QIS vs ConnectWise Manage: Your PSA Captures Every Ticket Your MSP Resolves. It Has Never Routed One Resolution to the 24,999 Other MSPs Who Will See the Same Issue Tomorrow.

Architecture Comparisons #66 | Article #324

Architecture Comparisons is a running series examining how Quadratic Intelligence Swarm (QIS) protocol — discovered by Christopher Thomas Trevethan, 39 provisional patents filed — relates to existing tools and platforms. Each entry takes one tool, maps where it stops, and shows where QIS picks up.

It is Tuesday morning. A Microsoft 365 OAuth token rotation pushed by Microsoft over the weekend has silently broken email sync for three of your managed clients. The error surfaces as a cascade: Exchange connector failures, Teams authentication prompts, and shared mailbox permission errors that look like three separate incidents until your Level 2 engineer recognizes the underlying pattern.

Forty minutes of triage. A ConnectWise ticket for each client. A detailed resolution note documenting the token re-authentication sequence, the affected connector versions, and the PowerShell remediation script your engineer just wrote. The fix goes into your knowledge base as a ConnectWise procedure entry.

Your clients are back online by noon. You close the tickets. The documentation is good.

What your documentation will never do — what ConnectWise Manage's architecture makes structurally impossible — is reach the 24,999 other MSPs on the ConnectWise platform who are watching the same OAuth failure cascade appear in their client tickets right now. Some of them are on their second hour of triage. Some are escalating to Microsoft. Several will spend the rest of the week writing the same PowerShell script your engineer finished at 10am.

That knowledge exists. It is sitting in your ConnectWise account. And the architecture of the platform means it will stay there.

ConnectWise Manage captures resolutions. It does not route them.

That is an architectural distinction. And it has a mathematical consequence.

What ConnectWise Manage Gets Right

ConnectWise Manage is the operational system of record for professional services automation in the MSP industry. The platform was not designed to do one thing — it was designed to run an entire managed service business, end to end, and it does that with the depth of a product that has been refined for decades in the MSP market.

The ticketing system is the operational core. Service tickets capture every client interaction: the initial symptom report, the triage steps, the resolution, the time entries, the communication log. Ticket templates enforce consistent documentation across your team. Automated workflows route incoming issues to the right board, assign them to the right tier, and escalate when SLA thresholds approach. When your engineer closes a ticket, the record of what happened is preserved — who worked it, how long it took, and what fixed it.

The project management layer handles the structured work that MSPs do alongside break-fix: deployments, migrations, onboardings, lifecycle refreshes. Projects tie to boards, boards tie to time entries, time entries drive billing — the accounting integration closes the loop from delivery to invoice without manual reconciliation.

The CRM and agreement management modules are equally important for MSP operations. ConnectWise tracks the managed service agreements that define what your clients have contracted, which assets are under management, and which billable thresholds apply. Automated billing pulls from time entries and agreement configurations, reducing the manual reconciliation that historically consumed hours per billing cycle.

The reporting layer provides visibility into the metrics that matter for MSP business health: ticket volume by client, technician utilization, SLA performance, recurring revenue, contract profitability. These are not decorative dashboards — they are the inputs to operational decisions about staffing, pricing, and client tier management.

The integrations matter too. ConnectWise Manage connects to ConnectWise Automate (RMM) for automated ticket creation from endpoint alerts, to ConnectWise Sell for quoting and procurement, and to third-party tools across security, documentation, backup, and monitoring. The ecosystem is broad because ConnectWise has built it over twenty-plus years of MSP-focused development.

For the work that happens inside your MSP — ticket flow, project delivery, client management, billing, reporting — ConnectWise Manage is a capable and battle-tested platform.

The architectural limit is not what ConnectWise does. It is where it stops.

Where ConnectWise Manage Stops: The Company Boundary Is an Intelligence Boundary

ConnectWise Manage is organized around companies. Your MSP is a company. Each of your managed clients is a company. Every ticket, procedure, configuration item, and resolution note is scoped to one of those company records.

That scoping is the product's design. It enables client-specific context, client-specific billing, and client-specific SLA tracking. It is not a flaw.

But that company boundary is also an intelligence boundary.

Every resolution your engineers document in a ConnectWise ticket note stays inside your ConnectWise account. Every procedure entry your senior engineer writes after solving a novel problem lives in your ConnectWise procedure library. Every pattern your team recognizes across tickets — "every time we see error code 0x8004011D on Exchange, the resolution is always a connector credential rotation" — is knowledge that lives exclusively in your environment.

There is no mechanism in ConnectWise's architecture for a resolution documented in your account to reach another MSP.

