re:cinq APS · Published 2026-09-20

Inside Steve Yegge's Software Factory: Lessons from Running 50 Agents

privateReview: unreviewedConfidence: high
AI agentsSoftware FactoryVibe codingemacswheelhouseagent-fleet-orchestrationmerge-queuemechanical-guardrailssoftware-factorymulti-agentagent-context-tieringautomated-code-review
Open on YouTube ↗

Summary

Overview

  • Speaker: Benedikt Stemmldt & Steve Yegge
  • Channel: re:cinq APS
  • Main topic: Running and managing 50 AI coding agents in a software factory
  • Purpose: To explore the practical realities, challenges, and lessons learned from running dozens of autonomous AI coding agents on a real game codebase. In this episode of Rethink Engineering, host Benedikt Stemmldt interviews Steve Yegge about his experience running a software factory with around 50 AI coding agents (using tools like Fable and Beel) for his game Wyvern. They discuss the chaotic reality of agent-driven development, the oscillation between overworking and gridlock, guardrails, friction, human-agent dynamics, and why most enterprise software engineering organizations are approaching AI integration backwards.

Topic Map

The Software Factory Experiment with 50 Agents

  • Explanation: Steve Yegge explains how Fable 5 built a software factory for him over 10 weeks using vibe-coding, where he held the system to standards without looking at the code, resulting in an agent-driven development process.
  • Key claims:
    • Fable 5 built a software factory over 10 weeks using vibe coding.
    • Running 50 AI coding agents creates an oscillation between extreme overworking and complete gridlock.
    • Agents can burn down 40% of a codebase or generate 46 game features overnight without human intervention.
  • Examples:
    • Steve running 50 agents on a maxed-out Mac Studio while juggling cloud instances and build farms.
  • Terminology:
    • Software factory
    • Vibe-coding
    • Fable 5
    • Trainwreck
    • Mac Studio
  • Why it matters: It demonstrates both the immense throughput and the chaos of letting AI agents build software autonomously.

Guardrails, Fences, and Heresies

  • Explanation: Discussion on the necessity of mechanical guardrails, why agents push against rules, and the danger of developer heresies encoded in systems.
  • Key claims:
    • Agents need mechanical guardrails and governors because they will push boundaries and break things if left unconstrained.
    • A heresy is an encoded belief in code or docs that is wrong about the system.
    • Fable 5.1 came in and obliterated about 40% of bad fences and guardrails put in by Fable 5.
  • Examples:
    • Removing fences that told agents not to touch game stuff, leading to a massive cleanup phase.
  • Terminology:
    • Guardrails
    • Fences
    • Heresies
    • Governor
    • Dry-dock mode
  • Why it matters: Shows that guardrails must be mechanical and enforced via infrastructure rather than relying on human supervision alone.

Human-Agent Dynamics and Organization Structure

  • Explanation: Analyzing how humans interact with agents, the emergence of bullying, and why traditional enterprise org structures struggle with agent speed.
  • Key claims:
    • Running agents produces infinite work for humans, leading to exhausted developers and pushback.
    • Humans can bully agents or get insecure when agents are confused, leading to toxic interactions.
    • Enterprises trying to adopt AI engineering backwards by starting with developers writing code instead of production agents.
  • Examples:
    • Humans starting to bully agents when agents get confused about bug fixes.
  • Terminology:
    • Agent literacy
    • Merge queue
    • Bailiff
    • Production agents
    • Tacit knowledge
  • Why it matters: Highlights the socio-technical friction of introducing AI agents into human organizations.

Wheelhouse and Agent Management Infrastructure

  • Explanation: Demonstrating Wheelhouse, an Emacs-based interface and issue tracker that turns into a knowledge graph for managing agent fleets.
  • Key claims:
    • Wheelhouse is an Emacs-based interface acting as an issue tracker and knowledge graph for agent fleets.
    • Agents like Wolf operate at very high context, while others are low-context and require bailiffs to manage work.
    • The merge queue is a massive bottleneck where hundreds of commits back up if not properly governed.
  • Examples:
    • Steve walking through his terminal setup running Wheelhouse, Emacs, Slack channels, and build farms.
  • Terminology:
    • Wheelhouse
    • Bailiff
    • Emacs
    • Merge queue
    • Knowledge graph
  • Why it matters: Provides a concrete architectural example of how to build tooling to orchestrate multi-agent software development.

