Skip to main content
November 19, 2026

Why 30-Item Agent Plans Fail: Granularity, Task Graphs and One Coordinator

Why 30-Item Agent Plans Fail: Granularity and Delegation

You ask an agent for a remediation plan and get 30 numbered steps. You skim, approve, and around step 17 it does something you would have rejected, if you had still been reading.

A simple rule helps here: a plan the human cannot hold in their head is a bad plan for the agent too. Below: why flat plans break, two ways to shrink them, when a manager agent should build a task graph, and why questions need one entry point.

Why Flat Plans Break

Errors compound. Take an illustration, not a measurement: if each step succeeds independently 95% of the time, all 30 steps succeed about 21% of the time (0.95^30). Six steps at the same rate succeed about 74% of the time. Real steps are not independent, but the shape holds: in a flat list nothing catches an error before the next step builds on it.

Length is the axis that hurts. METR's paper Measuring AI Ability to Complete Long Software Tasks rates models by the length of tasks they finish at a 50% success rate: about 50 minutes for Claude 3.7 Sonnet when it was written, doubling about every seven months since 2019. The authors say the growth seems driven mainly by "greater reliability and ability to adapt to mistakes". Longer work fails more often.

Static plans cannot adapt. The ADaPT paper names the problem with plan-and-execute agents: "the inability to execute any sub-task may lead to task failure." A 30-step plan written up front fixes every step before the agent has seen the first result.

Review turns into a rubber stamp. Nobody checks step 23 against step 4, and sometimes nobody checks at all: in Claude Code agent teams, a teammate that plans first sends a plan approval request to the lead, and if its permission mode has not changed since it was spawned, "Claude Code approves the plan as soon as the request arrives, without the lead reviewing it." An approval step does not mean anyone read the plan.

Fix One: Phases

Cut the plan into phases of a few steps each, and give every phase an exit check that a machine or a human can verify. Only the current phase needs detail. Later phases stay one line long, because their details depend on what earlier phases find.

Fix Two: Raise the Altitude

Write the plan as outcomes and checks, not keystrokes. "Drain node-7 and confirm no pods are pending" is one plan item. The six kubectl commands behind it are the executor's business.

ADaPT shows why this works. It decomposes a sub-task only "when the LLM is unable to execute" it, recursively, and it "dynamically adjusts to the capabilities of the executor LLM as well as to task complexity." It reports success rates up to 28.3% higher in ALFWorld, 27% in WebShop and 33% in TextCraft than strong baselines. The lesson for hand-written plans: detail should appear where the executor needs it, not everywhere in advance.

Worked Example: A Database Failover Plan

The flat version has 30 steps: check lag, pause writers, promote, update DNS, restart and smoke-test each of eight services.

The phased version:

Phase Goal Exit check
1. Assess Confirm the primary is unhealthy and pick the replica Replica lag under the agreed limit, decision written down
2. Freeze Stop writes Write rate at zero on the primary
3. Promote Promote the replica and move the endpoint New primary accepts writes, endpoint resolves to it
4. Reconnect Bring clients back Error rate back to baseline for every service
5. Close Record what changed Timeline and every state-changing command logged

Five lines fit in a reviewer's head. Each exit check is a stop point: if it fails, the agent reports instead of improvising.

When a Manager Agent Should Build the Task Graph

When work really is big, the plan should be a graph, and a manager agent can build it.

Anthropic's Building effective agents describes the orchestrator-workers pattern: "a central LLM dynamically breaks down tasks, delegates them to worker LLMs, and synthesizes their results." It fits "complex tasks where you can't predict the subtasks needed."

LLMCompiler uses a planner that formulates an execution plan of function calls, a task fetching unit that dispatches them, and an executor that runs them in parallel. Against ReAct it reports latency speedups of up to 3.7x, cost savings of up to 6.7x and accuracy gains of up to about 9%. Those are function-calling benchmarks, not remediations, but the point carries over: independent tasks should not wait in line.

