Multimodal systems: potential that melts at scale
The promise of multimodal systems based on large language models looks attractive: several LLM agents can divide a large task among themselves, consult each other, and find a solution together. However, practice shows the opposite effect: the more agents are involved in collaborative work, the less stable the system becomes. Intuitively, it seems the problem lies in coordination, but a group of researchers in a position paper on arXiv suggests looking deeper.
The root of many failures lies in how agents access shared state. Each of them reads and writes data to a common repository — notes, results, versions of facts. When the number of accesses increases, classic data races emerge. If this were an ordinary multithreaded program, engineers would immediately suspect synchronization issues. But because the system's participants appear "intelligent," their errors are often attributed to misunderstanding, when in reality this behavior is typical of parallel access to shared resources.
Long "deliberations" are twice as dangerous
The nature of LLM agents adds an extra layer of complexity. The model's inference process takes a noticeable amount of time, and throughout this time, the agent works with the snapshot of state it saw at the moment of the request. While the model "thinks," other agents are not idle: they update shared data. Upon returning with a ready solution, the agent may rely on an outdated view of the world.
As the number of agents increases, so does the number of such long thought windows, and with them, the likelihood of various anomalies grows. One agent fails to notice that a subtask has already been completed by a colleague and starts duplicating work. Two attempt to write the final result, and the last write overwrites the previous one without any warnings. Someone reads data while another agent hasn't finished updating it and gets an inconsistent intermediate version. All this looks like chaos, but in reality, it follows patterns well known from database theory — stale reads, lost updates, and state integrity violations.
Communication failures are also just a symptom
Why is it so easy to misdiagnose? Take coordination failure. Agents have clearly divided roles and seemingly coordinated their actions. But if the shared fact base is constantly changing, one agent may act based on a state that a colleague has already rewritten. From the outside, this looks like inconsistent plans or poor understanding of instructions. However, the root cause is not weak coordination, but a lack of control over concurrent data access.
The same applies to communication. A message itself may be perfectly formed and delivered on time. But if, by the time the recipient starts processing it, the shared data has already changed, the message's meaning becomes distorted. Such failures are extremely difficult to reproduce: they depend on precise timing. With few agents, the problem is barely noticeable, but at scale, the number of overlapping operations grows, and errors begin to occur with alarming regularity.
Concurrency control — as a foundation, not a patch
The solution proposed by the researchers lies in transferring proven approaches from the database world into the architecture of multimodal systems. Instead of relying on LLMs to somehow "come to an agreement," the platform should explicitly manage concurrent access. Practically, this means three areas of work:
- Conflict detection. The system tracks simultaneous attempts by agents to modify the same data and prevents a collision before it leads to corrupted results.
- Isolation guarantees. Each agent must work with a consistent snapshot of state or have mechanisms that prevent reading incomplete writes.
- Structured resource access. Instead of direct access to shared context, explicit interfaces are used: locks, operation versions, write queues, or atomic updates.
The authors emphasize that concurrency control cannot be added retroactively when the system has already started failing. It must be an architectural decision at the "second floor" level, from which all other design stems. If you first define the rules for working with shared state and then build agent coordination on top of them, many reliability problems simply won't have a chance to arise.
Conclusions
LLM-based multimodal systems hold immense potential, but their vulnerability stems not from the weakness of individual models, but from the fact that we try to make several parallel executors work with a single, changing state without basic protective mechanisms. By recognizing data races as the primary source of failures, developers gain the ability to apply long-known solutions — isolation, conflict detection, and access ordering. Perhaps this is less flashy than improving prompts, but it is precisely this approach that allows a multimodal system to remain reliable as the number of participants grows.
