Parallel Agents Do Not Need a Smarter Plan. They Need a Schedule.

Parallel agents stay safe when one person releases a work graph and a query, not the model, hands out the next small claim.

Rick Hightower

Cover image for “Parallel Agents Do Not Need a Smarter Plan. They Need a Schedule.” by Rick Hightower

AI agent task scheduling keeps admitted work in a graph: one human release, then small claims a query hands out.

A multi-step plan written in the prompt disappears when the context window compacts, and a second agent editing that same file makes the loss permanent. AI agent task scheduling holds only if the work graph, the claims, and the discovered work live outside any one session.

In this article: A Markdown plan fails when two coding agents share a feature. One human release of a work graph, atomic claims, a worktree per agent, and four paths for discovered work replace it. A fictional workspace export shows the pattern on one ticket.

Admission already let this ticket start. It is still eight or fifteen tasks: a query layer, a writer, an access check, tests, and a large-workspace check.

AI agent task scheduling exists because a Markdown plan dies on compaction, a second agent, or a bug with nowhere to go. Schedule leaves a released graph, claims, and a pull request. It does not call the next stage. A person stays at the release gate.

Two questions that look alike

Dispatch and Schedule both say "what is next." They do not mean the same thing.

Table: , Dispatch, Schedule. Rows: Question; Who decides; Unit; Output.

The comparison puts the two stages side by side on four rows. The first column names what is being compared. The Dispatch column gives Dispatch's answer, and the Schedule column gives Schedule's answer.

  • Question. Dispatch asks which tickets start, on which workflow, and with what budget. Schedule asks, inside admitted work, which step runs now and on which agent.
  • Who decides. For Dispatch, people set priority and Dispatch proposes. For Schedule, a query decides and a person releases the plan.
  • Unit. Dispatch works on a ticket. Schedule works on a package of 15 to 60 minutes.
  • Output. Dispatch produces admitted work with limits. Schedule produces claims, completed packages, and a pull request.

A scheduler over the whole backlog lets agents set team priority. Keep that queue with Dispatch. Keep the execution graph inside one admitted ticket. The stages share the ticket. They do not call each other.

Table: Part, Schedule. Rows: Trigger; Work; Independent check; Memory; Stop condition.

Schedule's loop has five parts. The Part column names each part, and the Schedule column says what that part is for this stage.

  • Trigger. Schedule runs on admitted work, a closed step, a merged dependency, or an expired lease.
  • Work. It writes packages, runs a ready query, hands out claims, and triages discoveries.
  • Independent check. A gatekeeper validates the graph, and a person releases it before any claim.
  • Memory. It recalls past breakdowns, estimates, and work discovered late last time.
  • Stop condition. It stops when every package is closed, or when an admission limit sends the work back to an engineer.

Shrinks for the human: tracking which agent holds which step. Grows for the human: one release of the plan, and the scope questions discovered work raises.

The scheduling pattern, one human release

One agent writes every package. Workers take one step and do not rewrite the plan. The graph sits outside the prompt. A query, not the model, decides what is ready.

The scheduling pattern, one human release: plan the whole graph, a person releases it once, then a query hands out leased claims.

Plan once. Each package has acceptance criteria, a design note, an estimate, and a spec section by ID and pinned revision. Dependencies are edges. Import the whole graph in one step. Size is 15 to 60 minutes, one commit. Spec-first covers one task. Spec-anchored stays beside the code. Spec-as-source is the only file a person edits.

One human release. A script rejects cycles, orphans, missing criteria or spec references, duplicates, and estimates over about 90 minutes. A person releases the plan, and the release is recorded on the ticket. Hard edges gate readiness. Soft links, such as "discovered while working on" or "related to," do not block.

Claim, lease, worktree. A claim succeeds or fails cleanly. Live workers renew a short lease, and a timer returns expired claims to the pool. Each worker gets a git worktree, its own branch. It closes the step or files new work. The finished graph is a pull request. A person merges it.

Discovered work

Only the agent that found the extra work can tell which path applies. It proposes one. It does not waive scope.

Four paths for discovered work. Out-of-scope finds leave the graph as a proposed ticket for a person.

  1. It does not block. File a linked package and keep going.
  2. It blocks this step. Add a blocking edge, release the claim, and let the new package jump the ready frontier.
  3. It invalidates a later package. Supersede it. Keep the old package closed, with a reason.
  4. It is outside scope, or nobody is sure. Do not add it. Write a proposed ticket for a person. If this ticket cannot finish without it, stop and hand the question to the engineer.