This is not a criticism of ConnectWise. It is a description of what professional services automation software is built to do. ConnectWise is built to run your MSP. It is not built to operate as a network that routes resolution intelligence between 25,000 independently operating MSPs. That is a categorically different architectural problem.

But the consequence is real, and it compounds every week.

The Mathematics of What Gets Lost

ConnectWise products are used by approximately 25,000 technology solution providers globally. A mid-sized MSP managing 200 clients might open and close 300 to 500 service tickets per week. Across 25,000 MSPs at even a conservative 200 resolutions per week, the platform is generating on the order of 5 million documented resolutions every week.

Each of those resolutions is, in principle, useful intelligence for some number of the other 24,999 MSPs. Not every resolution is relevant to every other MSP — a specialist in healthcare IT infrastructure has different relevant twins than a generalist MSP serving SMBs in retail. But every MSP has relevant twins: firms managing similar client profiles, similar stack configurations, similar SLA commitments, similar geographic concentrations of client industry.

The architecture of ConnectWise Manage means that zero of those 5 million weekly resolutions cross the account boundary. The intelligence sits in 25,000 separate silos. When a new issue emerges — a Microsoft patch that breaks a dependency, a firmware update that introduces an intermittent hardware fault, a security tool update that conflicts with endpoint management — each MSP encounters it fresh.

The formal framing uses a combinatorial relationship. If N is the number of MSPs on the platform, the number of unique MSP-to-MSP synthesis pairs is N(N-1)/2.

For N = 25,000:

25,000 × 24,999 / 2 = 312,487,500 synthesis pairs

More than 312 million unique pairings, each representing a potential channel through which one MSP's resolution could reach a relevant peer. Today, every one of those pathways carries zero information. The resolutions exist. The MSPs exist. The relevance exists. The routing layer does not.

What QIS Does: Routing Resolution Intelligence Without Sharing Client Data

QIS protocol — Quadratic Intelligence Swarm, discovered by Christopher Thomas Trevethan — was designed to close exactly this kind of gap. The architecture operates at the layer between where a platform like ConnectWise stops and where cross-organization intelligence could begin.

The mechanism is outcome packets. When an MSP engineer closes a ticket, a QIS node running alongside the ConnectWise instance produces a distilled summary of what was learned. That summary is compressed to approximately 512 bytes. It contains no client identifiers, no client names, no network topology, no configuration specifics, no billing information. What it contains is the abstract pattern of the resolution: what category of incident this was, what class of environment was affected, what resolution pathway succeeded, what symptoms preceded the fix.

The outcome packet is semantically fingerprinted and routed to a deterministic address that reflects its meaning. "Exchange OAuth token rotation failure in Microsoft 365 connector, hybrid environment, resolution via PowerShell credential refresh" maps to an address that is the same across any MSP that encounters the same pattern — regardless of which routing mechanism carries it. This is a property of the semantic addressing, not of any specific transport.

When another MSP's ConnectWise instance encounters the same pattern — Exchange connector failures, Teams authentication prompts, shared mailbox permission errors — their QIS node queries the same address and retrieves the outcome packets that are already there. A small number of 512-byte packets. Delivered in milliseconds. No client data in the network layer.

The synthesis happens locally. The receiving MSP's node reads the packets, aggregates the resolution patterns, and surfaces the most common successful pathway. The engineer sees: "47 similar incidents logged across the network in the past 30 days. Dominant resolution: PowerShell token re-authentication with connector version 4.1.2 or later. Mean resolution time: 18 minutes. Recurrence signal: 12% recurrence rate within 30 days if token rotation is not automated."

Their 40-minute triage becomes an 18-minute resolution. The knowledge that existed in the network reached them before they had to rediscover it.

The Difference From ConnectWise Manage's Knowledge Base

ConnectWise Manage includes knowledge base functionality. Procedure entries, documentation templates, and ticket notes can be organized and searched within your account. Some MSPs use this extensively and develop rich internal libraries.

The architectural difference is the boundary.

Your knowledge base contains what your engineers have learned. A QIS outcome packet network contains what every participating MSP has learned — filtered to the resolutions that are semantically relevant to your current incident, and delivered without any of the client-specific context that created them.

This is not a replacement for your ConnectWise knowledge base. It is a layer that operates at a scale no single MSP's knowledge base can reach.

The parallel is exact: ConnectWise gives you a record of what you have resolved. QIS routes what the network has resolved, filtered to what matters for your current incident, before you have to rediscover it.

The Implementation Architecture

A QIS node integrated with ConnectWise Manage connects at the ticket closure point. In practice, this means a webhook or API listener that fires when a ticket transitions to a closed status.

import hashlib
import json
from dataclasses import dataclass, field
from typing import Optional

