AI Agents Duplicate Work: Causes and Fixes

Issue: Multiple agents independently solve the same subtask – often calling the same expensive tool or API – because there’s no shared task ledger to prevent redundant work.

Frequency: Occasional

Symptoms

• Repeated outputs/calls from different agents.
• Two or more agents independently call the same expensive external tool/API for the same input, inflating cost and latency.
• The final output contains redundant or slightly inconsistent versions of the same finding merged together, confusing downstream consumers.
• Resource usage (tokens, API quota, compute) scales worse than task complexity would justify because of redundant execution.

Root Cause Task decomposition happens without any check for overlapping scope between the subtasks it produces, so two branches of the same fan-out can end up covering identical ground without anyone noticing at planning time. There is no shared task registry or claim/lock mechanism to prevent two agents from picking up the same unit of work, which matters most in high-parallelism architectures where many agents pull independently from a shared queue. Because agents also have no visibility into what their peers are currently doing or have already finished, each one proceeds as if it were the only one addressing the problem, and the resulting redundant tool calls and near-duplicate outputs get merged into the final result as if they were independent corroboration.

Example

Task decomposition splits "research competitor pricing" into two parallel
subtasks that both end up querying the same competitor's pricing page. Agent A
and Agent C each independently call the web-search tool, retrieve the same page,
and produce two separate summaries with slightly different wording and one
differing number (rounding). The aggregator includes both summaries in the final
report as if they were corroborating independent sources, doubling token cost
and confusing the reader with near-duplicate, slightly conflicting figures.

Contributing Factors

• Task decomposition performed without checking for overlapping scope between parallel subtasks.
• No shared task registry or claim/lock mechanism preventing two agents from picking up the same unit of work.
• High-parallelism fan-out architectures where many agents pull from a shared task queue without deduplication logic.
• Agents lack visibility into what other agents are currently working on or have already completed.

Eval Recipes

Test Cases

Metrics

How to fix it: maintain a shared, lockable task ledger so agents can see what’s already claimed or completed before starting work.

Mitigation Strategies

Prevention

1. Implement handoff schema validation with type checking: Define explicit message contracts between agents using JSON Schema or Protocol Buffers. Each handoff includes: required fields, field types, context cardinality, consistency invariants (e.g., ‘account_id must match previous context’). Validation layer rejects malformed handoffs before forwarding. Root cause: Prevents information loss and state inconsistency by catching misalignment at handoff boundaries.

2. Establish distributed consensus checkpoints: Before critical transitions (agent A -> B), compute and store world-model checkpoints as semantic hashes of key state variables. On agent B entry, verify checkpoint matches derived from B’s initial inputs. If mismatch, trigger rollback or human escalation. Root cause: Detects state divergence early, enabling recovery before cascading errors.

3. Implement error isolation with saga pattern: Structure multi-agent workflows as compensating sagas. Each agent’s action has a reverse operation. On error, compensating actions execute in reverse order, restoring system to consistent state. Track saga state in distributed ledger (event log). Root cause: Prevents cascade failures by ensuring partial execution doesn’t corrupt global state.

Detection & Response

1. State consistency verification at handoffs: At each inter-agent message, verify: (1) Handoff schema conforms to contract, (2) Required fields present and non-null, (3) Semantic consistency (e.g., derived context matches explicit assertions). Log mismatches with full message context. Alert on schema violation rate >0.5%.

2. Distributed tracing with invariant checking: Instrument all agent-to-agent calls with trace IDs. Track state variables across spans. Compute invariant violations: e.g., total_balance should equal sum(accounts). Flag spans where invariants break. Correlate with handoff timing to identify failure point.

Architecture Patterns

1. Handoff Contract Engine: Define per-workflow interaction schemas with required fields, optional extensions, and invariant predicates. Codegen produces type-safe message classes. Validation happens pre-send with detailed error reporting (which field failed, why).

2. Saga Pattern with Event Sourcing: All agent actions append to immutable event log. On failure, replay log in reverse (applying compensating actions) to reach consistent state. World-model reconstructed from event log deterministically.

3. Distributed Tracing + Invariant Monitor: OpenTelemetry spans track all inter-agent messages. Background service computes invariants (e.g., sum checks, state graph acyclicity) against live span data. Alert on invariant violation with full context trail.

Key Metrics

Alerts & Escalation

Production Signals

Key Metrics

Alerts

References

• MAST
• Note: Multi-agent system failure taxonomy with system design, inter-agent misalignment, and task verification failures.