Software factory org design keeps headcount flat and reassigns ownership to a spec author, a verifier, a fleet operator, and a line owner, because agents absorb implementation and leave the specifying, verifying, and halting to people.
TL;DR
Agents absorb implementation, so the scarce human work becomes specification, verification, fleet operation, and the authority to stop a line. Headcount stays flat and composition changes. The org chart that results is organized around who owns a delivery line, not around who writes the code.
A review rotation sized for six pull requests a day meets thirty overnight, the engineer who configured the agents has left, and no one on the rotation can say who is allowed to stop the line.
A line here means one service and the five-station delivery path that ships it, from intake through release. Each of those stations creates work that has to land on a named person. Someone writes the specification the agents execute against and curates the test scenarios their output is judged on. Someone else needs documented authority to halt a running fleet. Neither job appears on an org chart today: no title, no place on a reporting chart, no entry in anyone's performance review.
This guide is for CTOs and VPs of Engineering deciding who owns a line once agents run it: the roles the factory creates, the functions it redefines, halt authority, team topology, and career design under delegated authorship. Ratio computation belongs to capacity forecasting. Engineering org design of this kind is a composition question before it is a hiring question.
What Changes Before Headcount Does
Engineering leaders decide which implementation work goes to agents and which controls engineers keep. A 2026 arXiv preprint followed 802 developers and 196,212 pull requests at one enterprise from January 2024 to April 2026, under a company-wide mandate to double throughput. Raw pull request volume grew 3.1x against the pre-mandate early-2025 baseline; the pool of developers acting as reviewers grew 1.5x; the share of pull requests receiving at least one human review fell from 89% to 68%. The work did not disappear when it moved; it landed on fewer people, in a shape nobody had staffed for.
"Scaling engineering without hiring" is the phrase leaders reach for, and it describes a real change badly. Output does not scale with agent count. What changes is composition: at the same headcount, implementation moves off engineers, and specification, verification, fleet operation, and release authority move onto them. A sustainable agents-per-engineer ratio exists, and it is worth computing before the org chart changes.
The Roles Software Factory Org Design Creates
Four accountabilities have to land on named people before a line runs unattended. They are jobs rather than job titles, and one engineer can carry two of them on a small team. Orchestration and governance owners emerge at the platform layer of an agentic operating model; these four sit on a single delivery line.
Spec Author
The spec author's deliverable is a specification, not code. It states the outcome, the scope boundaries, the constraints, and what acceptance looks like, in enough detail that an agent can execute against it without a follow-up. The author versions it in the repository so it survives their absence, which is what separates a specification from a ticket.
Verifier
The verifier owns the test scenarios and the scored validation pipeline, and decides which findings gate a merge. The Pragmatic Engineer reported on July 28, 2026 that Bun's creator rewrote it from Zig to Rust with 64 parallel agents in 11 days; implementation took about 15% of that time and fixing, testing, and verification took the other 85%. A verifier job description that reads like a QA job description has understated it by better than five to one.
Test Coverage maps untested critical paths with the Context Engine and drafts a test plan the team approves, then fans a fleet of agents across the repositories to write the tests. Code Review takes the first pass on every pull request. Both run on Cosmos, a unified cloud agents platform available on all paid plans, and the judgment stays with the verifier.
Fleet Operator
The fleet operator runs the control surface the agents execute inside. The Cosmos primitives are what this role administers: Environments set where agents run and what they can reach, Experts define agent behavior, and Sessions hold the conversation and the auditable record. Triggers start Sessions from events, schedules, and webhooks, and Automations wire an event source to an Expert. The operator owns that wiring, watches Cosmos Sessions for runaway work, and is the one person who can stop every agent at once.
Line Owner and Gate Owner
The line owner holds merge authority for one line and the authority to halt it. Both belong to the same person, because a halt is a merge decision made under time pressure. The factory model puts two human gates on the path, one at specification and one at release. A gate owner can hold either, and both report to the line owner. The Cosmos Session behind a merge is the record a gate owner reads before signing it off.
What makes a line owner real rather than decorative is a written record that names them, states that they may stop the line, and says that nobody has to approve that call. Without the last clause, the role is an audit-log field.
The Roles the Factory Redefines
Four existing functions change shape as those four accountabilities land, and each leaves work behind that someone has to pick up.
- Junior implementer: Westby, Modestino, and Cheng's IZA discussion paper, unrefereed and drawn from Lightcast vacancy data, estimates a 14 to 15 percent relative decline in junior versus senior developer vacancies in the year after ChatGPT's November 2022 release. The Stanford Digital Economy Lab puts employment of 22-to-25-year-olds in AI-exposed occupations 19% below the path of less-exposed peers, and calls that descriptive, not causal. Junior engineers still have to learn the system somewhere, and supervised specification work is where that now happens.
- Manual QA: PractiTest's State of Testing Report 2025 found 20% of teams had replaced about 75% or more of manual testing effort, up from 18% in 2023. Those testers are the strongest internal candidates for the verifier job.
- Review-heavy senior: A GitHub blog post published May 7, 2026, reported that Copilot code review had processed over 60 million reviews, growing 10x in less than a year, and observed that "Throughput has scaled exponentially. Human review capacity hasn't." The senior's leverage moves from approving changes to setting the bar each change is measured against.
- Ticket-grooming lead: Hoffmann et al.'s HBS working paper drew on a panel of 187,489 open-source developers observed weekly from June 2022 through June 2023. It measured project-management activity falling 10 percentage points, a 24.9% relative drop, against coding activity rising 5.4 points. Intake coordination turns into specification work, which is the spec author's job.
The remainder each one leaves is what the four roles above absorb.
Halt Authority and Incident Ownership
Naming an owner is the easy half. Granting that owner written permission to stop work already in progress is the half organizations skip.
Kraken's March 9, 2026 engineering post states that AI-generated code carries the same quality bar as any other code, and that the developer who pushes it remains responsible. The rule holds only if somebody can enforce it while the code is still moving.
Gartner forecast on May 26, 2026, that 40% of enterprises will demote or decommission autonomous AI agents by 2027 because governance gaps surface only after production incidents. LeadDev's AI Impact Report 2026, previewed in an August 7, 2026 article, found 81% of respondents give AI tools or agents write access to code repositories. Only 7% of organizations manage non-human identities on a dedicated platform, and only 15% rotate agent credentials on a schedule. Write access is granted far more often than the ability to revoke it under pressure.
When a verifier flags a bad result, the line owner halts that line and the fleet operator halts everything. Both authorities belong on the org chart, and both should be exercised in a drill while the stakes are low. Afterward the line owner reconstructs what each agent was doing from its Cosmos Session.
PagerDuty's engineering blog wrote on August 27, 2026, that service ownership once followed authorship, because whoever wrote the code understood it. Agents broke that chain. Service ownership now attaches to the line owner, whatever wrote the change, so the page goes to the person named on the line. The resulting on-call load is the practical cap on how many agents one person can carry.
Team Topology and Span of Control
Most AI engineering team structure debates stall on the org chart. The question that settles it is narrower: who writes the agent configuration, and who waits when it changes. Platform teams know the tradeoff from CI templates and lint configs. Agent configuration sharpens it, because the configuration decides behavior instead of checking it.
| Dimension | Platform-Owned Experts | Squad-Owned Experts |
|---|---|---|
| Authorship | Central group writes and versions templates | Squads fork and customize templates |
| Change latency | Squads wait on a platform queue | Squads ship behavior changes independently |
| Failure mode | Platform team becomes the bottleneck | Quality bars drift between squads |
| Compliance and security coverage | One reviewed template carries the security behavior for every line | Each squad reproduces it, and coverage varies |
| When to use | Experts encoding compliance or security policy and release policy | Experts encoding squad-specific acceptance criteria |
Cosmos supports the hybrid through its Expert Registry, where a platform group maintains shared templates and product squads fork them. Reporting follows that split: spec authors and verifiers sit in the squad, because both jobs need domain knowledge no central team holds for every service, and fleet operators sit in the platform organization.
A centralized fleet-ops team fits while the lines are few and the controls still moving, and one operator per squad fits once the wiring settles. The switch announces itself when the central queue turns up in squad retros. Span of control is set by review load and not by headcount: a line owner who cannot read the evidence behind every merge owns too many lines.
Hiring, Leveling, and Career Design Under Delegated Authorship
Under delegated authorship, seniority shows in judgment about specifications and evidence, because output volume now measures the workflow around a person more than the person. Canva described an AI-Assisted Coding competency replacing its Computer Science Fundamentals screening for backend and frontend roles in a June 11, 2025 post, with criteria including whether a candidate can find and fix issues in AI-generated code. Sierra wrote in April 2026 that it had dropped coding and algorithms interviews for a debugging round built on a colleague's draft PR. Karat's April 2026 rubrics treat evaluating code as the stronger signal.
Promotion follows the same evidence: specifications that survive execution without rework, halts called correctly, and a gate that got tighter because someone read the scores properly. LeadDev's Engineering Leadership Report 2026, based on responses from 600 engineers of whom 530 completed every question, found managing AI agents was the top personal skill-development priority for 73% of respondents, up from 60% in 2025. On the IC track, scope grows from specifications for one service to verification and gates across a line. The management track holds the line ownership.
Gartner's July 2026 forecast warns that by 2028, organizations relying on AI to cut junior roles will hollow out their own software engineering talent pipeline. A junior who writes specifications under a verifier and ships supervised changes still learns the system from the inside.
Where Software Factory Org Design Goes Wrong
Recurring failures in these reorganizations trace to authority that leaders discussed and never granted in writing.
- Owner in name only: The org chart names someone who appears in an audit log and has no power to halt the line. Give every named owner documented halt authority, then test it once outside an incident.
- Fleet ops as a bottleneck: One central team owns every shared template and every event wiring, so each squad waits on its queue. Publish the templates, let squads fork them, and keep the central team out of the per-change approval path.
- Seniors as gatekeepers: The Pragmatic Engineer reported in March 2026 that a senior vice president in Amazon's retail organization told teams to require senior sign-off on AI-assisted changes from junior and mid-level engineers. The trigger was a run of high-blast-radius incidents. Sign-off at that volume becomes a queue. Make those seniors verifiers who own the evidence bar.
- Cuts against the ceiling: Leadership reads agent output as slack and cuts headcount before measuring how much work actually got delegated. Hold headcount steady until measured delegation on your own lines supports a different decision.
A reorg moves boxes on the chart and leaves halt authority exactly where it was, which is why all four keep coming back.
Staffing the First Line by Conversion
Conversion staffs the first line from people you already employ. The senior who writes your most detailed tickets is already doing spec authorship, so hand them the artifact and the intake gate. Your strongest test-scenario author becomes the verifier. Fleet operation usually lands on whoever owns your CI/CD pipelines, since event wiring and runtime configuration are the same kind of work. Your tech lead with merge authority becomes the line owner on the day you write down that they may halt the line without asking.
Start the Cosmos deployment with a reviewed configuration in version control, a Session recorded for every agent run, and a halt path carrying the line owner's name. On a brownfield line, index the codebase before writing the first specification. The Context Engine maps semantic dependencies and cross-repository call flows, so your spec author writes constraints against real call paths. On a greenfield line, start one squad from shipped Cosmos Expert templates and use the factory maturity model to pick which gate gets the first named owner.
What to Do Next
Composition change at flat headcount buys throughput only when named owners keep their authority under release pressure. Run one halt drill this week on a service with a named line owner and a written halt path. Measure the minutes between the line owner's decision and the last agent going quiet, and write down who had to be asked for permission along the way. If anyone had to be asked, the authority was never granted, and the org chart is describing a factory you do not have.
Frequently Asked Questions
Related Reading
Written by
Ani Galstian
Ani writes about enterprise-scale AI coding tool evaluation, agentic development security, and the operational patterns that make AI agents reliable in production. His guides cover topics like AGENTS.md context files, spec-as-source-of-truth workflows, and how engineering teams should assess AI coding tools across dimensions like auditability and security compliance