What Breaks Going From 1 Coding Agent to 10 | James Moss, Tessl
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
1:02
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
31:32
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
22:29
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
625s
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
863s
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
1046s
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
1289s
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
1441s
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).
Mentioned resources
- Tessl
- GitHub
- Linear
- Drizzle
Channel & topics
Watch on YouTube · Back to latest
This independent, AI-assisted summary is provided for commentary and informational purposes. It may contain errors or omit important context. Please watch the original video for the creator's complete presentation. Video, thumbnail, and related copyrights belong to their respective owners.