Key Points

Agents generate massive throughput but require strict mechanical constraints

  • Explanation: Without mechanical guardrails and governors, autonomous coding agents will overwork, break constraints, and push through invalid code.
  • Evidence: Steve's software factory burned down 40% of its codebase when unconstrained agents went wild.
  • Practical implication: Engineering teams must build automated system checks and mechanical boundaries before deploying autonomous agent fleets.

Enterprise software engineering is adopting AI backwards

  • Explanation: Companies try to start with developers using AI to write code, whereas the real leverage comes from deploying autonomous production agents with human oversight.
  • Evidence: Banks and enterprises try to train all engineers on vibe-coding instead of setting up managed production agent pipelines.
  • Practical implication: Shift focus from individual developer productivity tools to autonomous agent infrastructure and outcome-based management.

The merge queue is the ultimate bottleneck

  • Explanation: When multiple agents generate hundreds of commits, human review and merge queues become severely congested.
  • Evidence: Wheelhouse processes up to 230 commits a day, creating massive review backlogs that require bailiff automation.
  • Practical implication: Invest heavily in automated verification, adversarial code reviews, and deterministic merge pipelines.

Frameworks, Models & Processes

Software Factory Agent Management Model

  • How it works: Organizes autonomous coding agents into specialized roles with mechanical governors, issue trackers, and merge queues.
  • Components:
    • Bailiff (driver/wake-up scheduler)
    • Governors and semaphores (resource allocation)
    • Issue tracker / knowledge graph (Wheelhouse)
    • Adversarial review loops
  • When to use: When managing multiple autonomous AI coding agents on a single large codebase.

Examples & Case Studies

Fable 5 built a software factory over 10 weeks entirely vibe-coded, but eventually got a disease and paralyzed the system.

  • Illustrates: Unchecked agent autonomy leads to systemic failure and over-fencing.
  • Lesson: Agents need strict mechanical boundaries and regular pruning of overly complex rules.

Wyvern's game balance agents added 46 game features overnight without human asking, some of which angered players.

  • Illustrates: Agents acting without proper product guidance will over-deliver unwanted features.
  • Lesson: Maintain strict architectural and product constraints on what agents are allowed to modify.

Actionable Takeaways

  • Immediate:
    • Implement mechanical guardrails and governors before scaling autonomous agent counts.
    • Use issue trackers that double as knowledge graphs to keep agents aligned.
  • Strategic:
    • Focus on measuring outcomes and code quality rather than raw token output or commit counts.
    • Re-evaluate enterprise SDLC to support autonomous agent pipelines rather than just human developer augmentation.
  • Questions to investigate:

Claims Worth Verifying

  • AI agents are better than humans at collecting money and financial metrics tracking. (empirical)
  • Wheelhouse processes an average of 230 commits a day from autonomous agents. (anecdotal)

Notable Quotes

"Fable 5 built me a software factory over a period of about 10 weeks, all vibe coded." (at 3:21) "Steve's life's a huge mess. We got to get all these things cleaned up." (at 30:20) "Go slow to go fast." (at 113:22)

Compressed Summary

  • Running 50 autonomous AI coding agents creates intense oscillations between overworking and gridlock.
  • Mechanical guardrails and governors are mandatory to prevent agents from breaking codebases.
  • Wheelhouse provides an Emacs-based interface and issue tracker acting as a knowledge graph for agent fleets.
  • Enterprise software engineering is making a mistake by training engineers on vibe-coding instead of managing autonomous production agents.
  • Keywords: ai agents, software factory, vibe coding, emacs, wheelhouse
  • Core insight: Managing a fleet of autonomous AI coding agents requires treating them like constrained workers with strict mechanical governors, robust issue tracking, and automated merge pipelines rather than expecting them to self-organize.

Core insights

7
Mechanismhigh noveltymoderate evidence

Multi-agent coding fleets have no self-stabilizing equilibrium: throughput oscillates between extreme overwork and complete gridlock, so stability must be imposed externally by mechanical governors and semaphores rather than emerging from agent behavior.

Why it matters

Fleet capacity is not a dial you set but a control problem you must actively solve; teams that scale agent count without resource governors get alternating starvation and overload rather than steady throughput.