@dataclass
class MSPResolutionPacket:
    """
    QIS outcome packet for MSP incident resolution.
    Contains no client identifiers, no client names,
    no network topology, no billing data.
    Only the abstract pattern of what was learned.
    """
    incident_category: str          # e.g., "auth.oauth.token_rotation"
    environment_class: str          # e.g., "m365_hybrid_exchange"
    resolution_pathway: str         # e.g., "powershell_credential_refresh"
    connector_version_affected: str # e.g., "4.1.x"
    symptom_sequence: list[str]     # e.g., ["exchange_connector_failure", "teams_auth_prompt"]
    mean_resolution_minutes: float
    recurrence_signal: float        # 0.0-1.0 probability of recurrence within 30 days
    resolution_confidence: float    # 0.0-1.0 based on successful resolutions in packet history

def derive_semantic_address(packet: MSPResolutionPacket) -> str:
    """
    Deterministic address from incident pattern.
    Any MSP seeing the same pattern queries the same address.
    """
    fingerprint = f"{packet.incident_category}:{packet.environment_class}:{packet.resolution_pathway}"
    return hashlib.sha256(fingerprint.encode()).hexdigest()[:32]

class ConnectWiseQISBridge:
    """
    Bridges ConnectWise Manage ticket closures to QIS outcome routing.
    Fires on ticket close webhook. Deposits to network. Queries for peers.
    """
    def __init__(self, routing_store):
        self.store = routing_store  # Any routing mechanism: DHT, vector DB, REST API, etc.

    def on_ticket_closed(self, ticket: dict) -> Optional[dict]:
        packet = self._extract_packet(ticket)
        if packet is None:
            return None

        address = derive_semantic_address(packet)

        # Deposit: this resolution is now available to relevant peers
        self.store.deposit(address, packet.__dict__)

        # Query: what have relevant peers already learned?
        peer_packets = self.store.query(address, limit=50)
        synthesis = self._synthesize(peer_packets)

        return {
            "address": address,
            "peer_resolutions_found": len(peer_packets),
            "dominant_pathway": synthesis.get("dominant_pathway"),
            "mean_peer_resolution_minutes": synthesis.get("mean_resolution_minutes"),
            "recurrence_signal": synthesis.get("recurrence_signal"),
            "confidence": synthesis.get("confidence")
        }

    def _extract_packet(self, ticket: dict) -> Optional[MSPResolutionPacket]:
        category = ticket.get("resolution_category", "")
        if not category:
            return None
        return MSPResolutionPacket(
            incident_category=self._normalize_category(ticket),
            environment_class=self._extract_environment_class(ticket),
            resolution_pathway=self._extract_resolution_pathway(ticket),
            connector_version_affected=ticket.get("affected_version", "unknown"),
            symptom_sequence=ticket.get("symptom_tags", []),
            mean_resolution_minutes=ticket.get("actual_hours", 0) * 60,
            recurrence_signal=0.0,
            resolution_confidence=0.8
        )

    def _synthesize(self, packets: list) -> dict:
        if not packets:
            return {}
        pathways = [p.get("resolution_pathway", "") for p in packets]
        dominant = max(set(pathways), key=pathways.count) if pathways else ""
        mean_minutes = sum(p.get("mean_resolution_minutes", 0) for p in packets) / len(packets)
        recurrence = sum(p.get("recurrence_signal", 0) for p in packets) / len(packets)
        return {
            "dominant_pathway": dominant,
            "mean_resolution_minutes": round(mean_minutes, 1),
            "recurrence_signal": round(recurrence, 3),
            "confidence": min(0.99, 0.5 + len(packets) * 0.01)
        }

    def _normalize_category(self, ticket: dict) -> str:
        return ticket.get("board_name", "general").lower().replace(" ", "_")

    def _extract_environment_class(self, ticket: dict) -> str:
        config_items = ticket.get("config_items", [])
        return "_".join(sorted(set(
            item.get("type", "unknown") for item in config_items
        )))[:64]

    def _extract_resolution_pathway(self, ticket: dict) -> str:
        notes = ticket.get("resolution_notes", "")
        return notes[:128].lower().replace(" ", "_") if notes else "undocumented"

The routing store in this implementation is deliberately abstract. Any mechanism that can accept a 512-byte packet at a deterministic address and return matching packets from other participants qualifies. A DHT achieves this at O(log N) or better routing cost and full decentralization. A semantic vector index achieves it at O(1) lookup with a managed backend. A simple REST API with a well-designed endpoint achieves it for smaller networks. The architectural pattern is the same regardless of transport — because the pattern is the loop, not the mechanism.

Architecture Comparison