Tooling supports this now. In Claude Code agent teams, a task in the shared list "can also depend on other tasks and shows as blocked in the task list until they're completed", and it unblocks on its own. Claude Code subagents can spawn their own subagents, "up to three layers below the main conversation" by default, set with CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH. That is the sub-manager pattern: a manager hands a branch of the graph to a subagent that splits it again. Agent teams are flatter by design: "teammates cannot spawn their own teammates. Only the lead can manage the team."

Can agents decompose reliably? Only with guardrails. Anthropic's multi-agent research system post says early agents made "errors like spawning 50 subagents for simple queries", and the fix was explicit scaling rules: "Simple fact-finding requires just 1 agent with 3-10 tool calls". Google Research's study of 180 agent configurations found that on a strictly sequential planning benchmark (PlanCraft) "every multi-agent variant we tested degraded performance by 39-70%", and that independent multi-agent systems amplify errors by up to 17.2x. Fan-out pays on parallel work and hurts on chains, as our post on supervisor agents vs one good agent covers.

The agent teams docs give sizing rules that echo the human rule. Tasks that are too large mean "teammates work too long without check-ins." Start with 3 to 5 teammates, and "having 5-6 tasks per teammate keeps everyone productive." A 30-task backlog can be fine when no single agent or human has to hold more than a handful of it at once.

One Entry Point for Questions

Workers hit ambiguity. If every worker can ask the human, you get three versions of one question, answered inconsistently, at 3 a.m.

Claude Code removes AskUserQuestion from every subagent except forks, and when a background subagent needs permission, "Claude Code surfaces the prompt in your main session and names the subagent that is asking." In agent teams, the "lead is fixed": the main session leads for its lifetime. Questions flow up to one coordinator, who either answers from the context it already has or asks the human once.

Make that explicit in your own designs:

  • Workers report blockers to the coordinator, never to the human.
  • Only the coordinator may change the plan.
  • Answers go to every worker they affect, not only the one that asked.
  • A human question pauses the dependent branch, not the whole run.

Decision Table

Plan shape Move Why
A handful of steps, one system Keep it flat Easy to review, little to compound
Long, mostly sequential Phases with exit checks Each check stops a bad branch early
Long, steps are commands Raise the altitude The executor decomposes as needed
Many independent parts Manager builds a task graph Parallel work is where fan-out pays
A branch is itself large Sub-manager for that branch Keeps each manager's scope small
Workers need human input Route through one coordinator One voice, consistent answers

Checklist for a Plan an Agent Will Execute

  • Can you read the top level aloud in under a minute? If not, phase it or raise the altitude.
  • Does every phase or task have a check that proves it is done?
  • Are dependencies written down, so independent tasks can run in parallel?
  • Is there a cap on fan-out, both depth and number of workers?
  • Is one agent named as the owner of the plan and of all human questions?
  • Does any plan approval step actually reach a person who reads it?

Long runs also fill the context window; our post on context rot and compaction covers keeping state in files.

How Akmatori Applies This to Incidents

As the architecture docs describe, each Akmatori run gets a generated AGENTS.md that defines the incident manager role and a short, ordered workflow: search runbooks, then cross-incident memory, then recent change events, and only then call infrastructure tools. Runbook and memory lookups used to be subagents; they are now gateway tools with BM25 ranking and no LLM in the loop. The root cause is posted in the incident's chat thread, one place for the team to follow. Risky actions become proposals that wait for human approval.

Conclusion

A 30-item flat plan fails twice: the human cannot review it and the agent cannot carry it. Split it into phases with exit checks, write outcomes instead of commands, let a manager build a task graph only when the work is truly parallel, and route every question through one coordinator.

If your team wants AI-assisted incident workflows with short, verifiable plans and a single coordinator, Akmatori helps SRE teams investigate alerts, coordinate response, and automate safe infrastructure actions. Powered by Gcore for global infrastructure reliability.

Automate incident response and prevent on-call burnout with AI-driven agents!