--- slug: issue-control-plane type: pattern summary: "Use durable work items to qualify, dispatch, observe, and review coding-agent work without depending on any one agent session." created: 2026-11-16 updated: 2026-11-16 related: loop-engineering: relation: implements note: "The issue tracker supplies discovery, durable state, and stop conditions for an engineered outer loop." blackboard: relation: specializes note: "An issue control plane specializes the shared blackboard into typed work items with an explicit lifecycle." agent-workflow-graph: relation: uses note: "Dependencies and lifecycle transitions between work items form a workflow graph that the dispatcher can evaluate." worktree-isolation: relation: uses note: "Each eligible work item runs in an isolated checkout so concurrent agents cannot overwrite one another." background-agent: relation: uses note: "A dispatched work item becomes a bounded background-agent run whose outcome returns to the same record." agentic-pull-request: relation: produces note: "A successful work item commonly produces an agentic pull request linked back to its objective and evidence." approval-policy: relation: uses note: "Approval policy determines which work items may start automatically and which terminal results need human review." --- # Issue Tracker as Control Plane > **Pattern:** A named solution to a recurring problem. *Use the issue tracker or project board as the durable control plane for coding agents: qualify work there, dispatch eligible items, track each run, and return evidence to the same record for review.* *Also known as: Issue-Centered Orchestration, Work-Item Control Plane* ## Understand This First - [Loop Engineering](loop-engineering.md) — the outer loop that discovers work, runs agents, verifies results, and decides when to stop. - [Blackboard](blackboard.md) — a shared structured surface through which independent workers coordinate. - [Agent Workflow Graph](agent-workflow-graph.md) — the dependency and lifecycle model that decides which work can run next. - [Worktree Isolation](worktree-isolation.md) — the separate checkout that keeps one agent's changes from colliding with another's. ## Context At the **agentic** and **organizational** levels, teams often begin with coding agents as interactive tools. A developer opens a session, explains a task, watches the work, and remembers what happened. That works while there are only one or two sessions. It breaks when a lead is supervising several agents, work continues in the background, or a task must survive a crash, handoff, or restart. The team already has a durable record of intended work: issues, tickets, or project-board cards. Each record can hold an objective, owner, dependencies, acceptance criteria, discussion, and links to code. The issue tracker is therefore a natural place to coordinate agents, but only if it does more than store a backlog. A passive list becomes a control plane when automation uses its state to decide what may run, starts the run, observes liveness, retains evidence, and enforces the terminal review boundary. OpenAI's Symphony describes this move explicitly: the issue tracker becomes the control plane for isolated coding-agent work. GitHub has brought agent assignment, session status, logs, and steering into Issues and Projects. Atlassian describes Jira Automation in similar terms and extends it into governed loops that turn qualified backlog items into review-ready pull requests. The products differ, but the system shape is the same. ## Problem How do you coordinate many coding-agent runs without making a human remember the state of every session? Chat threads and terminal sessions are poor coordination records. They are easy to start and hard to inventory. A session may be working, waiting for input, stalled, finished without evidence, or dead while its task still looks active. The next agent may repeat the same investigation because the prior run's findings never reached a durable surface. A lead can supervise a few such sessions by memory; beyond that, context switching becomes the bottleneck. A plain issue queue doesn't solve this by itself. If an agent can claim any open issue, if status changes mean whatever each worker wants them to mean, or if "done" records only the agent's opinion, the tracker is just a prettier chat history. The coordination surface needs an executable lifecycle. ## Forces - **Work must outlive execution.** The objective, current state, and evidence have to survive any one agent process or context window. - **Not every ticket is agent-ready.** Ambiguous goals, missing acceptance criteria, unresolved dependencies, and sensitive authority boundaries must block dispatch. - **Parallel work needs exclusion.** Two agents claiming the same item, or editing the same files through different items, can destroy more time than parallelism saves. - **Liveness and completion are different facts.** A running session can be stuck; a terminated session can leave useful work; an agent's success message doesn't prove acceptance criteria passed. - **The control plane must not become a second product.** Teams gain from using the work system they already inspect, but custom orchestration can turn a simple queue into fragile infrastructure. - **Throughput can outrun review.** Faster dispatch creates more pull requests and evidence packets, while human review remains finite. ## Solution **Make the work item the durable unit of orchestration, and give it a small enforced state machine.** An orchestrator reads eligible items, claims one atomically, launches an isolated agent run, records progress and evidence back on the item, and advances it only when the transition's gate passes. The useful minimum has six parts: **Qualification.** Define what makes a work item dispatchable. It should name one concrete outcome, bound the allowed surface, state acceptance criteria, expose dependencies, and carry the authority the agent actually has. A label such as `agent-ready` is meaningful only when something verifies those conditions before applying it. **Atomic claim.** Move one item from ready to claimed in a single operation. Record the run identity and workspace with the claim. If another worker already holds it, don't start a second run. File-level or subsystem conflicts may require a broader exclusion rule than issue identity alone. **Isolated execution.** Give the claimed item its own [Worktree Isolation](worktree-isolation.md), branch, container, or ephemeral environment. The work item's scope becomes the agent's boundary. A failed run can then be discarded or retried without contaminating other work. **Liveness.** Record a small set of operational states such as queued, claimed, working, blocked, awaiting review, completed, and failed. Add heartbeats or bounded deadlines where a silent worker would otherwise hold an item forever. A timeout should return the item to an explicit recovery path, not quietly mark it ready and lose the failed attempt. **Evidence.** Put the result where the next person or agent will find it. Link the branch or pull request, checks run, relevant logs, review findings, and remaining risks to the work item. Preserve failed attempts too: a reproduction that didn't work or a dependency that blocked progress can keep the next run from paying for the same discovery. **Terminal review.** Separate "the agent stopped" from "the work is accepted." Executable checks may advance low-risk work automatically. Code changes that cross the team's [Approval Policy](approval-policy.md) stop at human review. The work item closes only after the required gate has accepted its artifact. The state machine should be strict about meaning and modest in size. If teams need a paragraph to explain the difference between twelve working states, the tracker is becoming harder to operate than the agents. Prefer a few states backed by specific transition rules and put detail in evidence fields. > **💡 Tip:** Start by automating the return path, not the dispatch path. Require every agent run to attach its artifact, checks, and stop reason to one work item. Once that record is dependable, automatic claiming and scheduling become much safer. ## How It Plays Out A team maintains a service with a long bug backlog. A triage rule marks an issue agent-ready only when it has a reproduction, bounded component, and executable acceptance test. The dispatcher claims one eligible issue, opens a worktree, and starts a [Background Agent](background-agent.md). The agent posts a branch and test result back to the issue, then moves it to awaiting review. If the run goes silent past its deadline, the control plane marks it stalled and preserves the workspace for diagnosis. It never treats silence as completion and never launches a duplicate while the claim is live. A platform group wants several agents to update independent internal libraries. Each issue declares its target repository and depends on the issue that publishes the shared schema. The work items form an [Agent Workflow Graph](agent-workflow-graph.md): leaf upgrades can run together, while dependent work stays blocked. A successful run opens an [Agentic Pull Request](agentic-pull-request.md) with build evidence. Merge remains human-owned. The board shows which work is runnable, which dependency is holding the rest, and which artifacts are waiting for attention. A startup wires every open ticket directly to an agent and celebrates the first week's throughput. The review column soon contains dozens of large pull requests. Agents retry vague issues, reopen one another's files, and spend tokens re-discovering missing requirements. The failure isn't that issues make a bad control plane. The team skipped qualification, exclusion, and terminal review. It fixes the system by narrowing `agent-ready`, limiting concurrent claims by subsystem, capping retries, and refusing new dispatch when the review queue passes a threshold. ## Consequences **Benefits.** Work becomes inspectable across sessions. A person can see what is ready, running, blocked, failed, or awaiting review without opening every agent transcript. Restarts get cheaper because the durable record preserves the objective and prior evidence. Dependencies can control dispatch, while atomic claims and isolated workspaces make parallelism safer. The same record connects intent to artifact: issue, run, branch, checks, review, and closure. The pattern also moves supervision toward exceptions. Humans don't have to watch each tool call. They qualify work, review terminal artifacts, and investigate blocked or unhealthy runs. That shift is where much of the throughput gain comes from. **Liabilities.** The tracker can become a false source of truth. A green status means little if workers can set it without passing the real gate. Stale claims can strand work, aggressive automatic retries can waste money, and weak dependency data can dispatch tasks in the wrong order. The control plane itself needs observability, recovery rules, and tests for its state transitions. More output can make the human system worse. If agents produce review work faster than people can absorb it, the board fills with technically finished but practically abandoned artifacts. Back-pressure belongs in the dispatcher: pause new work when review, integration, or deployment capacity is saturated. Finally, issue trackers are optimized for human coordination, not always for high-frequency event streams. Keep detailed tool traces elsewhere and attach bounded summaries and evidence links to the item. The work item should remain readable enough that a reviewer can decide what happened and what to do next. ## Sources - OpenAI's [open-source Codex orchestration with Symphony](https://openai.com/index/open-source-codex-orchestration-symphony/) describes an issue-tracker control plane that turns project work into isolated coding-agent runs and returns results for review. - GitHub's [agent activity in Issues and Projects](https://github.blog/changelog/2026-03-26-agent-activity-in-github-issues-and-projects/) brings coding-agent assignment and lifecycle visibility into the team's existing work-management surface. - GitHub's [agent-session management from Issues and Projects](https://github.blog/changelog/2026-04-23-view-and-manage-agent-sessions-from-issues-and-projects/) adds direct inspection and management of active agent sessions from the durable work record. - Atlassian's [Jira Automation as an agent control plane](https://www.atlassian.com/blog/development/scale-agent-impact-with-jira-automation) describes coordinating multiple coding-agent providers through Jira's work and automation model. - Atlassian's [governed agent loops](https://www.atlassian.com/blog/jira/governed-agent-loops) connects qualified backlog work, continuous agent execution, governance, and review-ready pull requests. --- - [Next: Agent Governance and Feedback](agent-governance-and-feedback.md) - [Previous: Loop Engineering](loop-engineering.md)