The agent org chart: what DL4 actually demands

DL3 was knowledge. DL4 is management.

DL3 is the knowledge layer: the CLAUDE.md, the context files, the team standard. At DL3 you still drive every phase by hand. The gain is real and capped, because you are the bottleneck in every loop.

DL4 is what happens when you hand that knowledge to a fleet of agents and step back to review. One request in, a finished feature out, you approving only the parts that matter. The work changes shape entirely: you are no longer the developer who prompts. You are the manager of a team you cannot see.

• Your job.At DL3 you drive every phase by hand. At DL4 you review the parts that matter.
• The unit of work.At DL3 it is the prompt. At DL4 it is the request.
• Who executes.At DL3, you, one session at a time. At DL4, a fleet of agents working from the same context.

The hard part was never the agents

An agent that writes code is the easy eighty percent. The moment you have more than one, the real problem appears, and it is not technical. It is organisational: who hands work to whom, who is allowed to ship, who catches the security regression, who turns a single correction into a standing rule the whole fleet obeys.

That is an org chart. Not a metaphor for one, an actual chart of roles, authority and review gates, except every box is an agent and you are the only human in the room.

Which agents to build first

You do not build the whole fleet at once. You build the agents that close the loop first, and you add the governance layers last. The order is the strategy. Build it backwards and you get a fleet that ships fast and wrong.

• 1. Close the loop.One request goes in, a finished feature comes out, a human approves the parts that matter. Nothing else ships until this loop is trustworthy on its own.
• 2. The conductor.The orchestration layer that routes work, holds state and gives you one thing to manage instead of sixteen. Skip it and you are back to babysitting every session by hand.
• 3. Security.The agent that catches the regression a coder would happily ship. A fleet without it does not move slower. It moves wrong, faster.
• 4. The learning loop.Every correction you make at review flows back into the shared context, so the fleet makes a mistake once instead of sixteen times. This is your DL3 brain, now feeding agents.
• 5. Discovery.The agents that surface work rather than just do it. Powerful, and useless before the loop, the conductor and governance are solid. Last for a reason.

Where DL4 teams stall

The teams that stall at DL4 are the ones that built coders and skipped the conductor and the governance. They have a fleet writing code and nothing managing it, so velocity goes up while trust goes down, and eventually they quietly roll the whole thing back.

Here is the trade-off the demos skip: a fleet amplifies whatever you give it. A good rule propagates to every agent instantly. So does a bad one. Without the learning loop and the review gate you built at DL3, you are not scaling delivery. You are scaling your worst assumption, in parallel.

Map your delivery to DL4

If you reached DL3 you already have the knowledge. DL4 is the harder, less glamorous work of turning that knowledge into roles, authority and gates a fleet can run without you in every loop. Build the agents that close the loop. Add the conductor. Then govern. In that order.

So here is the question I keep asking our own teams: if you mapped your delivery to DL4 tomorrow, which layer would you keep a human on the longest?