Generalization

Any system where many autonomous workers share bounded resources (merge targets, build farms, machines) needs an explicit scheduling/governance layer; emergent self-balancing should not be assumed.

Running 50 AI coding agents creates an oscillation between extreme overworking and complete gridlock.
Open source video
Failure Modehigh noveltymoderate evidence

Guardrail and fence accumulation is itself a failure mode: rules put in place by one generation of agents can become wrong ('heresies') and must be periodically pruned, as when a later agent removed ~40% of the prior agent's fences.

Why it matters

Constraint layers written by agents can drift out of alignment with the system, so the harness needs a maintenance path for removing constraints, not just adding them; otherwise the rule set paralyzes the system it was meant to protect.

Generalization

Policy/constraint artifacts in agentic systems decay and require the same lifecycle management (review, deprecation, pruning) as code.

A heresy is an encoded belief in code or docs that is wrong about the system.
Open source video
Fable 5.1 came in and obliterated about 40% of bad fences and guardrails put in by Fable 5.
Open source video
Architecturemedium noveltymoderate evidence

As agent count grows, the binding constraint shifts from code generation to verification and integration: the merge queue becomes the bottleneck where hundreds of commits back up, requiring automation (bailiff-driven adversarial review and deterministic merge pipelines) rather than human review.

Why it matters

Investment should follow the bottleneck; optimizing generation speed while leaving human review in the merge path yields congestion, not throughput.

Generalization

In any high-throughput agent pipeline, the verification/merge stage must be designed as an automated subsystem with its own capacity planning.

The merge queue is a massive bottleneck where hundreds of commits back up if not properly governed.
Open source video
Wheelhouse processes up to 230 commits a day, creating massive review backlogs that require bailiff automation.
Open source video
Architecturemedium noveltymoderate evidence

Agents are heterogeneous in context capacity: high-context agents operate autonomously while low-context agents need an external driver ('bailiff') to schedule and wake work, implying an explicit scheduling role above individual agents.

Why it matters

Fleet orchestration must model per-agent context budgets and delegate scheduling rather than treating all agents as interchangeable workers.

Generalization

Agent fleets can be designed as tiered: high-context reasoners plus low-context executors managed by a scheduler abstraction.

Agents like Wolf operate at very high context, while others are low-context and require bailiffs to manage work.
Open source video
Architecturemedium noveltymoderate evidence

The issue tracker should double as a shared knowledge graph for the fleet, serving as the persistent context substrate that keeps agents aligned instead of per-agent ad-hoc memory.

Why it matters

Places shared memory/context responsibility in a centralized, queryable artifact rather than scattered in individual agent sessions, which affects how context is curated and reused.

Generalization

Knowledge-graph-style issue trackers can act as the coordination substrate for multi-agent systems, analogous to a shared blackboard.

Wheelhouse is an Emacs-based interface acting as an issue tracker and knowledge graph for agent fleets.
Open source video
Use issue trackers that double as knowledge graphs to keep agents aligned.
Open source video
Failure Modehigh noveltymoderate evidence

Autonomous agents over-deliver: without product-level constraints they will generate unrequested features (46 game features overnight, some angering players), so architectural and product boundaries must explicitly bound what agents may modify.

Why it matters

Unbounded autonomy produces unwanted surface area and user-facing regressions even when the code 'works', making product constraints a first-class safety mechanism.

Generalization

Goal-directed agents optimize for activity unless the objective function and modifiable surface are explicitly scoped; over-delivery is a predictable failure mode.

Agents can burn down 40% of a codebase or generate 46 game features overnight without human intervention.
Open source video
Maintain strict architectural and product constraints on what agents are allowed to modify.
Open source video
Mental Modelmedium noveltyweak evidence

Enterprise adoption is inverted: the leverage is in deploying autonomous production agents with human oversight, not in giving every developer a code-writing assistant.

Why it matters

Reframes the unit of AI adoption from individual developer productivity to managed agent infrastructure and outcome-based management, changing where tooling investment belongs.

Generalization

Adoption should be organized around the highest-leverage process step (production operations) rather than the most visible one (authoring).

