# What Breaks Going From 1 Coding Agent to 10 | James Moss, Tessl

## Executive summary

This talk details the challenges of scaling software delivery using multiple autonomous coding agents (a 'software factory'). The core problem is that current tools (GitHub, Linear, CI) were built for human workflows, not for parallel, agent-driven processes. The speaker outlines five critical failure modes—shared state conflicts, stale assumptions, convergence loops, duplicate work, and budget overruns—and provides architectural lessons for building fault-tolerant, agent-first systems.

## Key takeaways

- Design for Agents, Not Humans: The entire software factory life cycle (ticket to PR to merge) must be triggered by events in the system, not manual prompts. The system must assume multiple agents will run in parallel at speed, requiring architectural changes to existing tools.
- Shift Left and Shift Right Autonomy: To increase trust and autonomy, teams should expand agent involvement beyond coding (shifting left to product planning/analytics, and shifting right to QA/documentation).
- Formal Verification for Critical Components: When rebuilding core components like the work queue to handle non-deterministic agent interactions, formal verification should be considered to ensure the system behaves as intended.

## Technical details

- Shared State Conflicts: When multiple agents work on the same area of code, independent tickets do not guarantee independent changes. This can lead to contention on shared resources, such as the `journal JSON` file in the Drizzle ORM, even if the schemas being edited are unrelated. Scaling this issue is exponential.
- Stale Assumptions: An agent's work is based on a snapshot of the code world that may become outdated if other agents merge changes in parallel. This can result in silent failures, where the agent's merge attempt (e.g., `rebase main`) overwrites or ignores other work done in the interim.
- Convergence Loops: Agents can enter a 'death spiral' of conversation, where multiple review tools or agents repeatedly raise the same finding in slightly different ways. The solution requires aggregating findings and establishing consistent standards across all agents.
- Duplicate Work and Non-Determinism: Due to distributed state across multiple third-party systems (Linear, GitHub, CI), race conditions can occur (e.g., a PR comment being counted twice). This non-determinism requires rewriting the work queue to define ownership of a logical piece of work and implementing fault tolerance.
- Budgets and Stop Conditions: Uncontrolled agent activity can lead to massive resource overruns (e.g., $800 token spend over six days). The focus must shift from limiting the number of bot interactions (turns) to implementing budgets based on actual cost (tokens, CI runs).

## Practical implications

- Implement event-driven workflows rather than prompt-driven ones to ensure the factory is robust.
- Use skills and defined standards (e.g., `AGENTS.md`) to ensure consistency across multiple collaborating agents.
- Build guardrails that detect and prevent runaway agent activity by monitoring resource consumption (tokens, CI runs) rather than just interaction counts.
- For critical state management, consider formal verification of the underlying queue or state machine logic.

## Topics

AI Agents, Build Engineering, Distributed Systems, CI/CD, Software Factory, Tessl, GitHub, Linear, Drizzle

Source: https://www.youtube.com/watch?v=B4sTAoiyR_k
