Sofia, a senior backend engineer, closes a task in Asana: "Implement idempotency layer for payment webhook retries."
It took her team 18 days. The solution involved a Redis-backed idempotency key store, a retry budget policy capped at five attempts with exponential backoff, and a dead-letter queue that triggers a Slack alert after the third failed retry. The task is tagged. The completion notes are thorough. The Asana board looks clean.
Somewhere in Asana, across 139,000 paying organizations, 47 other teams are building the same thing right now. Some of them are on day three. Some are about to discover the same Redis lock contention issue Sofia's team hit on day nine. One of them is about to get paged at 2am for the exact failure mode Sofia's team documented in their completion notes.
Sofia's outcome never routes to them.
That is not a bug in Asana. Asana is doing exactly what it is designed to do: track tasks, assign ownership, hit deadlines, move projects forward. It is doing it extraordinarily well for over a hundred thousand organizations worldwide.
The gap is not a missing feature. It is a boundary. Asana is the coordination layer for work that needs to get done. It is not the intelligence layer for what was learned when work got done. No project management tool is.
Quadratic Intelligence Swarm closes that gap. This article is about where Asana stops and where QIS begins.
What Asana Is Built For
Asana is genuinely excellent at what it does. That is worth saying clearly before drawing any architectural boundaries, because the boundary only makes sense if you understand what sits on each side of it.
Asana gives organizations task ownership at scale. A task in Asana has an assignee, a due date, a project, a priority level, a set of subtasks, attachments, comments, and a history. When a task moves from "In Progress" to "Complete," everyone who needs to know is notified. That transition is logged. It can trigger automations: move a dependent task to "Ready," notify a stakeholder, update a portfolio dashboard.
At the portfolio level, Asana gives leadership a real-time view across every project in flight. Which initiatives are on track? Which are blocked? Where are the resourcing bottlenecks? Asana surfaces this without requiring anyone to send a status update email. The data is live.
Asana's workflow automation layer — Rules, in their terminology — handles the repetitive coordination logic that eats engineering and operations teams alive. When a task is marked complete, move the next task to the top of the queue. When a new task is added to a project, assign it to the current sprint owner. These automations are not trivial. They encode real organizational logic that would otherwise require constant human intervention.
The intake workflows Asana builds for cross-functional teams are legitimate infrastructure. A product request form that routes to the right team, auto-populates fields based on request type, and drops a structured task into the right project — that is coordination work that used to require a dedicated operations person. Asana automates it.
This is what Asana is built for. Coordination: ensuring that every piece of work has an owner, a deadline, a context, and a chain of accountability. For that problem, Asana is one of the best tools ever built.
The Boundary: Where Asana Stops
Asana tracks tasks. It does not learn from them.
When Sofia's team closed the idempotency layer task after 18 days, Asana recorded a completion event. The task moved to done. The completion notes went into the task detail. The time tracking data, if they used it, sat in the task history. The tags they applied — "payments," "reliability," "webhooks" — are visible to anyone who searches that project.
But those 18 days contained something more than a completion event. They contained a solution path. A failure mode discovered on day nine. A decision between two architectural options with a recorded rationale. A performance benchmark that ruled out one approach. A dead-letter queue design that turned out to be reusable across three other services.
None of that routes anywhere.
It cannot route, because Asana's architecture does not have a routing layer for task outcomes. Asana's data model is organized around projects and teams, not around task type similarity across organizations. A completed task lives in a project. It can be copied, templated, duplicated within your organization. It cannot participate in a cross-organizational synthesis of similar completed tasks.
The intelligence in that completed task — what worked, what failed, how long it actually took for that specific problem type, which architectural decisions proved correct six months later — has no address. It has no destination. It does not move.
This is not a design flaw. Routing task outcomes across organizational boundaries is not what project management software is supposed to do. Asana's privacy model, its multi-tenant architecture, its user trust model — all of them correctly prevent Sofia's task data from being read by other organizations.
The gap is structural. The coordination layer (Asana) and the intelligence layer (what QIS handles) are different systems solving different problems. Asana solved coordination at a world-class level. The intelligence layer above task completion does not yet exist as a protocol.
That is the boundary.
QIS Starts at That Boundary
The math of the gap is instructive.
Asana had 139,000+ paying organizations as of their last public filings. Each completed task at one organization is potentially relevant to similar tasks at other organizations. Not all tasks. Not most tasks. But for any given task type — "implement idempotency layer," "migrate database schema with zero downtime," "evaluate vendor for cloud storage," "design API rate limiting policy" — there are clusters of teams working on structurally identical problems.
The number of organization pairs in Asana is:
N(N-1)/2 = (139,000 x 138,999) / 2 = approximately 9.66 billion synthesis pairs
Every one of those pairs is currently at zero. Not because the data does not exist. The completion notes, the time tracking, the architectural decisions — that data exists, distributed across 139,000 organizations. The pairs are at zero because there is no routing protocol. There is no way for a completed task at one organization to find its twins at other organizations and synthesize what was learned.
QIS is the protocol for that routing layer.
The core architecture of QIS — Quadratic Intelligence Swarm — is a complete loop: every outcome routes to its semantic address, every address accumulates outcome packets from structurally similar tasks, every new task with a matching fingerprint can query that address before spending 18 days rediscovering what Sofia's team already documented. The breakthrough is the loop itself. Not the addressing scheme. Not the transport. Not the synthesis method. The complete closed loop between task completion, outcome routing, and task intelligence.
This is the architecture Christopher Thomas Trevethan discovered on June 16, 2025. The loop had not been closed before. 39 provisional patent applications have been filed. Patent Pending.
The Code Layer: What Outcome Routing Looks Like
The following is a reference implementation of an Asana outcome router. It is transport-agnostic: the same packet structure routes over a vector database, a DHT, a SQLite index, or a REST API endpoint. The transport choice does not change the protocol.
import hashlib
import json
import time
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class AsanaTask:
task_id: str
title: str
description: str
completion_notes: str
time_spent_days: float
outcome_type: str # e.g. "success", "partial", "escalated"
domain: str # e.g. "payments", "infrastructure", "vendor-ops"
tech_stack: list[str] # e.g. ["redis", "python", "postgres"]
tags: list[str] = field(default_factory=list)
team_size: Optional[int] = None
@dataclass
class OutcomePacket:
semantic_address: str # deterministic, based on task type + domain + stack
fingerprint: str # 64-byte hex hash
payload: dict # compressed outcome data, target ~512 bytes
timestamp: float
transport_hint: str # advisory only, not required
class AsanaOutcomeRouter:
"""
Post-completion outcome router for Asana tasks.
This runs AFTER Asana marks a task complete. It is additive to Asana,
not a replacement. Asana continues to own task coordination. This router
handles outcome intelligence: distilling what was learned and routing it
to the semantic address where structurally similar task outcomes accumulate.
Transport-agnostic: the same OutcomePacket can be routed via vector DB,
DHT, SQLite, REST API, or any other transport. The protocol is the packet
structure and the addressing scheme, not the transport layer.
"""
STACK_NORMALIZE_MAP = {
"postgresql": "postgres",
"pg": "postgres",
"redis-cluster": "redis",
"aws-lambda": "lambda",
"gcp-cloud-functions": "cloud-functions",
}
def __init__(self, transport=None):
# transport=None runs in dry-run mode (returns packet without routing)
# pass a transport adapter to route: VectorDBTransport, DHTTransport,
# SQLiteTransport, RESTTransport, etc.
self.transport = transport
def _normalize_stack(self, stack: list[str]) -> list[str]:
normalized = []
for item in stack:
key = item.lower().strip()
normalized.append(self.STACK_NORMALIZE_MAP.get(key, key))
return sorted(set(normalized))
def _build_semantic_address(self, task: AsanaTask) -> str:
"""
Deterministic semantic address based on task type + domain + stack.
Two tasks with the same type, domain, and stack signature route to
the same address. This is how task twins find each other.
"""
normalized_stack = self._normalize_stack(task.tech_stack)
title_tokens = task.title.lower().replace("-", " ").split()
type_signal = "_".join(title_tokens[:4])
stack_signature = "-".join(normalized_stack[:3])
raw_address = f"{task.domain}::{type_signal}::{stack_signature}"
return raw_address
def _fingerprint(self, semantic_address: str, task: AsanaTask) -> str:
"""
64-byte deterministic fingerprint. Same task type + domain + stack
produces the same fingerprint prefix, enabling twin lookup.
"""
content = f"{semantic_address}|{task.outcome_type}|{task.time_spent_days:.1f}"
return hashlib.sha256(content.encode()).hexdigest()
def _distill_payload(self, task: AsanaTask) -> dict:
"""
Distills a completed Asana task into a ~512-byte outcome packet.
Strips PII, project-specific identifiers, and org-specific context.
Retains the transferable intelligence: what worked, what failed,
how long, which architectural choices, outcome type.
"""
notes_signal = task.completion_notes[:300] if task.completion_notes else ""
payload = {
"outcome": task.outcome_type,
"days": round(task.time_spent_days, 1),
"domain": task.domain,
"stack": self._normalize_stack(task.tech_stack),
"notes": notes_signal,
"team_size": task.team_size,
# task_id and org identifiers intentionally omitted
}
raw = json.dumps(payload)
if len(raw.encode()) > 512:
payload["notes"] = notes_signal[:150] + "..."
return payload
def build_packet(self, task: AsanaTask) -> OutcomePacket:
semantic_address = self._build_semantic_address(task)
fingerprint = self._fingerprint(semantic_address, task)
payload = self._distill_payload(task)
return OutcomePacket(
semantic_address=semantic_address,
fingerprint=fingerprint,
payload=payload,
timestamp=time.time(),
# Advisory: DHT for cross-org, vector DB for semantic search,
# SQLite for local/offline, REST for managed deployment.
# The protocol works over any of them.
transport_hint="vector_db|dht|sqlite|rest",
)
def route(self, task: AsanaTask) -> OutcomePacket:
"""
Main entry point. Call this after Asana marks a task complete.
Returns the OutcomePacket regardless of transport (for logging/audit).
If no transport is configured, runs in dry-run mode.
"""
packet = self.build_packet(task)
if self.transport is not None:
self.transport.post(
address=packet.semantic_address,
fingerprint=packet.fingerprint,
payload=packet.payload,
)
else:
print(f"[dry-run] Packet built for address: {packet.semantic_address}")
print(f"[dry-run] Fingerprint: {packet.fingerprint[:16]}...")
print(f"[dry-run] Payload size: {len(json.dumps(packet.payload))} bytes")
return packet
def query_twins(
self,
domain: str,
task_type_tokens: list[str],
tech_stack: list[str],
min_outcomes: int = 3,
) -> dict:
"""
Query: "What did other teams with similar tasks in similar stacks learn?"
Constructs the semantic address for the query and retrieves accumulated
outcome packets from task twins. Synthesizes what worked.
"""
normalized_stack = self._normalize_stack(tech_stack)
type_signal = "_".join(t.lower() for t in task_type_tokens[:4])
stack_signature = "-".join(normalized_stack[:3])
query_address = f"{domain}::{type_signal}::{stack_signature}"
if self.transport is None:
return {
"query_address": query_address,
"status": "dry_run",
"message": (
"In production: retrieves accumulated outcome packets "
f"from all teams whose tasks resolved to address '{query_address}'. "
f"Requires at least {min_outcomes} outcomes to synthesize."
),
}
raw_outcomes = self.transport.query(
address=query_address,
min_count=min_outcomes,
)
if not raw_outcomes:
return {"query_address": query_address, "outcomes": [], "synthesis": None}
outcome_types = [o["outcome"] for o in raw_outcomes]
time_values = [o["days"] for o in raw_outcomes if "days" in o]
notes = [o.get("notes", "") for o in raw_outcomes if o.get("notes")]
synthesis = {
"n": len(raw_outcomes),
"success_rate": outcome_types.count("success") / len(outcome_types),
"median_days": sorted(time_values)[len(time_values) // 2] if time_values else None,
"time_range": [min(time_values), max(time_values)] if time_values else None,
"outcome_distribution": {
ot: outcome_types.count(ot) for ot in set(outcome_types)
},
"note_signals": notes[:5],
}
return {
"query_address": query_address,
"outcomes": raw_outcomes,
"synthesis": synthesis,
}
if __name__ == "__main__":
router = AsanaOutcomeRouter(transport=None) # dry-run mode
sofia_task = AsanaTask(
task_id="asn_task_8847291",
title="Implement idempotency layer for payment webhook retries",
description=(
"Payment webhooks from Stripe are occasionally retried by the provider. "
"We need to ensure duplicate events do not trigger duplicate charges."
),
completion_notes=(
"Implemented Redis-backed idempotency key store with 24h TTL. "
"Retry budget: 5 attempts, exponential backoff starting at 2s. "
"Dead-letter queue triggers Slack alert after 3rd failure. "
"Discovered Redis lock contention on day 9 -- resolved by switching "
"from SETNX to SET NX PX with a 500ms lock timeout. "
"Final solution handles ~2,400 webhook events/min at p99 < 40ms."
),
time_spent_days=18.0,
outcome_type="success",
domain="payments",
tech_stack=["redis", "python", "postgres", "stripe"],
tags=["reliability", "webhooks", "idempotency"],
team_size=3,
)
packet = router.route(sofia_task)
print(f"\nOutcome packet routed to: {packet.semantic_address}")
result = router.query_twins(
domain="payments",
task_type_tokens=["implement", "idempotency", "layer", "payment"],
tech_stack=["redis", "python", "postgres"],
min_outcomes=3,
)
print(f"\nTwin query: {result['query_address']}")
print(f"Status: {result['status']}")
The router fires post-completion. Asana continues to own task coordination. The router handles the intelligence layer: what was learned routes to its semantic address, accumulates with structurally similar outcomes, and becomes available to task twins before they spend 18 days rediscovering what Sofia already documented.
The Architecture Stack
+------------------------------------------------------------------+
| ASANA LAYER |
| |
| Tasks Owners Deadlines Projects Portfolios |
| Subtasks Comments Attachments Automations Timelines |
| Workflows Forms Rules Status Reports |
| |
| World-class coordination. Every task has an owner. |
+------------------------------------------------------------------+
|
Task marked complete
|
v
+------------------------------------------------------------------+
| QIS BOUNDARY |
| |
| Outcome distillation from completed tasks |
| -- Strips PII and org-specific identifiers |
| -- Retains transferable intelligence (what worked, what failed, |
| how long, which architectural decisions, outcome type) |
| |
| Semantic fingerprinting |
| -- Task type + domain + stack -> deterministic address |
| -- Same address = task twins across all organizations |
| |
+------------------------------------------------------------------+
|
~512-byte outcome packet
|
v
+------------------------------------------------------------------+
| QIS ROUTING LAYER |
| |
| Deterministic addressing |
| -- Semantic address routes to accumulated twin outcomes |
| -- New tasks query before starting work |
| |
| Transport-agnostic |
| -- Vector DB | DHT | SQLite | REST API |
| -- Protocol is the packet structure, not the transport |
| |
| Synthesis |
| -- Aggregate: success rates, time distributions, note signals |
| -- Output: what worked for your exact task type and stack |
| |
+------------------------------------------------------------------+
|
v
+------------------------------------------------------------------+
| TASK TWIN INTELLIGENCE |
| |
| "47 teams solved this. Median: 14 days. Success rate: 89%. |
| Common failure mode on day 9: Redis lock contention. |
| Recommended start: SET NX PX with 500ms lock timeout" |
| |
+------------------------------------------------------------------+
Layer 1 is Asana. It is not replaced. It is not modified. It continues doing what it does.
Layer 2 is where QIS begins: the distillation of completed task outcomes into transferable packets with deterministic semantic addresses. This layer strips everything that cannot travel across organizational boundaries and retains everything that can.
Layer 3 is the routing protocol: transport-agnostic, deterministic, accumulative. Outcome packets from structurally similar tasks aggregate at shared addresses. Task twins find each other without knowing the other exists.
The breakthrough is the complete loop. Not any single layer. The loop closes when a new task of type X in domain Y on stack Z can query what every previous task of type X in domain Y on stack Z discovered before starting work. That loop did not exist before QIS.
Three Natural Forces
When the loop closes, three forces emerge. They are not features to be built. They are not mechanisms to configure. They emerge from the architecture the way compound interest emerges from a savings account: as an inevitable consequence of the loop running over time.
The domain expert signal. Someone in every organization defines what makes two tasks similar enough to route together. For engineering tasks, that might be a VP of Engineering calibrating the stack similarity threshold. For procurement tasks, it might be a procurement officer defining what counts as a "vendor evaluation" task type. This is not a product decision. It is a decision about who defines similarity — and that decision already exists in every organization, embedded in how they categorize and tag work. QIS surfaces it. It does not invent it.
The aggregate intelligence force. Suppose 500 engineering teams across Asana's 139,000 organizations have each completed a task roughly equivalent to "implement rate limiting on external API calls." Each of those completions produced outcome data: how long it took, which approach worked, which approach failed, what the edge cases were. The aggregate of those outcome packets, filtered to teams with your exact technology stack, is a synthesis that no individual team could produce. It is not scored. It is not ranked. It is simply the accumulated record of what happened when people who are structurally similar to you solved the same problem. That aggregate becomes more accurate every time another team completes a similar task.
The selection effect. Teams using outcome-routed task intelligence start work with the aggregate knowledge of their task twins. They avoid failure modes that are already documented. They start closer to working solutions. Their median completion time for recurring task types drops. Teams without access to that intelligence keep solving the same problems from scratch. The market does not need to enforce this. It selects for it automatically. The selection pressure is not dramatic or sudden. It is the same compounding effect that makes any systematic knowledge advantage durable over time.
These forces do not need to be built. They emerge when the loop closes.
Domain Scenarios
Healthcare: Clinical Trial Coordination
A clinical trial involves hundreds of task types that recur across sites: protocol deviation logging, IRB amendment submissions, site activation checklists, lab result reconciliation. Each site completes these tasks independently. The outcomes — how long each task type actually takes at sites with similar patient volume and staffing, which process adaptations worked, which compliance steps were commonly missed — do not route anywhere.
With outcome routing, a site activating for a new trial can query what similar sites learned during activation for the same therapeutic area and protocol type. The outcome packets from prior activations route to a semantic address that the new site can query before beginning. Deviation rates decrease. Activation timelines compress. The intelligence is already distributed across the network of completed tasks. The protocol routes it.
Manufacturing: Production Line Operations
A production facility manages hundreds of operational tasks: equipment calibration, quality inspection procedures, maintenance schedules, supplier qualification checks. Facilities running similar equipment on similar production volumes complete these tasks continuously. The outcomes — which calibration procedures work for your exact equipment configuration, which inspection sequences catch defects earliest, which maintenance intervals correlate with lowest downtime — do not travel between facilities.
With outcome routing, a facility facing a recurring equipment calibration task can query the aggregate outcomes from facilities with structurally similar equipment and production volume. The semantic address captures the task type, equipment class, and production context. What worked routes to where it is relevant.
Software Engineering: Architectural Decisions
Software teams make architectural decisions constantly. Database migration strategies, API versioning approaches, caching layer designs, authentication patterns. These decisions are made task by task, documented in Asana comments or completion notes, and archived in project history. They do not route to other teams making the same architectural decisions with the same stack.
With outcome routing, a team evaluating caching strategies for a read-heavy API on a specific stack can query the aggregate outcomes from teams who made similar decisions on similar stacks. Success rates by approach, median implementation time, common failure modes — all of that is already distributed across the network of completed tasks. QIS routes it to where it is needed before the work begins, not 18 days after it ends.
The Boundary Is a Description
The boundary between Asana and QIS is not a weakness in Asana. It is a description of where coordination ends and intelligence begins.
Coordination is the problem of ensuring that work gets done: that every task has an owner, a deadline, and a chain of accountability. Asana solves that problem at a level of sophistication and scale that represents years of deliberate product development. The 139,000 organizations using Asana are there because task coordination is genuinely hard and Asana does it well.
Intelligence is a different problem: ensuring that what was learned when work got done routes to where it is relevant. That the 18 days Sofia's team spent documenting a solution to a specific failure mode in a specific technology context becomes available to the 47 teams currently in the middle of the same problem. That the aggregate of all completed tasks of a given type, across all organizations, is accessible to the next team starting that task type.
No project management tool solves that problem. Not because they failed to build a feature, but because it is a different class of problem that requires a different class of protocol.
Asana tracks every task. QIS routes what was learned from each one.
The loop that closes that gap — outcome distillation, semantic addressing, transport-agnostic routing, twin synthesis — is the architecture of Quadratic Intelligence Swarm. It runs above Asana, not instead of it. It fires after task completion, not during task coordination. It is additive to the coordination layer, not competitive with it.
Sofia closed her task. The outcome packet routed to its address. The next team starting the same problem will not need 18 days.
QIS — Quadratic Intelligence Swarm — was discovered by Christopher Thomas Trevethan on June 16, 2025. 39 provisional patent applications filed. Patent Pending.
Patent Pending. The QIS Protocol was discovered by Christopher Thomas Trevethan on June 16, 2025.
Top comments (0)