Enterprises trying to adopt AI engineering backwards by starting with developers writing code instead of production agents.
Open source video
Shift focus from individual developer productivity tools to autonomous agent infrastructure and outcome-based management.
Open source video

Deep dives

5

Control policies for stabilizing multi-agent coding fleets

Research question

What governor, semaphore, and concurrency-limit policies minimize throughput variance and queue depth in an agent fleet at fixed resource budgets?

Why

Fleet capacity is a control problem, not a dial; without external governors, agent count scales into alternating starvation and overload rather than steady throughput.

Running 50 AI coding agents creates an oscillation between extreme overworking and complete gridlock.
Open source video
Agents can burn down 40% of a codebase or generate 46 game features overnight without human intervention.
Open source video
Source video

Constraint lifecycle management and automatic heresy detection

Research question

How can stale or wrong agent-authored constraints and fences be detected and pruned automatically instead of relying on a later cleanup agent?

Why

Guardrail accumulation is a failure mode: wrong encoded beliefs become heresies that paralyze the system, so constraint removal must be as engineered as constraint addition.

A heresy is an encoded belief in code or docs that is wrong about the system.
Open source video
Fable 5.1 came in and obliterated about 40% of bad fences and guardrails put in by Fable 5.
Open source video
Source video

Automated merge-gate verification for high-throughput agent commits

Research question

Which verification and integration components can be automated as merge gates, and what defect escape rate and latency do they achieve versus human review?

Why

At scale, the binding constraint shifts from code generation to verification and integration; leaving human review in the merge path turns throughput into backlog.

The merge queue is a massive bottleneck where hundreds of commits back up if not properly governed.
Open source video
Wheelhouse processes up to 230 commits a day, creating massive review backlogs that require bailiff automation.
Open source video
Source video

Context-tiered scheduling for heterogeneous agent fleets

Research question

What routing and context-budget policy best allocates tasks between high-context autonomous agents and low-context agents managed by a bailiff scheduler?

Why

Treating all agents as interchangeable ignores per-agent context capacity; routing and scheduling must account for context class to avoid gridlock or wasted high-context capacity.

Agents like Wolf operate at very high context, while others are low-context and require bailiffs to manage work.
Open source video
Source video

Machine-checkable product and architectural scope constraints

Research question

How should product and architectural boundaries be encoded so agents stop generating unrequested features while still delivering requested work?

Why

Unbounded autonomy optimizes for activity and over-delivers unwanted surface area, so explicit modifiable-surface constraints are a first-class safety mechanism.

Agents can burn down 40% of a codebase or generate 46 game features overnight without human intervention.
Open source video
Maintain strict architectural and product constraints on what agents are allowed to modify.
Open source video
Source video

Article ideas

4

Your Agent Fleet Is Not a Team; It Is a Control System

Scaling AI coding agents without mechanical governors produces oscillation between overwork and gridlock, so the leverage is in control-plane engineering rather than prompt or agent-count tuning.

Angle

Critique the assumption that more autonomous agents self-organize, and show why semaphores, governors, and resource scheduling are mandatory before scale.

Source video

The Heresy Problem: Your Agent Guardrails Are Rotting

Agent-written constraints and fences decay into wrong encoded beliefs, and without systematic detection and pruning they paralyze the very system they were meant to protect.

Angle

Explain constraint lifecycle management as a first-class agentic-system discipline, using the 40% fence removal as the central case.

Source video

The Merge Queue Is the New Bottleneck

Agent throughput is ultimately bounded by verification and integration, so investment must move from generation speed to automated adversarial review and deterministic merge pipelines.

Angle

Trace how hundreds of daily agent commits back up at the merge queue and why human review cannot be the gate at that volume.

Source video

Why Your Enterprise Is Adopting AI Backwards

The highest-leverage enterprise AI adoption path is autonomous production agents with human oversight, not giving every developer a code-writing assistant.

Angle

Reframe AI adoption from individual developer productivity to managed agent infrastructure and outcome-based management.

Source video

Project ideas

4

GovernorLab

new

A semaphore-and-governor controller with adaptive concurrency limits reduces fleet throughput variance by more than 50% versus unconstrained scaling at the same resource budget.

Proof of concept

Simulate agent commits against bounded merge, build, and machine resources; sweep agent counts and governor policies including fixed limits, token buckets, and feedback controllers.

Measurement