Teams skip the fourth path. Quiet extra steps can turn a two-hour ticket into a two-day one while the owner still believes the original scope.

Claims and states

The same step can be claimed only once. Each worker has its own worktree, and a dead lease returns to the pool.

A package stays unreleased until a person releases the plan, then moves among ready, claimed, and closed.

Three tools, one owner per fact

A plan source writes the first task list. A ticket store holds the team record. A task graph runs execution. The tool names in each path are examples.

Table: Path, Plan source, Team record, Execution graph, Fits. Rows: Solo; Plan mode to graph; Methodology to graph; Migration batch.

Four paths combine the three tools in different ways. The Path column names the combination. Plan source says what writes the first task list. Team record says where the team's record lives. Execution graph says what runs the steps. Fits names the situation each path suits.

  • Solo. Claude Code plan mode writes the plan, your tracker holds the team record, and Claude Code Tasks runs execution. It fits one engineer doing short work.
  • Plan mode to graph. Claude Code or Codex plan mode writes the plan, WikiTicket holds the team record, and Beads runs execution. It fits parallel agents on a feature.
  • Methodology to graph. Superpowers or GSD writes the plan, WikiTicket holds the team record, and Beads runs execution. It fits an existing planning skill set.
  • Migration batch. A codemod's edit sites form the plan, one ticket per campaign holds the team record, and Beads runs execution with one package per site. It fits maintenance campaigns.

Most factories grow into the plan-mode-to-graph and methodology-to-graph paths. WikiTicket owns the plan the team can see. After admission, Beads owns the frontier, the claims, and the leases, then writes a summary back to the ticket. Closing every step produces a pull request. A person merges it.

Signals, and a small start

Table: Signal, What it tells you. Rows: Discovered work per ticket; Package count and size; Reclaimed leases; Blocked time; Estimate versus actual.

Five signals show whether scheduling works. The Signal column names what to measure, and the What it tells you column says what the measurement means.

  • Discovered work per ticket. A high count means the ticket was not ready.
  • Package count and size. Tiny packages mean over-decomposition, and each one costs spin-up and tests.
  • Reclaimed leases. These show stuck workers. A rising count points at the harness, not the plan.
  • Blocked time. It measures ready work waiting on a dependency or a person.
  • Estimate versus actual. It shows whether planner sizing can be trusted.

Recall what showed up late on similar work. Evidence is thin to medium: the split works, and the failures are huge ready queries, over-decomposition, zombie claims, and backward dependencies. Thoughtworks lists agent-native task trackers as a category to assess, and Claude Code's task list was inspired by Beads. A low discovered-work count means the Plan stage is doing its job.

A fictional workspace export

The access-check ticket has merged. The export ticket is admitted. The planner writes the query layer, the CSV writer, a test per criterion, and the large-workspace validation, using the acceptance criteria and the tenant-isolation decision. The query layer blocks the writer. The writer blocks the tests.

The fictional export: one graph, one human release, then a time-zone fix that jumps the frontier without a hand re-plan.

The large-workspace validation is estimated at three hours, so the gatekeeper rejects it and the planner splits it. The engineering lead releases the graph. The release is recorded on the ticket.

Two workers claim steps in their own worktrees. One finds a date-formatting helper writing the wrong time zone into the CSV. The bug blocks the writer, so the worker files a blocking package, releases its claim, and the fix jumps the frontier. Nobody re-plans by hand.

Do this today

  • Put the next multi-step feature in packages with dependency edges, not in a prompt checklist.
  • Hold each package to 15 to 60 minutes. Block estimates over about 90 minutes until a person releases the plan.
  • Script the gatekeeper: no cycles, no orphans, criteria, a spec reference, no duplicates.
  • Use atomic claims, a short lease, a reclaim timer, and a git worktree per agent.
  • Stay on plan mode until two agents must share one feature.

The graph outlives the session

One person releases the graph. A query decides what is ready. A claim is won or lost cleanly, and discovered work is filed instead of chased. You remain the only one who can waive scope.

How do your agents keep a multi-step plan today, and what happens when two of them share a feature?


This is Part 5 of "AI Software Factory Series," a 17-part guide to building an AI software factory with human gates.