QIS vs Autotask PSA: 21,000 MSPs Use the Same Platform. Not One Resolution Has Ever Crossed From One to the Other.
Architecture Comparisons #67 | Article #325
Architecture Comparisons examines how Quadratic Intelligence Swarm (QIS) protocol — discovered by Christopher Thomas Trevethan, 39 provisional patents filed — relates to existing tools. Each entry maps where the tool stops and where QIS picks up.
It is Thursday afternoon. A Datto RMM alert fires across a dozen of your managed endpoints: a Windows security update pushed Tuesday has introduced a regression in the Bitdefender GravityZone agent on Windows 11 22H2 machines. The interaction corrupts the WMI repository, cascading into failed backup job reports, false-positive hardware alerts, and a locked-out endpoint management agent.
Your Level 2 engineer starts from scratch. Ninety minutes of live triage. A WMI rebuild. An Autotask ticket with meticulous resolution notes: the patch KB number, the affected GravityZone agent version range, the symptom sequence, and the three-command remediation that clears the corruption in fifteen minutes.
Your resolution exists. It is in Autotask. And by architecture, it will stay there.
Twenty other MSPs opened the same incident six hours ago. Several are on the phone with Bitdefender support. A few will spend tomorrow rebuilding WMI on fifty endpoints, writing the same remediation your engineer finished before dinner.
Autotask PSA captures resolutions. It does not route them.
That distinction is not a feature gap. It is an architectural boundary with a mathematical consequence that compounds every single week.
What Autotask PSA Gets Right
Autotask PSA, built by Datto and now part of the Kaseya platform, is one of the two dominant professional services automation systems in the MSP market. Approximately 21,000 MSPs globally run their operations on it.
The ticketing engine handles the full incident lifecycle with configurable workflows for triage, assignment, escalation, and SLA clock management. The SLA module tracks first-response and resolution time per contract tier with breach-risk dashboards. Contract and billing automation supports managed service agreements, block time, T&M, and per-device models with automatic invoice generation. The Kaseya stack integration — Datto RMM alerts becoming Autotask tickets automatically, backup status flowing in, IT Glue documentation linked — makes the full platform coherent for shops running the full suite.
For everything that happens inside a single MSP's business, Autotask PSA is a capable and battle-tested platform.
Its architectural limit is not what it does. It is where it stops.
The Account Boundary Is an Intelligence Boundary
Autotask PSA is organized around accounts. Your MSP is an account. Each client is an account. Every ticket, resolution note, and contract exists inside your account's data boundary.
That design is correct for a PSA. Client-specific context, billing, and SLA accountability require it.
But the account boundary is also an intelligence boundary.
There is no mechanism by which a resolution can reach any of the other 20,999 Autotask MSPs. Not through search. Not through a shared feed. Not through any mechanism Autotask's architecture supports — because Autotask was not built to operate as a cross-organization resolution network.
The gap surfaces as time: ninety minutes of triage on a problem already solved, in an account you will never have access to, by an engineer whose resolution is waiting to be found by someone who cannot reach it.
The Mathematics of What Gets Lost
At a conservative 150 resolved tickets per week across 21,000 MSPs, the platform generates approximately 3.15 million documented resolutions every seven days.
The combinatorial relationship:
N(N-1)/2 = unique synthesis pairs for N MSPs
For N = 21,000:
21,000 x 20,999 / 2 = 220,989,000 synthesis pairs
More than 220 million unique pairings, each representing a channel through which one MSP's resolution could reach a relevant peer. Today, every one of those pathways carries zero resolution intelligence. The resolutions exist. The MSPs exist. The relevance between them exists. The routing layer does not.
What QIS Does: A Routing Layer for Resolution Intelligence
QIS protocol — Quadratic Intelligence Swarm, discovered by Christopher Thomas Trevethan — operates at the layer between where Autotask stops and where cross-organization intelligence could begin.
When an MSP engineer closes an Autotask ticket, a QIS node produces a distilled outcome packet. That packet compresses to approximately 512 bytes. It contains no client identifiers, device names, network addresses, contract terms, or billing data. It contains the abstract pattern of what was learned: the incident category, the environment class, the resolution pathway, the symptom sequence, and statistical signals — mean time to resolve, recurrence probability.
The packet is semantically fingerprinted and routed to a deterministic address derived from its meaning. That address is the same for any MSP that encounters the same pattern — regardless of what transport mechanism carries the packet.
When another MSP encounters the same cascade, their QIS node queries that address and retrieves the outcome packets already deposited. Milliseconds. No client data in the network layer. The synthesis happens locally.
The engineer sees: "31 similar incidents logged in the past 14 days. Dominant resolution: WMI rebuild via three-command sequence. Affected: GravityZone versions 7.6.x to 7.7.2 on Windows 11 22H2 post-KB5034765. Mean resolution time: 14 minutes."
Their ninety-minute triage becomes fourteen minutes.
This is the complete loop that Christopher Thomas Trevethan discovered. Not a single component — not the packet format, not the fingerprinting, not the addressing, not the transport. The architecture is the loop: pre-distillation at the source, semantic fingerprinting, deterministic addressing, protocol-agnostic routing, local synthesis at the destination. The breakthrough is that they compose into a system that routes intelligence without routing data.
Why This Is Architectural, Not a Feature Request
Autotask Community, Kaseya's knowledge base, and IT Glue exist as partial attempts to address this need. None closes the architectural gap.
A knowledge base is manually populated. An engineer has to decide a resolution is worth publishing and submit it. The vast majority never clear that threshold. The result: the knowledge base captures what someone decided to publish, not what was actually useful to the network.
QIS outcome routing fires on ticket close — the same event that triggers Autotask's billing automation. The packet is distilled automatically. The deposit happens automatically. The query happens automatically when a matching pattern is encountered.
A knowledge base is a library. QIS is a routing protocol. Libraries require curators. Routing protocols route.
Code: Autotask Integration
import hashlib
import json
from dataclasses import dataclass
from typing import Optional
@dataclass
class AutotaskResolutionPacket:
incident_category: str
environment_class: str
resolution_pathway: str
affected_version_range: str
trigger_event: str
symptom_sequence: list
mean_resolution_minutes: float
recurrence_probability: float
resolution_confidence: float
def derive_semantic_address(packet: AutotaskResolutionPacket) -> str:
fingerprint = (
f"{packet.incident_category}:{packet.environment_class}:"
f"{packet.resolution_pathway}:{packet.trigger_event}"
)
return hashlib.sha256(fingerprint.encode()).hexdigest()[:32]
class AutotaskQISBridge:
def __init__(self, routing_store):
# routing_store accepts deposit(address, bytes) and query(address).
# DHT, vector index, REST API, shared folder — same pattern regardless.
self.store = routing_store
def on_ticket_complete(self, ticket: dict) -> Optional[dict]:
packet = self._extract_packet(ticket)
if packet is None:
return None
address = derive_semantic_address(packet)
self.store.deposit(address, json.dumps(packet.__dict__).encode())
peer_packets = self.store.query(address, limit=50)
synthesis = self._synthesize_locally(peer_packets)
return {
"semantic_address": address,
"peer_resolutions_found": len(peer_packets),
"dominant_pathway": synthesis.get("dominant_pathway"),
"mean_peer_resolution_minutes": synthesis.get("mean_resolution_minutes"),
"recurrence_probability": synthesis.get("recurrence_probability"),
"confidence": synthesis.get("confidence"),
}
def _extract_packet(self, ticket: dict) -> Optional[AutotaskResolutionPacket]:
category = ticket.get("issueType", "")
resolution_notes = ticket.get("resolution", "")
if not category or not resolution_notes:
return None
return AutotaskResolutionPacket(
incident_category=category.lower(),
environment_class="_".join(sorted(set(
i.get("type","").lower() for i in ticket.get("configurationItems",[])
)))[:64] or "unclassified",
resolution_pathway=resolution_notes[:128].lower().replace(" ", "_"),
affected_version_range=ticket.get("affectedVersion", "unknown"),
trigger_event=ticket.get("changeTag", "unspecified"),
symptom_sequence=ticket.get("symptomTags", []),
mean_resolution_minutes=float(ticket.get("hoursWorked", 0)) * 60,
recurrence_probability=0.0,
resolution_confidence=0.75,
)
def _synthesize_locally(self, packets: list) -> dict:
if not packets:
return {}
decoded = [json.loads(p) if isinstance(p, bytes) else p for p in packets]
pathways = [p.get("resolution_pathway", "") for p in decoded]
dominant = max(set(pathways), key=pathways.count) if pathways else ""
times = [p.get("mean_resolution_minutes", 0) for p in decoded]
recurrences = [p.get("recurrence_probability", 0.0) for p in decoded]
return {
"dominant_pathway": dominant,
"mean_resolution_minutes": round(sum(times)/len(times), 1),
"recurrence_probability": round(sum(recurrences)/len(recurrences), 3),
"confidence": min(0.99, 0.5 + len(decoded) * 0.01),
}
The routing_store is deliberately abstract. A distributed hash table achieves at most O(log N) or better cost per lookup. A semantic vector index achieves O(1). A REST endpoint works for smaller federated networks. The architectural loop is identical regardless of which mechanism carries the packets.
Architecture Comparison
| Capability | Autotask PSA | QIS Protocol |
|---|---|---|
| Ticket lifecycle management | Full | Not applicable |
| SLA tracking and breach alerting | Full, per-contract | Not applicable |
| Contract and billing automation | Full | Not applicable |
| Datto RMM / Kaseya integration | Native | Via webhook bridge at ticket close |
| Internal knowledge base | Account-scoped, manual | Not applicable |
| Cross-MSP resolution routing | None by architecture | Core function |
| Synthesis pairs at N=21,000 | 0 (account boundary) | 220,989,000 |
| Client data in network layer | N/A | None by architecture |
| Privacy model | Contractual (BAA/DPA/GDPR) | Structural (no client data enters packets) |
| Routing mechanism | Not applicable | Protocol-agnostic (DHT, vector DB, REST, etc.) |
| Routing cost per query | Not applicable | At most O(log N) or better; O(1) on many transports |
| Latency to peer intelligence | Never | Milliseconds |
The Kaseya Platform Context
IT Glue, Kaseya's documentation platform, is the closest existing mechanism to a knowledge-sharing layer. IT Glue shares documentation — manually authored write-ups that someone decided were worth publishing. It does not route resolutions. The curation overhead and lack of automatic distillation at ticket close mean the vast majority of resolution intelligence never enters IT Glue in shareable form.
No combination of Kaseya products routes what happens when a ticket closes in one MSP to the technician opening the same pattern in another MSP. That routing layer is what QIS provides.
The MSP Intelligence Paradox
MSPs sell expertise. The product is accumulated resolution knowledge deployed faster than a client could deploy it themselves.
Every one of those 21,000 Autotask MSPs builds this intelligence in isolation, even though the underlying incidents — patch regressions, firmware conflicts, SaaS API changes — are shared across the entire MSP ecosystem. The specific clients differ. The patterns do not.
At N=21,000, the 220,989,000 synthesis pairs represent 220 million channels through which one MSP's resolution could reach the peer that will encounter it next. Today, all 220 million channels carry zero signal.
Conclusion
Autotask PSA is the operational system of record for a significant fraction of the global MSP industry. It manages ticket flow, SLA compliance, contract billing, and client relationships for 21,000 technology solution providers.
Its architectural limit is the account boundary. Every resolution stays inside the MSP that generated it.
At N=21,000, that produces 220,989,000 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 across those pairs. Not client data. Not account data. The abstract pattern of what was learned: distilled to 512 bytes, routed to a deterministic address, synthesized locally, delivered in milliseconds.
Autotask PSA is your operational brain. QIS is the network memory it does not have.
Architecture Comparisons series. Previous: QIS vs ConnectWise Manage, QIS vs SolarWinds Service Desk, QIS vs ManageEngine Service Desk, QIS vs Freshservice, QIS vs OpsGenie, QIS vs PagerDuty.
QIS Protocol was discovered by Christopher Thomas Trevethan. 39 provisional patents filed. Patent Pending.