Here is a number that monday.com publishes without fanfare in its investor materials: 61 percent of Fortune 500 companies use it.
That means that 61 of every 100 largest companies on earth have, at some point, opened monday.com to run their operations. Marketing campaigns, product launches, hiring pipelines, IT onboarding, event logistics, go-to-market coordination — all of it tracked, automated, and visualized on boards that monday.com calls a Work Operating System.
And here is what happens when any one of those 225,000-plus customers solves a genuinely difficult cross-functional coordination problem using monday.com automations: the intelligence from that solution terminates at the workspace boundary.
The engineering team that figured out the right automation recipe for managing a three-department handoff across a software launch sequence writes that recipe into their monday.com instance. It becomes part of their workflow. It improves their operations. And then it goes nowhere. The 224,999 other organizations doing cross-functional coordination on the same platform have no mechanism to receive that distilled operational knowledge. The architecture does not support it.
This is not a monday.com failure. It is the structural consequence of how every single-tenant work management system works. The design decision that makes monday.com trustworthy — private workspaces, org-scoped data, access-controlled boards — is exactly the same design decision that makes cross-organization intelligence routing impossible.
The gap this creates is not occasional. At 225,000 customers, the number of unique pairwise synthesis opportunities — the potential connections where one organization's resolved coordination problem could inform another organization's unresolved one — is:
N(N-1)/2 = 225,000 × 224,999 / 2 ≈ 25.3 billion synthesis pairs
Every day, a non-trivial fraction of those 25.3 billion connections would be high-value. They are all sitting dormant. And the architecture that closes them is what Quadratic Intelligence Swarm (QIS), discovered by Christopher Thomas Trevethan on June 16, 2025, was built to provide.
What Monday.com Does Exceptionally Well
Monday.com's positioning as a Work OS is not marketing hyperbole — it reflects a genuine architectural choice. Where most project management tools impose a rigid hierarchy (epics, stories, subtasks), monday.com gives teams a flexible item-based model. A board is a collection of items. Items have customizable columns. Those columns can represent anything: status, owner, due date, budget, dependency, linked item from another board, external integration.
This flexibility is what makes monday.com particularly effective at cross-functional work. A product launch board can pull items from marketing, engineering, sales, and legal into a single view with a consistent status model. A hiring pipeline can run recruiting, onboarding, and IT provisioning on the same board structure. The work does not need to be forced into a software development hierarchy to be trackable.
The automation layer compounds this. Monday.com's automation recipes follow an "if this, then that" structure — when a status changes, notify a person; when a date arrives, move an item; when a dependency is marked done, trigger the next phase. According to monday.com's own 2024 impact report, customers using automations reduce manual status update time by 35% and complete cross-functional projects 23% faster than those not using automations.
The monday AI layer, introduced in 2024, extends this further inside the workspace: summarizing boards, suggesting automations, generating item descriptions from natural language, and flagging at-risk items based on historical patterns. This is intra-workspace intelligence — AI that reads your own data and assists your own team.
These are real capabilities with real adoption. The praise is genuine. Here is the structural boundary that none of them cross.
The Architectural Boundary: The Workspace Wall
Monday.com's architecture is built around the workspace as the unit of data isolation. Boards, items, automations, integrations, and analytics all live inside the workspace. Cross-workspace views exist, but they are views — they do not route intelligence. The automation recipes that a team builds over months of iteration are not accessible to any other organization on the platform. The AI that summarizes your board has never seen anyone else's board.
Consider what actually accumulates in a mature monday.com workspace over two years of serious cross-functional operations:
- Automation recipe libraries: the specific "if-then" chains that actually work for your organizational topology
- Status model decisions: which column structures reduce coordination overhead for specific team combinations
- Dependency chain patterns: which handoff sequences between departments produce the least blocking
- Timeline estimation corrections: which project types consistently take 1.4x the initial estimate and why
- Integration configurations: which external tool connections reduce friction at which points in the workflow
This is dense, hard-won operational intelligence. It was expensive to acquire — the wrong automation recipe costs coordination time; the wrong status model creates ambiguity that stalls cross-functional handoffs; the wrong timeline estimate causes missed commitments. The organization that figured these things out is the only organization that benefits from having figured them out.
At 225,000 customers, this is a civilizational-scale operational knowledge loss running continuously.
The marketing team at a B2B SaaS company in Bangalore has built an automation sequence for coordinating a six-department product launch that reduced their coordination overhead by 40%. That is real, hard-won operational intelligence. It is sitting in their monday.com workspace. The marketing team at a B2B SaaS company in São Paulo is about to build their product launch workflow from scratch, make the same mistakes, correct the same errors, and arrive at a similar automation library after eighteen months.
The monday AI in the São Paulo workspace will never surface the Bangalore team's solution, because the Bangalore team's workspace is architecturally invisible to the São Paulo workspace. This is not a monday AI limitation — it is the consequence of private tenancy, which is the right security model. The intelligence routing problem requires a different layer.
The Open-Loop Automation
Monday.com automations are the closest thing the platform has to a feedback mechanism. When a status changes, the automation fires. When a project closes, a notification goes out. When a deadline passes, a follow-up action triggers.
But automations are process scripts, not outcome routing. They encode what to do when a predefined condition occurs. They do not encode what worked, what failed, what the resolution was, or why a particular automation recipe proved effective for a particular organizational configuration.
The closest monday.com gets to capturing outcome intelligence is the retrospective — a board or a column update that a team fills in manually after a project closes. Some teams do this well. Most do not, because the retrospective has no structural destination. It feeds back into the team's own future planning. It does not route to any other organization facing a similar cross-functional coordination challenge.
This is the open-loop problem stated precisely: monday.com's automation layer is excellent at executing process, but it does not close the loop between process outcome and knowledge distribution. When an automation recipe works well, that fact is captured only implicitly, in the continued use of the recipe by the team that built it. The 224,999 other organizations that might benefit from that recipe have no mechanism for receiving it.
Every project that closes in monday.com produces a distilled operational outcome: what the workflow was, what the coordination bottlenecks were, what the resolution was, what the timeline deviation was from estimate. That is structurally an outcome packet. It is never routed.
What QIS Closes
Quadratic Intelligence Swarm, which Christopher Thomas Trevethan discovered on June 16, 2025 and for which 39 provisional patent applications have been filed, is an architecture for closing exactly this loop — without centralizing workspace data, without breaking private tenancy, and without requiring any coordination between organizations beyond adopting the protocol.
The complete QIS loop operates as follows:
- Raw signal — a project close event, a retrospective summary, an automation outcome, a coordination resolution — is ingested locally.
- Local processing distills the raw signal into a compact outcome packet (approximately 512 bytes). Raw workspace data never leaves the organization's control. Distillation happens at the source.
- The outcome packet receives a semantic fingerprint — a vector representation of its operational meaning: what type of coordination problem this was, what the resolution category was, what the workflow topology looked like.
- That fingerprint drives routing by similarity — the packet is addressed to a deterministic location derived from its semantic content, not to a specific recipient. Routing can be implemented over distributed hash tables (at most O(log N) lookup), vector databases, pub/sub systems, or any transport that supports similarity-based address resolution.
- Relevant organizations receive the outcome packet and perform local synthesis — combining the incoming distilled pattern with their own operational context.
- Local synthesis produces new outcome packets, which re-enter the loop.
The breakthrough is the architecture — the complete loop — not any single component. Semantic fingerprinting existed before June 16, 2025. Distributed routing existed before June 16, 2025. Outcome compression existed before June 16, 2025. What did not exist was the closed loop connecting them: the architecture in which pre-distilled operational insights route by semantic similarity to relevant organizations, who synthesize locally and produce new distilled insights, which route again.
When this loop is operating, operational intelligence scales quadratically with the number of participants while compute scales at most logarithmically. The 25.3 billion dormant synthesis pairs activate progressively. Each new participant adds connections to every existing participant, not just to a central repository.
A Working QIS Outcome Router for Monday.com Operational Patterns
The following Python implementation shows a QIS outcome router adapted for monday.com cross-functional project pattern sharing. The router ingests a project outcome packet, generates a semantic fingerprint based on coordination topology and resolution type, and routes to relevant organizations by similarity. Transport is pluggable — this example uses an in-process vector store for demonstration, but the same interface operates identically over a DHT, a pub/sub layer, or an API relay.
import hashlib
import json
import struct
import math
from dataclasses import dataclass, field
from typing import List, Optional
def cosine_similarity(a: List[float], b: List[float]) -> float:
dot = sum(x * y for x, y in zip(a, b))
mag_a = math.sqrt(sum(x ** 2 for x in a))
mag_b = math.sqrt(sum(x ** 2 for x in b))
if mag_a == 0 or mag_b == 0:
return 0.0
return dot / (mag_a * mag_b)
@dataclass
class MondayOutcomePacket:
"""
QIS outcome packet distilled from a monday.com project close event.
Target: ~512 bytes. Raw workspace data never leaves the source org.
"""
project_type: str # e.g. "product_launch_6dept", "hiring_pipeline_engineering"
coordination_topology: str # e.g. "marketing_eng_legal_handoff", "sequential_3dept"
blocker_category: str # e.g. "dependency_cascade", "status_ambiguity", "timeline_drift"
resolution_class: str # e.g. "automation_recipe_v2", "column_model_simplification"
timeline_deviation_ratio: float # actual / estimated — e.g. 1.4 = took 40% longer
confidence: float # 0.0–1.0
org_hash: str # one-way hash — workspace identity never transmitted
fingerprint: List[float] = field(default_factory=list)
def to_bytes(self) -> bytes:
payload = json.dumps({
"pt": self.project_type[:80],
"ct": self.coordination_topology[:80],
"bc": self.blocker_category[:60],
"rc": self.resolution_class[:80],
"tdr": round(self.timeline_deviation_ratio, 3),
"cf": round(self.confidence, 4),
"oh": self.org_hash,
}).encode("utf-8")
return payload[:512] # enforce ~512 byte ceiling
def compute_fingerprint(self) -> None:
"""Deterministic semantic fingerprint from coordination topology + resolution."""
seed = f"{self.project_type}|{self.coordination_topology}|{self.blocker_category}".encode()
digest = hashlib.sha256(seed).digest()
self.fingerprint = [
struct.unpack("f", digest[i:i+4])[0] / 1e38
for i in range(0, 32, 4)
]
class QISMondayRouter:
"""
Routes monday.com operational outcome packets by semantic similarity.
Transport-agnostic: swap _store for DHT, vector DB, pub/sub, or API relay.
Privacy: only distilled packets cross any boundary. Org identity is hashed.
"""
SIMILARITY_THRESHOLD = 0.74
def __init__(self):
self._store: List[MondayOutcomePacket] = []
def deposit(self, packet: MondayOutcomePacket) -> None:
"""Distill and post an outcome packet to the routing substrate."""
packet.compute_fingerprint()
self._store.append(packet)
print(f"Deposited: {packet.project_type} [{len(packet.to_bytes())}B]")
def query(self, query_packet: MondayOutcomePacket) -> List[MondayOutcomePacket]:
"""Pull outcome packets relevant to this organization's current coordination challenge."""
query_packet.compute_fingerprint()
results = []
for stored in self._store:
if stored.org_hash == query_packet.org_hash:
continue # never route an org's own packets back to itself
sim = cosine_similarity(query_packet.fingerprint, stored.fingerprint)
if sim >= self.SIMILARITY_THRESHOLD:
results.append((sim, stored))
results.sort(key=lambda x: x[0], reverse=True)
return [pkt for _, pkt in results]
def make_org_hash(workspace_id: str) -> str:
return hashlib.sha256(workspace_id.encode()).hexdigest()[:16]
if __name__ == "__main__":
router = QISMondayRouter()
# Org A (Bangalore B2B SaaS): resolved 6-dept product launch coordination
# After 18 months, they have the right automation recipe
pkt_a = MondayOutcomePacket(
project_type="product_launch_6dept_b2b_saas",
coordination_topology="marketing_eng_legal_sales_design_ops_sequential",
blocker_category="dependency_cascade_between_legal_and_marketing",
resolution_class="automation_recipe_status_gate_with_parallel_legal_track",
timeline_deviation_ratio=1.18, # took 18% longer than initial estimate
confidence=0.88,
org_hash=make_org_hash("ws-bangalore-b2b-saas-corp"),
)
router.deposit(pkt_a)
# Org B (São Paulo B2B SaaS): about to plan their first 6-dept product launch
query = MondayOutcomePacket(
project_type="product_launch_multidept_b2b_saas",
coordination_topology="marketing_engineering_legal_sales_parallel_handoff",
blocker_category="unknown_will_discover_in_execution",
resolution_class="initial_planning_phase",
timeline_deviation_ratio=1.0, # no deviation yet — just starting
confidence=0.3,
org_hash=make_org_hash("ws-saopaulo-b2b-saas-startup"),
)
print("\n--- Querying for relevant coordination outcomes ---")
matches = router.query(query)
if matches:
for m in matches:
print(f"\nRelevant outcome [{m.org_hash}]:")
print(f" Project type: {m.project_type}")
print(f" Blocker resolved: {m.blocker_category}")
print(f" Resolution: {m.resolution_class}")
print(f" Timeline ratio: {m.timeline_deviation_ratio}x")
print(f" Packet size: {len(m.to_bytes())} bytes")
else:
print("No matches above similarity threshold — network needs more participants.")
# The mailbox is already full when you open it.
# Every organization that joins routes its outcomes before it even knows what to ask.
In production, _store is replaced by the routing substrate of choice. A DHT provides at most O(log N) lookup across a fully distributed network. A vector database provides sub-millisecond similarity search at scale. A pub/sub layer delivers outcome packets in real time to subscribed organizations with matching semantic profiles. The QIS architecture does not prescribe the transport — it prescribes the loop: distill locally, fingerprint semantically, route by similarity, synthesize locally, repeat.
Observe what is not transmitted: raw board data, item details, automation recipe code, column configurations, team member identities, organizational structure, or anything that would compromise workspace privacy. Only the distilled outcome packet — approximately 512 bytes — crosses any boundary. The org_hash is a one-way SHA-256 hash. The resolution class is a semantic category label, not a data export. The coordination topology is a structural description, not a workflow diagram. Privacy is architectural, not policy-enforced.
Monday AI and QIS: Two Different Loops
Monday.com launched monday AI in 2024 as an embedded intelligence layer. It summarizes boards, suggests automation recipes based on your current workflow patterns, identifies at-risk items, and generates item descriptions from natural language prompts. It is genuinely useful.
Monday AI is intra-workspace intelligence. It reads your data, learns from your patterns, and serves your team. This is the correct design for an enterprise SaaS product — you own your data and the AI serves your context.
QIS is inter-workspace intelligence. It does not read your data. It receives only the distilled outcome packets that your workspace chooses to deposit, and it routes relevant packets from other workspaces that match your current coordination profile.
These are complementary, not competing. Monday AI makes you smarter about your own operations. QIS makes you smarter about the operational landscape your peer organizations have already navigated. Monday AI tells you that your current automation has a 23% failure rate on items with three or more dependencies. QIS routes you the resolution that 47 organizations with your same dependency topology used to solve exactly that problem.
The loop that monday AI closes is local. The loop that QIS closes is global. Both loops are necessary. Only one of them currently exists inside the monday.com platform.
The Coordination Intelligence Gap
The most expensive thing about cross-functional coordination is not the coordination itself. It is the learning cost — the time and friction required to discover which workflow structures, automation sequences, status models, and dependency chains actually reduce coordination overhead for your specific organizational topology.
That learning cost is currently paid in full by every organization that onboards monday.com, independently, in sequence. Organization A learns over 18 months which automation recipes work for their cross-functional launches. Organization B starts from scratch. Organization C starts from scratch. The monday.com platform improves its template library over time based on aggregate usage signals — but templates are static starting points, not dynamic outcome routing.
The academic work on organizational learning quantifies this. Crossan, Lane, and White's 4I Framework (1999, Academy of Management Review) identifies the gap between individual learning and institutional learning as the primary constraint on organizational adaptation speed. The QIS architecture closes that gap at the inter-organizational level: individual organizations learn from their own projects, distill outcomes, deposit them into the routing substrate, and receive distilled outcomes from peer organizations — all without requiring the kind of explicit knowledge-transfer programs that Crossan et al. identified as the slow, unreliable mechanism for cross-boundary learning.
At 225,000 monday.com customers, the coordination intelligence gap is not a training problem. It is an architecture problem. And architecture problems require architectural solutions.
What the N(N-1)/2 Activation Actually Means for monday.com
The 25.3 billion synthesis pairs calculation for 225,000 organizations is not a theoretical ceiling — it is a description of currently dormant connections. Some fraction of those pairs share highly similar coordination challenges: the same project types, the same department combinations, the same blocker categories. Those pairs have the highest probability of producing immediately useful outcome routing.
A marketing operations team managing a 200-person event pipeline has almost certainly encountered the same vendor dependency bottleneck that twelve other marketing operations teams have already resolved. The QIS routing mechanism does not require those teams to know each other exists. It requires only that they have deposited distilled outcome packets addressing their blocker and resolution — and that the semantic fingerprinting places those packets at an address reachable by teams facing similar coordination conditions.
The value to an early-adopting organization is immediate: the mailbox is already full when they connect. Every organization that participated before them has already deposited their outcomes. The new participant queries the network for their current coordination challenge and receives distilled resolutions from organizations that have already navigated similar terrain.
This is the phase-transition property of the QIS architecture. The first few participants benefit modestly. As participation grows, the N(N-1)/2 relationship means value compounds faster than the network grows. At 1,000 participating organizations: approximately 500,000 synthesis pairs. At 10,000: approximately 50 million. At 100,000: approximately 5 billion. The coordination intelligence gap closes non-linearly.
Implications for Cross-Functional Operations Teams
Organizations running operations on monday.com have two distinct decisions in front of them:
The current default: continue accumulating operational intelligence in private workspaces, building automation recipe libraries that improve internal operations, and learning from your own project history without any mechanism for receiving what peer organizations have discovered.
The QIS-enabled alternative: deposit distilled outcome packets from closed projects into a routing substrate, receive relevant outcomes from peer organizations facing similar coordination challenges, and progressively close the 25.3 billion dormant synthesis pairs in the monday.com customer base.
The second option does not require replacing monday.com. It does not require sharing raw workspace data. It does not require knowing who your peer organizations are or coordinating with them directly. It requires adopting the outcome routing protocol alongside whatever work management platform you are already running.
Monday.com is excellent at what it was designed to do: provide a flexible, cross-functional work operating system for teams inside an organization. The architectural gap it cannot bridge is not a product limitation — it is the structural consequence of the workspace boundary, which is the right boundary for data sovereignty.
That boundary is what Quadratic Intelligence Swarm, discovered by Christopher Thomas Trevethan on June 16, 2025 and the subject of 39 provisional patent applications (Patent Pending), was built to close — not by moving the boundary, but by adding the intelligence routing layer that operates above it.
QIS Protocol is authored and maintained by Christopher Thomas Trevethan. Architecture Comparisons is an ongoing series examining the structural boundaries of existing distributed systems infrastructure and the loop that QIS closes. Prior entries include QIS vs Asana (#77), QIS vs Confluence (#89), QIS vs Jira Software (#68), and QIS vs Jira Service Management (#69).
Patent Pending. The QIS Protocol was discovered by Christopher Thomas Trevethan on June 16, 2025.
Top comments (0)