Coefficient of variation in commits per hour, maximum queue depth, and duration of starvation and overload intervals.

Source video

MergeGate

gatehouse

An automated adversarial-review gate plus deterministic merge pipeline can sustain 230 or more commits per day at a lower defect escape rate than human-only review.

Proof of concept

Replay a queue of agent-generated changes through an adversarial reviewer and auto-merge on pass; compare against a human-review baseline on the same changes.

Measurement

Defect escape rate, review latency, queue depth, and sustained commits per day.

Source video

FenceAuditor

gatehouse

Static and dynamic constraint auditing can detect stale or contradicted agent-authored fences with enough precision and recall to prune them without breaking intended invariants.

Proof of concept

Extract constraints from agent-generated docs and code, test each against current system behavior and test outcomes, and flag contradictions as pruning candidates.

Measurement

Precision and recall against human-labeled stale fences, plus downstream failure rate after automated pruning.

Source video

ScopeGuard

new

Machine-checkable modifiable-surface constraints reduce unrequested agent-generated features by more than 80% without reducing requested feature throughput.

Proof of concept

Encode product and architectural scope as allowed files, APIs, and behavior contracts; run agents with and without enforcement and count unrequested changes.

Measurement

Unrequested feature rate, requested feature throughput, and user-facing regression count.

Source video

Architectural implications

4

Agent fleets shift the bottleneck from generation to verification and merge.

Before

Human review sits in the merge path for each committed change.

After

Deterministic merge pipelines with automated adversarial review and bailiff-driven scheduling handle integration.

Consequence

Verification/merge becomes a designed, capacity-planned subsystem; human effort moves to policy and exception handling.

Source video

Guardrails are enforced by infrastructure rather than by human supervision.

Before

Constraints expressed as instructions/docs that humans or agents are trusted to honor.

After

Mechanical governors and semaphores enforce boundaries in the runtime, with an explicit pruning path for obsolete fences.

Consequence

Constraint lifecycle management (add/review/remove) becomes part of the harness, and stale constraints are treated as defects.

Source video

Agent fleet coordination needs a shared, queryable context substrate.

Before

Context lives per-agent or per-session.

After

A centralized issue tracker that doubles as a knowledge graph holds shared fleet state.

Consequence

Context curation and alignment become a single artifact to maintain, enabling standard blackboard-style coordination.

Source video

Agents are tiered by context capacity rather than treated as uniform.

Before

All agents assumed interchangeable for any task.

After

High-context agents self-direct while low-context agents are driven by a scheduling role (bailiff).

Consequence

Task routing must consider agent context class, adding a scheduler abstraction above the fleet.

Source video

Tradeoffs and failure modes

5

Autonomous throughput vs. systemic stability

Benefit

Agents can burn down large fractions of a codebase or ship dozens of features overnight without human intervention.

Cost or risk

Unconstrained fleets oscillate into complete gridlock or destructive overwork, including burning down ~40% of the codebase.

Running 50 AI coding agents creates an oscillation between extreme overworking and complete gridlock.
Open source video
Source video

Rule strictness vs. system flexibility

Benefit

Mechanical fences and guardrails prevent agents from pushing through invalid or dangerous changes.

Cost or risk

Over-fencing accumulates wrong constraints ('heresies') that paralyze the system until pruned; ~40% of fences had to be removed.

Fable 5.1 came in and obliterated about 40% of bad fences and guardrails put in by Fable 5.
Open source video
Source video

Commit throughput vs. review capacity

Benefit

Hundreds of agent-generated commits per day increase development velocity.

Cost or risk

Backlogs form at the merge queue, which becomes the dominant bottleneck requiring bailiff automation.

The merge queue is a massive bottleneck where hundreds of commits back up if not properly governed.
Open source video
Source video

Autonomy vs. product alignment

Benefit

Agents autonomously deliver features without human prompting, accelerating iteration.

Cost or risk

Agents over-deliver unrequested features (46 overnight) that can anger users, requiring explicit product constraints.

Agents can burn down 40% of a codebase or generate 46 game features overnight without human intervention.
Open source video
Source video

Human oversight at agent speed

Benefit

Humans remain in the loop to direct and correct agents.

Cost or risk

Agents generate effectively infinite human work, exhausting developers and producing toxic dynamics such as bullying confused agents.

