ztzoff.tech

Nov 5, 2026

The second agent is harder than the first

One agent is a project. Two is an operation: shared permissions, shared memory, a cost that no longer rounds to zero, and agents that drift apart. What to settle before adding the second one.

The first agent is a project. It has a sponsor, a budget code, a demo day, and a team that knows every prompt by heart. The second agent is when the company finds out whether it has an operation or a hobby. This is the first of two essays on the Scale stage of Discover, Design, Build, Scale, and it is about the things that were free with one agent and are suddenly not.

Permissions stop being a list and become a system

With one agent, the permission map is a document: what it reads, writes, changes alone, escalates, never touches. With two, the question becomes who is asking. Agent B calls a tool that agent A also uses. Does B have A's rights, its own, or the rights of the person who started the chain? A permission check that lived in one agent's code now has to live outside both of them, keyed on identity, and it has to be the same check for every agent you will ever add.

I have seen this go wrong in the simplest possible way: a lock meant to protect one tenant's data that reached across tenants, found only because an independent reviewer went looking for it. One agent would never have hit it. The second one would have.

Memory stops being private

If the first agent learned anything from its runs, the second one will want it. That sounds like a win and is a trap. A lesson that helped agent A on its tasks can hurt agent B on different ones. In our own measurements, lessons taken from the wrong kind of breakage did worse than no memory at all: 0.303 of trials verified against 0.455 without them.

So shared memory needs three things before the second agent reads it: a scope, so lessons are keyed to the situation they came from; a gate, so only runs that passed a check outside the model become lessons; and a holdout, so each consumer measures whether the shared memory helps it, separately. I covered why in weights, documents or experience and in why agents repeat the same mistake.

Cost stops rounding to zero

One agent's token bill hides inside someone's cloud account. Two agents calling each other, each with retries, each re-reading the same context, is a bill that shows up in a finance review. The multiplier is not two. A handoff between agents doubles the context being carried, and a loop between them can run for as long as the budget allows.

The fixes are design decisions, not optimisations. Cache-aware architecture decides which parts of the context stay stable across calls. The cheapest model that passes is chosen per agent, not per company, because the orchestrator and the specialist have different jobs. And the cost per run from the Build handover becomes a cost per workflow, measured end to end, with a budget alarm on it.

The agents drift apart

Here is the failure that nobody plans for. Agent A is tuned, or learns, or simply gets a model update. It gets better at its own cases. It also quietly changes the shape of what it hands to agent B, and B's pass rate drops with no deploy behind it. I call this evolutionary divergence, and the only defence is to treat the handoff as the thing you evaluate. Optimising each agent does not optimise the system.

Concretely: version-stamp every trace so a regression can be tied to a change in A even when nothing in B changed. Run the eval on the pair, not only on each. And put the shared contract between them, what A promises to produce and what B promises to accept, in writing, with a test.

The organisation has to change too

Two agents means two owners, or one owner with twice the surface. It means the runbook has a section on what to do when A is healthy and B is not. It means the sponsor of agent one, who got the demo day, is no longer the person who should decide about agent two. The decision about agent two belongs to whoever reads the holdout result from agent one, because that result is the only honest argument for spending the money.

A two-column comparison of what is free with one agent and what it becomes with two. Permissions go from a document to one check outside every agent, keyed on identity. Memory goes from private to scoped, gated and measured, or not shared. Cost goes from hiding in a cloud account to a per-workflow line with an alarm. Drift goes from impossible to version-stamped traces and an eval on the pair. The decision about the second agent moves from the sponsor to whoever reads the first agent's holdout result. Below, a bar chart of shared memory measured on realistic tasks: 0.455 of trials verified with no memory against 0.303 with lessons taken from the wrong kind of breakage.

What to settle before adding the second agent

  • One permission check outside every agent, keyed on identity, that all of them call.
  • A shared trace format with a version stamp on every span, so divergence has a place to show up. OpenTelemetry is the contract I use.
  • A per-workflow cost line with an alarm, not a per-agent one.
  • Scoped, gated, measured memory, or no shared memory at all until those three exist.
  • The first agent's holdout result, as the business case for the second.

None of this is exotic. It is the difference between a company that has an agent and a company that runs agents. The first agent earned the right to a second one only if it is done; and if it is, the list above is a few weeks of work, not a new programme.

Placing an existing agent against that list is a short exercise, and it is one I do in a free AI readiness assessment. Most companies with two agents discover they have two projects, not one operation, and that is fixable.

Book a discovery call