Inigo AnguloContact
Work01How I think02Lab03Writing04
Writing

AI agent teams for software development: what actually works in 2026

Inigo AnguloNovember 4, 20269 min readAI agent teams

Most of what is written about AI coding agents is either a demo or a warning. This is neither. It is the operating model I used to build and run a production platform with eight agents and no engineers on payroll: 445 merged pull requests, 1,456 CI runs and 15 gated releases in seven weeks. The model is not clever. It is a set of boring decisions about who may do what, and it is the reason the numbers are real instead of a story.

This is the hub of a series. Each section links to a deeper piece. If you want the method as steps to follow rather than the operating model, start with how to build an MVP with AI agents.

HUMANticketsdecisions LEADdecomposeintegrate frontend backend data design review security approvehuman PROD green: a human decides / amber: an agent gates / nobody right of the lead holds production credentials
The shape of the team. The volume comes from the middle; the trust comes from the edges.

1. Roles with mandates, not prompts

Each agent has a file that says what it does, which files it may touch, and what it must never do. A lead that decomposes tickets and integrates. Workers for frontend, backend and data. A reviewer that returns a list of concrete faults, not opinions. A security agent that runs a full penetration test before every release. A design agent with the only write access to the design tool. A verifier that only reads and can only answer PASS, FAIL or UNVERIFIABLE from a script's output.

The mandate outlives the session. That is the difference between a team and a chat: a worker that receives an instruction mid task from anyone but the lead does not apply it, it returns it. That rule alone removed a class of failures where a stray instruction in a file or a log was treated as a command.

2. Isolation before speed

Every ticket gets a branch from an up to date main, never from another ticket's branch. Every worker gets its own worktree and, when it needs a database, its own local stack with its own ports. Two agents sharing one database reset each other and measure the neighbour's schema; I learned that on a day five of them did it at once.

No agent holds production credentials. Not read only, not "just for checking". Agents deploy to production through a workflow that holds the secrets; they never see them. The reasoning is simple: an agent with a production token can route around every other gate, so the token is the gate.

3. Gates that mean something

Five required checks before main accepts a merge: lint with house rules, strict types, the test suites, a check that auth templates are intact, and a secrets scan on every commit of the branch. Browser tests on every change that is not documentation. A penetration test with a written verdict before every promotion. Then one human approval.

The subtle part is what counts as proof. A skipped check reports as green. A test that documents a bug protects the bug. A deployment that says READY can serve a 404. I wrote the rules for that in Why a green check is not proof, and the two human gates in Human in the loop for coding agents.

4. A decision log with ids

Agents hit decisions constantly: a name, a boundary, a trade off. Every one becomes a numbered item with lettered options and a recommendation, and I answer with an id and a letter. The answer is written into the repository with the reasoning and the alternatives. Over seven weeks that is more than 140 decisions, and it is why a fresh session can continue the work without re-arguing it. Configuration, naming, test structure and git conflicts never reach me; those are the lead's.

5. Facts come from scripts

No agent declares an external fact. "CI is green", "the preview works", "the migration is safe" are not sentences in this system. A script produces JSON with the run id, the commit, the deployment id or the URL, and the agent interprets it. If the script says FAIL, no amount of text turns it into PASS. This sounds pedantic until you have watched a fluent, confident summary describe a deployment that never happened.

What it produced

17 daysfirst commit to first production release
445pull requests merged, 38 closed unmerged
147red CI runs: the gates working
15numbered releases with a security report

The full story with the evidence read from the GitHub API is in 445 PRs in seven weeks, and the product itself in the Acervo case study.

What it costs, and what it does not replace

The agent bill was a few hundred francs a month. The expensive part was still judgment: what the product should be, which invariants live in the database, what counts as done. Agents made execution cheap enough that the gates where a human looks became the product. If you take one thing from this: do not start with the agents. Start with the rules for what counts as proof, then let the agents be fast inside them.

Next in the series: Human in the loop for coding agents: the two gates that matter. If you want this set up inside your company: AI build and deployment.

Working on something like this?

This is the method behind how I build: AI native development with human gates. Discuss a product idea → Or email me.