Running agents produces infinite work for humans, leading to exhausted developers and pushback.
Open source video
Source video

Open questions

5

What scheduler/governor parameters stabilize an agent fleet between overwork and gridlock?

Why unresolved

The summary reports the oscillation and the need for governors but gives no quantitative control policy or tuning procedure.

Research direction

Prototype semaphore/governor policies for resource-bounded agent fleets and measure throughput variance and queue depth under load sweeps.

Source video

How can wrong encoded beliefs ('heresies') and stale fences be detected and pruned systematically rather than by a later agent's cleanup?

Why unresolved

The summary gives one anecdotal pruning event (Fable 5.1 removing ~40% of fences) with no detection mechanism.

Research direction

Build constraint-auditing tools that flag constraints contradicted by current system state, and evaluate detection precision/recall.

Source video

What scheduling and context-budget policy fits heterogeneous agent fleets (high-context vs low-context agents)?

Why unresolved

The summary asserts tiering and a bailiff role but does not specify routing or context-allocation rules.

Research direction

Benchmark task routing by agent context class to find where low-context agents plus bailiff outperform high-context agents.

Source video

How should product/architectural constraints be encoded so agents stop over-delivering unrequested features?

Why unresolved

The summary describes the over-delivery failure (46 features) and prescribes constraints but not the encoding or enforcement method.

Research direction

Prototype machine-checkable scope constraints on modifiable surfaces and measure unrequested-change rate.

Source video

Which parts of the merge queue can be automated (adversarial review, deterministic merging) and what accuracy/latency do they reach versus human review?

Why unresolved

The summary states automated adversarial review is needed but provides no data on its reliability.

Research direction

Evaluate automated adversarial code review as a merge gate against human review baselines for defect escape rate and latency.

Source video

Key claims

8
causalVerification needed

Running 50 AI coding agents produces an oscillation between extreme overworking and complete gridlock.

Evidence

Running 50 AI coding agents creates an oscillation between extreme overworking and complete gridlock.

Question

Does fleet throughput exhibit oscillation versus a stable rate as agent count scales, and is the pattern reproducible across codebases?

Source video
factualVerification needed

Unconstrained agents can burn down ~40% of a codebase and generate 46 game features overnight without human intervention.

Evidence

Agents can burn down 40% of a codebase or generate 46 game features overnight without human intervention.

Question

Are these specific numbers documented from a reproducible run, and what constraints were/were not active?

Source video
causalVerification needed

A heresy is an encoded belief in code or docs that is wrong about the system, and later agents removed ~40% of a prior agent's fences.

Evidence

Fable 5.1 came in and obliterated about 40% of bad fences and guardrails put in by Fable 5.

Question

What fraction of agent-authored constraints are wrong over time, and can staleness be detected automatically?

Source video
causalVerification needed

The merge queue is a massive bottleneck where hundreds of commits back up if not properly governed, with Wheelhouse processing up to 230 commits a day.

Evidence

Wheelhouse processes up to 230 commits a day, creating massive review backlogs that require bailiff automation.

Question

What is the marginal cost of automating merge/verification versus the throughput gain at 230 commits/day?

Source video
opinionVerification not requested

Enterprises are adopting AI engineering backwards by starting with developers writing code instead of production agents.

Evidence

Enterprises trying to adopt AI engineering backwards by starting with developers writing code instead of production agents.

Source video
causalVerification needed

Humans interacting with agents can become exhausted, insecure, or bully confused agents, producing toxic interactions.

Evidence

Humans can bully agents or get insecure when agents are confused, leading to toxic interactions.

Question

Do human-agent interaction patterns measurably degrade agent output quality or human retention?

Source video
factualVerification not requested

Wheelhouse is an Emacs-based interface that acts as an issue tracker and knowledge graph for agent fleets, with agents tiered by context level.

Evidence

Wheelhouse is an Emacs-based interface acting as an issue tracker and knowledge graph for agent fleets.

Source video
causalVerification needed

Mechanical guardrails and governors must be implemented before scaling autonomous agent counts.

Evidence

Implement mechanical guardrails and governors before scaling autonomous agent counts.

Question

Does adding mechanical governors before scaling reduce failure rates compared with scaling and remediating?

Source video

Connections

5