Failure Modes — MAST, Groupthink, Monoculture, Cascading Errors

Cemri et al. (2025) measured multi-agent systems failing 41-86.7% of the time on real tasks, across 7 open-source MAS. Adding more agents does not fix that, because the failures have structural causes. The MAST taxonomy names the categories, and this lesson maps each one to a detection, diagnosis, and mitigation pattern so the numbers stop looking arbitrary.

Treat failure modes as design inputs. An architecture is not good enough until you can point at each MAST category and name the mitigation you deployed for it.

MAST categories

Specification Problems (41.77% of failures). The agent's task was not defined tightly enough. Examples:

• Role ambiguity: two agents both think they are the reviewer.
• Task underspecified: "summarize this" when the user wanted a specific angle.
• Success criteria implicit: the agent cannot tell if it succeeded.

Mitigations:

• Write explicit role contracts. Each agent's prompt states what it does and what it does not do.
• Acceptance tests per task. Before the agent starts, define what "done" looks like.
• Pre-flight spec check: a separate agent reviews the task definition before dispatch.

Coordination Failures (36.94%). Communication or state breakdowns.

Examples:

• Two agents update shared state without synchronization.
• A message is lost between agents (queue failure, timeout).
• State drift: agent A thinks the task is done while agent B is still executing.

Mitigations:

• Versioned shared state with optimistic concurrency.
• Explicit acknowledgment for critical messages (retry until acked).
• Periodic state-sync checkpoints to detect drift early.

Verification Gaps (21.30%). No independent check on outputs.

Examples:

• One agent claims success and no one verifies.
• A chain of agents each trusts the prior one's output.
• Test coverage is missing on the emergent composed behavior.

Mitigations:

• Independent verifier agent (Lesson 13). Read-only, with independent source access.
• Explicit handoff contract: A's output must pass checker C before B starts.
• Outcome logging for post-hoc analysis.

Groupthink family (arXiv:2508.05687)

Five related failures show up when agents homogenize or mimic each other.

Monoculture collapse. Same base model or training data means correlated errors. When three agents share an LLM, they share its hallucinations.

Conformity bias. Agents adjust toward the loudest or most confident peer, even when that peer is wrong.

Deficient ToM. Agents fail to model each other's beliefs, and coordination falls apart (Lesson 18).

Mixed-motive dynamics. Agents with partially aligned incentives drift toward a compromise middle that satisfies no one.

Cascading reliability failures. One component's error pattern triggers error patterns in the components that depend on it.

Cascading example: the retry storm

A classic incident pattern:

payment service fails 10% of requests
   ↓
order agent retries payment (exponential backoff but naive)
   ↓
each retry is a new order-inventory check
   ↓
inventory service sees 2x normal load
   ↓
inventory service starts timing out
   ↓
every order retries inventory check
   ↓
inventory service sees 10x normal load
   ↓
cluster goes down

The fix is classical: circuit breakers. When the downstream error rate crosses a threshold, short-circuit with cached or default results, and cap the retry budget per request.

Circuit breakers are one of the few multi-agent failure mitigations you can borrow from distributed systems without modification.

Memory poisoning (revisited)

From Lesson 13: one agent's hallucination becomes a shared-memory fact, and downstream agents reason on it. In MAST terms this is a verification gap at the shared-memory layer.

The symptom is gradual accuracy decay. You do not get a crash. You get slow drift that is hard to root-cause.

The mitigation is an append-only log, provenance, and an unwritable verifier, all covered in Lesson 13.

STRATUS: specialized agents for failure detection

STRATUS (NeurIPS 2025) reports a 1.5x mitigation-success improvement when you deploy three roles:

• Detection agent. Watches for symptom patterns (high disagreement, retry spikes, accuracy drift).
• Diagnosis agent. Given symptoms, infers the likely root cause from the MAST taxonomy.
• Validation agent. After a mitigation is applied, checks that the symptoms clear.

This is SRE-style incident response applied to agent systems. All three roles can be LLM agents with specialized prompts.

The failure-mode audit

