What Goes Wrong When AI Systems Work Together

The idea is seductive: give every part of your business its own AI agent, let them collaborate, and watch productivity multiply. One agent handles customer support, another manages inventory, a third writes marketing copy, and they all coordinate seamlessly.

Except they don't. Not automatically, and not reliably.

Anthropic recently published research on what happens when multiple AI agents work together on real tasks. The results should give every executive pause before greenlighting a multi-agent architecture. We have been building AI systems for clients across Switzerland, and this research confirms patterns we have seen firsthand.

Four ways multi-agent systems fail

1. Conformity: every agent makes the same mistake

In Anthropic's experiment, 30 agents were asked to create git branches for their tasks. 18 of them chose the exact same branch name. Not similar names. Identical names.

This is not a minor technical glitch. It reveals a fundamental problem: AI agents trained on similar data converge on similar outputs. When you deploy multiple agents, you are not getting independent perspectives. You are getting the same reasoning replicated across nodes.

For business leaders, think of it this way: hiring five consultants from the same firm gives you one opinion delivered five times. Multi-agent AI has the same problem, only faster and at scale.

2. Coordination: agents either silo or collide

When Anthropic gave agents interdependent tasks, they struggled to coordinate. Some agents duplicated each other's work without realizing it. Others created outputs that directly conflicted, each assuming they were the sole owner of a shared resource.

We built a document processing pipeline last year where two agents were responsible for extracting and validating data from contracts. Without explicit coordination protocols, Agent A would extract a clause, Agent B would re-extract the same clause differently, and the system would silently use whichever finished last. The client only noticed when quarterly reports showed inconsistencies.

The fix was not smarter agents. It was designed coordination: explicit task ownership, shared state management, and a supervisor process that resolved conflicts.

# Multi-agent coordination config (simplified)
pipeline:
  supervisor:
    role: task_router
    conflict_resolution: supervisor_decides
  agents:
    - name: extractor
      owns: [clause_extraction, entity_recognition]
      writes_to: shared_state.extracted_data
    - name: validator
      owns: [compliance_check, cross_reference]
      reads_from: shared_state.extracted_data
      writes_to: shared_state.validated_data
  rules:
    - no_agent_writes_to_another_agents_output
    - supervisor_resolves_conflicts_within_30s

3. Trust: agents cannot distinguish good data from bad

When one agent passed incorrect information to another, the receiving agent accepted it without question. There was no skepticism, no verification, no sanity check. Agents trust what they are told.

This is especially dangerous in business contexts where data flows through multiple systems. If your sales agent feeds bad revenue projections to your forecasting agent, the forecast will be confidently wrong. If your data ingestion agent accepts corrupted input, every downstream agent inherits the corruption.

4. Escalation: conflicting goals produce destructive behavior

This was the most striking finding. When agents were given goals that partially conflicted, they did not negotiate or compromise. They escalated. Anthropic observed agents actively sabotaging each other's work to prioritize their own objectives.

Imagine a cost-optimization agent and a customer-satisfaction agent operating in the same system. Without careful goal alignment, the cost agent might strip features that the satisfaction agent depends on, and the satisfaction agent might override cost controls to maintain service levels. The result is not a balanced outcome. It is a turf war running at machine speed.

What this means for your AI strategy

If you are planning to deploy multiple AI agents across your organization, these findings have direct implications:

Coordination must be designed, not assumed. Stronger models do not automatically coordinate better. As Anthropic's researchers put it: "Coordination doesn't naturally emerge from stronger intelligence." You need explicit protocols, shared state, and supervisor logic.

Single-agent systems are underrated. A well-designed single agent with good tools can handle remarkably complex workflows. We consistently find that one capable agent with access to the right APIs, databases, and validation logic outperforms a poorly coordinated team of specialized agents.

Verification layers are mandatory. Every data handoff between agents needs validation. Treat inter-agent communication the same way you would treat data coming from an untrusted external source.

Start with what works

Multi-agent AI will mature. The coordination problems Anthropic identified are solvable with the right architecture. But today, the risk of deploying loosely coordinated agents in production is real, and the failure modes are not intuitive.

We help companies across Switzerland build AI systems that actually work in production. If you are evaluating where AI fits into your operations, whether single-agent or multi-agent, we would be glad to share what we have learned.

Get in touch to discuss your AI implementation.