Capability ConnectWise Manage QIS Protocol
Ticket lifecycle management Full (create, triage, route, escalate, close) Not applicable — operates post-close
Agreement and billing automation Full Not applicable
Client asset management Full Not applicable
RMM integration (Automate) Native Via API bridge
Knowledge base (internal) Account-scoped Not applicable
Cross-MSP resolution routing None by architecture Core function
Synthesis pairs at N=25,000 0 (account boundary) 312,487,500
Client data in network layer N/A None by architecture (packets are abstract patterns)
Privacy model Contractual (BAA/DPA) Structural (no client data in outcome packets)
Routing mechanism Not applicable Protocol-agnostic (DHT, vector DB, API, etc.)
Latency to peer intelligence Never — cross-account intelligence does not exist Milliseconds

The MSP Use Case Is Distinctive

The MSP context carries a particular property that makes QIS routing especially valuable: MSPs are already organized around the idea of selling intelligence.

An MSP's product is not the hours its engineers log. It is the accumulated expertise those engineers carry — the knowledge of what breaks, why it breaks, and how to fix it faster than a client could fix it themselves. That expertise is the differentiation. MSPs with deeper resolution knowledge close tickets faster, maintain better SLAs, and retain clients at higher rates.

The paradox is that every MSP builds this intelligence in isolation. An MSP that has handled 2,000 Microsoft 365 migrations has absorbed every edge case, failure mode, and remediation pattern across those projects. That knowledge lives in the engineers' heads and in ConnectWise ticket notes. It does not flow to the MSP down the road that is about to handle migration number one.

QIS outcome routing does not expose the client context that makes each MSP's work proprietary. It routes the abstract pattern of what was learned — the category of problem, the class of environment, the resolution pathway, the recurrence signal. That is the layer of intelligence that every MSP needs and none of them can share through any current architectural path.

The 312 million synthesis pairs at N=25,000 are not a theoretical number. They represent the resolution intelligence that the MSP ecosystem generates every week and loses at every account boundary.

What QIS Does Not Replace

QIS protocol does not replace ConnectWise Manage. The PSA functions that make ConnectWise the operational backbone of MSP businesses — ticket management, project delivery, agreement automation, billing, client relationship records — operate at a different layer entirely. Those functions require client-specific context, client-specific history, and client-specific accountability. QIS outcome packets deliberately strip that layer out.

The relationship is complementary and non-overlapping. ConnectWise manages the client relationship and the operational workflow. QIS routes the abstract intelligence that the operational workflow generates, to the participants who can benefit from it, without the client context that created it ever entering the network.

Neither system does what the other does. The gap between them is the architectural space where 312 million synthesis pairs currently carry no information.

The Broader ITSM and MSP Architecture Pattern

This series has now examined the same architectural gap across a wide range of service management and operations platforms:

The pattern is the same across every platform: the intelligence that operations work generates is captured inside the platform's organizational boundary and never routes beyond it.

That is not a criticism of these platforms. It is a description of what ITSM, PSA, and service management software is built to do. Each platform is built to run one organization's operations. None of them were designed to operate as a network for routing resolution intelligence between organizations.

QIS protocol operates at the layer these platforms leave open. The architecture that Christopher Thomas Trevethan discovered — pre-distilled outcome packets, semantic fingerprinting, deterministic addressing, local synthesis — closes the gap that every one of these platforms has by design.

Conclusion

ConnectWise Manage is the operational system of record for the MSP industry. It runs ticket flow, project delivery, billing, and client relationship management for tens of thousands of technology solution providers. For everything that happens inside a single MSP's business, it is a deep and capable platform.

Its architectural limit is the account boundary. Every resolution a ConnectWise MSP documents stays inside their account. Every pattern their engineers recognize belongs to their knowledge base. Every hard-won fix for a novel Microsoft patch behavior or a connector compatibility failure is available only to them.

At N=25,000 MSPs on the platform, that produces 312,487,500 synthesis pairs that currently carry zero resolution intelligence.

QIS protocol — Quadratic Intelligence Swarm, discovered by Christopher Thomas Trevethan, 39 provisional patents filed — routes outcome packets between those pairs. Not client data. Not account data. The abstract pattern of what was learned, routed to the participants for whom it is relevant, synthesized locally, in milliseconds.

ConnectWise knows what you resolved.

QIS routes what the network resolved — filtered to what matters for your current incident, before you have to rediscover it.

This article is part of the Architecture Comparisons series. Previous entries: QIS vs PagerDuty, QIS vs OpsGenie, QIS vs Freshservice, QIS vs ManageEngine Service Desk, QIS vs SolarWinds Service Desk.

QIS Protocol was discovered by Christopher Thomas Trevethan. 39 provisional patents filed. Patent Pending.