| Coordinating many agents | Protocols alone (MCP / A2A) | Colrows governed semantic layer |
|---|---|---|
| What it standardizes | The wire: transport and discovery | The meaning: metrics, entities, joins |
| Metric definitions | Each agent decides its own | One governed definition, versioned |
| How agents agree | Negotiated at runtime, or not at all | Compiled once, before execution |
| Failure mode | Conflicting numbers, each plausible | One answer, or an explicit refusal |
| Access control | Left to each tool | Row and column policy at query time |
Multi-agent systems fail by design, not by model weakness
The most rigorous study of this is MAST, “Why Do Multi-Agent LLM Systems Fail?” from UC Berkeley (Cemri et al., 2025). Across more than 1,600 execution traces from seven open-source frameworks, failure rates ran from 41 to 86.7 percent. The authors sort the failures into three buckets: flaws in how the system is designed, agents talking past each other, and weak verification of the result. System design is the largest share. Their conclusion is blunt. Better base models will not fix this on their own, because the faults live in how the system is organized.
Google Research put a number on how far a single mistake travels. In its December 2025 scaling study, independent agents with no cross-checking amplified errors 17.2 times relative to a single agent. Route the same work through a central coordinator that validates outputs and the amplification drops to 4.4 times. The topology, not the model, decided how bad things got.
The honest boundary: what the failure research covers, and what it does not
Most vendor posts overreach here, so this one will not. MAST studied coding, math, and web navigation. None of its traces touched a data warehouse, SQL generation, or a metric definition. It did not measure enterprise analytics, and it would be wrong to claim it did.
What MAST proves is narrower and still useful. Multi-agent coordination collapses in software and reasoning tasks, and it collapses because of design, misalignment, and missing verification. Enterprise analytics then adds a failure vector the academic work has not yet studied. Call it semantic divergence. When several agents write SQL against the same data, each one silently decides the grain, the joins, the fiscal calendar, and the exclusions. Ask three agents for “revenue” and you get gross bookings, net of refunds, and recognized revenue. Three numbers, all defensible, none reconciled.
This is the enterprise form of a principle Cognition stated for coding agents: “actions carry implicit decisions, and conflicting decisions carry bad results.” A metric definition is exactly such an implicit decision. In a codebase the danger is two agents writing over the same file. In analytics the work is mostly read-only, so there is no file collision. The danger is quieter and worse. Every agent reads the same tables and walks away with a different meaning.
Start with one agent. Earn the second.
Before adding agents, notice how strong the single-agent case is. Anthropic, which builds one of the best-known multi-agent research systems, is direct about the limits. Teams “invest months building elaborate multi-agent architectures only to discover that improved prompting on a single agent achieved equivalent results.” In their own testing, the multi-agent research system used about 15 times more tokens than a single chat for the same class of work.
So the first move is not a swarm. It is a single agent with good tools, used until you hit one of three real limits: the context gets polluted, the work is genuinely parallel, or you need specialized tools. Cognition, coming from the opposite reputation, lands in the same place in its 2026 update. Extra agents should add intelligence while the decisive actions stay single-threaded. The two most-cited voices in this debate agree more than they disagree.
Fix the Context, Not the Model. A governed definition layer lets you stay on a cheap, reliable single-agent design for longer. It is also the contract that keeps a multi-agent system honest if you do scale. Either way, the win comes from fixing what the agents share, not from swapping the model.
That reframes what a semantic layer is for. It is not a way to prop up a bloated architecture. It is the thing that lets you avoid one, and the safety rail if you outgrow it.
Why MCP and A2A are necessary but not sufficient
The obvious objection: are the new agent protocols not built to solve this? MCP connects agents to tools. A2A lets agents talk to each other. Both now sit under a shared foundation, which is real progress for the ecosystem. But both standardize the wire, not the meaning of what travels over it. They settled who stewards the specifications and left unsettled which agent may read which data, and on what terms.
The bottleneck is not only missing definitions. When an agent calls a tool over MCP, the real work is schema discovery, filter validation, join resolution, and partition pruning. Getting a trustworthy number is a compilation problem, not a lookup. A pile of definitions in a prompt does not solve it. A compiler does, which is the argument in what a semantic compiler does. Gartner is blunt on the gap: it predicts that by 2028, 60 percent of agentic analytics projects that rely on MCP alone will fail for want of a consistent semantic layer (Market Guide for Agentic Analytics, February 2026). Treat that as a prediction, not a measured rate, but the direction is clear.
We made the fuller case in why MCP is not enough without a governed semantic layer. The short version: protocols move context, governance defines it.
The evidence that shared semantics change the outcome
Give models governed business semantics and their accuracy on enterprise questions climbs, across independent tests.
The strongest evidence is not from a vendor. An independent 2026 paired benchmark tested three frontier models with and without a compact semantic-layer document and found a 17 to 23 point gain in first-shot accuracy, statistically significant for every model (Cube, arXiv 2604.25149). Earlier, data.world showed GPT-4 answering enterprise questions at 16.7 percent over raw schema and 54.2 percent over a governed knowledge-graph representation, a 37-point jump (Sequeda et al., 2023). Models have improved since. The shape holds: structure beats raw text for analytical accuracy, as we set out in the text-to-SQL benchmark.
There is also a qualitative shift that matters more than any single score. dbt Labs' 2026 testing found that with a semantic layer, model failures turn into refusals, while raw text-to-SQL fails as a plausible but incorrect answer. For a number headed into a regulatory filing or a lender's recovery report, a refusal you can see beats a wrong number you cannot.
Analysts now frame this as infrastructure. Gartner's March 2026 predictions call building a universal semantic layer the only way to improve accuracy, manage costs, cut AI debt, align multi-agent systems, and stop costly inconsistencies before they spread, and forecast that by 2030 such layers will be treated as critical infrastructure. “Align multi-agent systems” is the operative phrase for this post.
A fair objection, worth stating. A skeptic will note that Gartner has hyped data fabric, data mesh, and the lakehouse in earlier cycles, and ask why the semantic layer is different. The honest answer: a feature becomes infrastructure only when it is portable and enforced, not when an analyst names it. That is the bar Colrows builds to, and the bar buyers should hold every vendor to.
How Colrows becomes the coordination contract
Colrows is an autonomous semantic layer that sits above your warehouse: Snowflake, Databricks, BigQuery, or Redshift. It is the deterministic contract every agent resolves against, whether you run one agent or an orchestrator with a dozen workers.
When any agent asks a question in plain language, Colrows does not hand the model a bag of schema and hope. It compiles the question into governed SQL at compile time, against one versioned set of metric and entity definitions. It proves the join path, enforces role and attribute access controls (RBAC, ABAC, and row and column-level predicates) before execution, writes an audit trail, and makes each answer reproducible to a point in time. Every agent in the system computes “revenue” the same way, because none of them gets to decide what it means. The enforcement point is the subject of how to secure AI agent database access.
That is what turns the diagram above from the left column into the right. The disagreement is not negotiated at runtime. It cannot occur, because the definition is settled before any agent runs. When the data to answer safely is not there, the layer refuses instead of inventing. In distributed-systems terms, it is a shared schema that every node is bound to.
What this looks like where a wrong number is reportable
The stakes are highest where numbers are audited. In Indian asset reconstruction, multiple agents run under full audit across portfolio analytics, recovery scoring, and non-performing-asset valuation, with RBI SARFAESI and DRT logic modeled in. If each agent held its own definition of recovery rate, the portfolio would never reconcile. A single governed contract keeps every agent's output traceable and consistent, which is what makes agentic analytics usable in a regulated setting at all.
In pharma field-force analytics, a sales operation of tens of thousands of representatives needs one definition of coverage and call adherence across every agent that touches the data. Shared semantic memory is what stops a fleet of agents from quietly producing a fleet of different truths.
Coordination is a memory problem in disguise
This is the sequel to our argument that a governed semantic layer is an agent's missing enterprise memory. The link is direct. A single agent invents a metric when it has no governed definition to anchor to. A multi-agent system multiplies that: five agents, five private notions of “active customer,” and an orchestrator that cannot tell which to trust. Agents do not disagree because they cannot talk. They disagree because they never agreed on what the words mean.
Protocols will keep getting better at moving context. Models will keep getting better at reasoning over it. Neither will decide what your company means by “revenue.” That belongs in a governed layer every agent is bound to, and it is the piece most multi-agent stacks are still missing.
A note on the sources
Figures here carry named primary sources. The failure taxonomy and 41 to 86.7 percent range are from MAST, Cemri et al., UC Berkeley, 2025 (arXiv 2503.13657). The error-amplification figures are from Google Research, “Towards a Science of Scaling Agent Systems,” December 2025 (arXiv 2512.08296); the 17.2x and 4.4x are the study's own anchors for the independent and centralized topologies. The single-agent guidance and token multiple are from Anthropic's multi-agent engineering write-up, 2025. The implicit-decisions point is from Cognition. The accuracy evidence is from Cube's paired benchmark (arXiv 2604.25149), Sequeda et al., data.world, 2023 (arXiv 2311.07509), and dbt Labs' 2026 semantic-layer benchmark. The infrastructure framing and the 60-percent MCP prediction are from Gartner's 2026 data and analytics predictions and its Market Guide for Agentic Analytics. Benchmark scores are point-in-time snapshots and drift as evaluations update. This page is not legal advice.
Frequently asked questions
Why do multi-agent systems fail?
Most failures are design and coordination failures, not model weakness. UC Berkeley's MAST study found failure rates from 41 to 86.7 percent across seven multi-agent frameworks, driven by system design flaws, inter-agent misalignment, and weak verification of the result. Enterprise analytics adds one more failure vector: several agents each adopt their own definition of a business metric and return numbers that do not reconcile.
Should I use a single agent or a multi-agent system?
Start with a single agent. Anthropic reports that a well-tooled single agent handles most workflows, and that its own multi-agent research system used about 15 times more tokens than a single chat. Add agents only when you hit context pollution, genuinely parallel work, or a need for specialized tools. A governed semantic layer lets you stay on the cheaper single-agent design longer.
Do MCP and A2A fix multi-agent coordination?
No. MCP standardizes agent-to-tool connections and A2A standardizes agent-to-agent messaging. Both move context between agents. Neither guarantees the agents agree on what a business term means. That agreement needs a governed semantic layer.
