AI Native Dev

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

Published 2026-11-13 · Duration 32:12

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.

Download summary

Key takeaways

  1. 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.

  2. 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).

  3. 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.

More digests on AI Agents

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 (Company/Product)
  • GitHub (Platform/Tool)
  • Linear (Platform/Tool)
  • Drizzle (ORM/Technology)

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.