Opinion

Why More Agents Make MAS Less Reliable: It's a Concurrency Problem

An arXiv position paper reframes multi-agent system failures as concurrency bugs. Long LLM inference windows behave like long transactions, reproducing stale reads, lost updates, and other classic anomalies.

Font size

Recently came across a position paper on arXiv (arXiv:2608.18092) that makes a blunt argument: the reliability problems plaguing multi-agent systems (MAS) come down to missing concurrency control. The issue isn't bad prompts or weak models. People are running transactions on a database with no locks.

The analogy holds up the more you think about it. Below I'll combine the paper's core arguments with observations from my own demo builds.

Adding agents often reduces reliability, and it's not mysticism

Adding agents often reduces reliability. The more agents you stack, the worse things get.

I've reproduced this curve in several demos. Three collaborating agents succeed around 8 out of 10 runs. Bump it to seven or eight, and you're lucky to get 4 stable runs. Push past twelve and you're gambling.

The usual suspects get blamed: prompts need tuning, reasoning needs a stronger model, the context window is too long. The paper disagrees. Most of these failures trace back to concurrency issues.

Treat LLM inference latency as a "long transaction"

Database engineers have an old saying: long transactions are the root of all evil. A transaction runs for thirty minutes, someone else modifies the data it needed, and by the time it commits it's reading stale data or, worse, producing dirty writes.

LLM inference is a long transaction by nature.

  • A single GPT-4o or Claude call takes 3 seconds for a quick response, and 30 seconds is common for complex tool use plus reasoning.
  • During those 30 seconds, other agents can easily finish modifying shared state.
  • When the slow agent returns and writes based on outdated facts, it overwrites someone else's update. That's a lost update.

The paper puts it plainly: long LLM inference windows amplify the risk of stale reads, lost updates, and inconsistent outcomes. Swap "LLM inference window" for "transaction" and the sentence fits in any database textbook.

Classic concurrency anomalies reproduce themselves inside MAS

The most important line in the paper: failure modes commonly attributed to coordination or communication breakdowns can be mapped directly onto classical concurrency anomalies.

In plain English: the "coordination failures" everyone blames are mostly classic concurrency bugs wearing a new costume. A few I've hit firsthand:

Lost update

Two agents both read user preferences A=[tech, music], each reasons independently, and then writes:

  • Agent 1 writes back A=[tech, music, cooking]
  • Agent 2 writes back A=[tech, music, sports]

Whoever writes last wins. The earlier agent's incremental change disappears. Same as two transactions modifying the same row.

Dirty read

Agent A changes a task status from pending to in_progress and starts executing. Agent B reads the status before A finishes, sees in_progress, and makes a downstream decision based on it. A then fails and rolls back to pending. Agent B's decision now rests on a state that never existed.

Write skew

Two agents each write based on the assumption that the other won't change anything. Classic doctor scheduling problem: both doctors see the schedule, conclude "as long as the other doesn't work overtime, I don't need to," and nobody gets scheduled. In MAS, two agents take snapshots, make independent decisions, and the merged result is inconsistent.

These aren't theoretical. I've reproduced them in both CrewAI and LangGraph.

Why existing frameworks ship without concurrency control

Mainstream agent frameworks (AutoGen, CrewAI, LangGraph) all share an implicit assumption: agent calls are short, fast RPCs.

# Typical node pattern in LangGraph
def research_node(state: AgentState):
    result = llm.invoke(state["messages"])
    return {"messages": [result]}

Looks like a function call. Underneath it's a blocking I/O operation lasting anywhere from a few seconds to half a minute. The framework gives you no way to:

  • Lock state for the duration of an invoke
  • Check whether the returned value reflects the latest state
  • Handle the case where someone changed the data you depended on while you were reasoning

Worse, "communication" between agents is really just shared state (a dict or a message queue) with no transaction boundaries, no isolation levels, no ACID guarantees. You think you're writing a workflow. You're actually running bare-metal concurrency.

The paper's verdict is blunt: it's like running transactions on a database with no locks. Actually, it's worse. At least databases have a WAL.

Borrowing from databases: locks, versions, and isolation

The paper recommends building concurrency control into MAS frameworks from day one. Here's how to apply the ideas, mixing the paper's suggestions with what I've tried in practice.

Pessimistic locking

Before an agent starts a task that modifies shared state, it explicitly locks the relevant fields. Other agents block on reads until the lock releases.

# Pseudocode
with state.lock("user_preferences"):
    current = state.read("user_preferences")
    new = agent.run(current)
    state.write("user_preferences", new)

The downside is obvious: LLM reasoning is slow, locks get held for ages, and concurrency drops to near zero. But for high-consistency scenarios (finance, order processing) it's worth it.

Optimistic concurrency with version numbers

Every shared object carries a version field. Before writing, do a CAS check: if the version hasn't changed, write; if it has, retry.

version = state.read("user_preferences.version")
prefs = state.read("user_preferences")
new_prefs = agent.run(prefs)
state.cas_write(
    key="user_preferences",
    expected_version=version,
    value=new_prefs,
)

This pattern fits read-heavy, write-light agent collaboration. The retry loop needs to fetch fresh data, otherwise it degrades back into lost updates.

Transaction isolation

Wrap one full agent collaboration (multiple steps, multiple reads and writes) into a transaction. Isolation levels, low to high:

  • Read uncommitted: basically useless
  • Read committed: avoids dirty reads
  • Repeatable read: avoids non-repeatable reads
  • Serializable: full isolation, worst performance

For most MAS scenarios, read committed is enough. Critical decision points (writes) should go through serializable.

CRDT (conflict-free replicated data types)

The paper doesn't mention this, but I've used CRDTs to solve one class of MAS problem: scenarios where multiple parties append independently and strict ordering doesn't matter.

Say multiple agents each add bullet points to a shared note. The final merge is conflict-free. Libraries like Yjs work out of the box and beat wrestling with locks.

Nobody builds this because agent frameworks are still in the "good enough" phase

Current MAS frameworks are still competing on "spin up an agent team in a few lines of code."

  • CrewAI markets rapid team assembly
  • AutoGen sells "conversation as collaboration"
  • LangGraph emphasizes visual workflows

Concurrency control is unglamorous work nobody wants to touch. In the short term it doesn't matter either: in demo land, three agents run fine and nobody worries about production stability.

But anyone who has seriously pushed MAS toward production has hit these problems. Prompts won't fix them. A stronger model won't fix them. You need concurrency primitives baked into the architecture.

To verify this yourself, follow this sequence

  1. Use CrewAI or LangGraph to build a demo with 5 or more agents where two agents write to the same shared state (user preferences, task list, anything).
  2. Run it 20+ times and record how often lost updates or dirty reads occur.
  3. Add a version field to shared objects plus CAS writes, and watch stability improve.
  4. For consistency-critical writes (money, order status), use serializable isolation, not optimistic concurrency.

If you only take one line from this paper: what you're hitting isn't "AI being unreliable," it's "no concurrency control." Once you frame it that way, the solution is obvious: go borrow from the database world.

Reference: arXiv:2608.18092 - Concurrency Control for Multi-Agent Systems

Source: https://arxiv.org/abs/2608.18092