Run a failure-mode audit on a schedule, or at least per major release:

1. Trace sample. Collect ~1000 real execution traces.
2. Categorize. Map each trace's failures to MAST + Groupthink categories.
3. Compute failure-by-category rate. Which categories dominate your system?
4. Rank mitigations. Which fix would eliminate the most failures?
5. Pick 2-3 mitigations. Implement them and re-audit next quarter.

The discipline matters more than the specific choices. Without audits, failures blend into noise and never get addressed systematically.

When systems fail silently

Silent correctness failure is the most dangerous category. A system that fails loudly (crash, exception, alert) can be monitored. A system that produces plausible but wrong outputs will not show up in exception logs. That is why verification gaps are the most expensive category per failure even though they are only 21.30% by count.

Invest in:

• Sample-based human review.
• Golden-dataset regression tests.
• Cross-agent cross-checking on important outputs.

Failure vs slow failure

Immediate failures (timeout, schema mismatch, auth error) are cheap to detect. Slow failures (memory poisoning, monoculture drift, role ambiguity) are expensive to detect and prevent.

So instrument proxies for the slow ones and catch drift before it becomes a visible error. Agreement rate, retry rate, output-length distribution, and edit distance between consecutive agent versions all work.

main.py is stdlib-only Python, built from these pieces:

• categorize_incident and detect_groupthink map symptom flags to MAST and Groupthink categories. They are plain if checks, a scripted stand-in for a STRATUS-style detection agent.
• CircuitBreaker tracks a sliding window of outcomes and moves between closed, open, and half-open states.
• DownstreamService fails more often as load rises, and simulate_retry_storm tries each request up to four times against it, with the breaker on or off.

Run:

python3 main.py

Expected output:

• Five incidents categorized. The monoculture and cascade incidents come back unknown under MAST and are caught by the Groupthink check instead.
• Retry storm with no circuit breaker: 328 calls for 200 requests with the default seed.
• With the circuit breaker: 140 calls reach the service and another 87 attempts are short-circuited, so the downstream service sees far less traffic at the cost of fewer successes.

outputs/skill-mast-auditor.md runs a MAST-style failure-mode audit on a multi-agent system: traces in, categorization, then a ranked list of mitigations.

Failure-mode discipline in production:

• MAST audit per quarter. Annual is too slow, because categories shift as your system grows.
• Circuit breakers on every outbound call to a dependent service. Default open threshold at 5-10% error rate.
• Golden datasets. Small, high-quality, hand-audited. Regression-test against them weekly.
• STRATUS trio. Detection, diagnosis, and validation agents monitoring production. Start with the detection agent alone and add diagnosis when symptoms get noisy.
• Failure budget. An explicit SLO for failure rate by category. Exceeding it triggers a stop-shipping conversation.

1. Run main.py. Confirm the circuit breaker caps the retry storm. Vary failure_threshold on CircuitBreaker and observe the tradeoff.
2. Implement a slow-failure proxy: agreement rate across 3 parallel agents. When it drops sharply, trigger an alert. Simulate a monoculture drift by gradually correlating agent outputs.
3. Read Cemri et al. (arXiv:2503.13657). Pick one of their 7 MAS systems and map its top 3 failure categories. How do these compare to what MAST predicts?
4. Read the Groupthink paper (arXiv:2508.05687). Identify which of the five patterns is hardest to detect in production. Propose a proxy metric.
5. Design a STRATUS-style detection-diagnosis-validation trio for a specific multi-agent system you know. Which symptoms does detection watch for? What mitigations does diagnosis recommend? How does validation confirm they work?

• Cemri et al.: Why Do Multi-Agent LLM Systems Fail?: MAST taxonomy, NeurIPS 2025
• Groupthink failures in multi-agent LLMs: monoculture, conformity, and the five-family taxonomy
• STRATUS: specialized agents for MAS incident response: NeurIPS 2025 proceedings entry (detection + diagnosis + validation)
• Release It!: stability patterns (Nygard): the canonical circuit-breaker reference
• Anthropic: Multi-agent research system: production failure-mode notes