Agentic Runner + Coding Agents

Inspiration

Codex is powerful at doing the work. The harder problem in long, multi-owner, or multi-output jobs is keeping intent, ownership, and proof of completion visible from the first decision to the final result. A coding task has the same problem at a smaller scale: useful decisions made during specification discussion can disappear before implementation and verification.

We built two independent Codex plugins to make those boundaries inspectable without replacing Codex's native tools.

What it does

Agentic Runner is an explicit upper control plane. It turns one parent request into a declared route map, assigns each output to a named execution owner, records shared constraints and lifecycle state, supervises fan-out and resume points, collects evidence from every branch, and blocks convergence when a branch is incomplete. This is especially useful for multi-output batch generation. Agentic Runner does not replace leaf generators; it controls their declared ownership and completion evidence.

Coding Agents is an explicit coding workflow that can begin before a detailed specification exists. The user and Codex can discuss behavior, interfaces, constraints, edge cases, acceptance criteria, tests, and forbidden changes. Confirmed decisions are turned into an actionable instruction document, such as docs/implementation-brief.md, and then into bounded assignments. Implementation is dispatched only through official Codex subagents and is verified against the agreed contract before finalization.

Each plugin is independently installable and usable. Coding Agents can take a project from specification consultation to verified code without Agentic Runner. Agentic Runner can supervise any declared tools, skills, plugins, or specialist workflows without Coding Agents. When used together, Agentic Runner owns cross-owner control and convergence while Coding Agents owns the coding branch. The shared marketplace is a distribution convenience, not runtime coupling.

How we built it

Both projects use Node.js standard-library APIs and Git. Their record-only CLIs preserve inspectable workflow state, while the Codex main thread retains policy, safety, integration, verification, and final-response ownership. Coding Agents deliberately does not launch codex exec or a custom child-agent process; official Codex subagents are its only worker-dispatch path. Agentic Runner binds supervised work to task identity, scope, lifecycle, handoff, resume, and completion evidence.

The Build Week demo used the current GPT-5.6-era Codex multi-agent V2 configuration with a session-wide ceiling of 30 concurrent agent threads and max_depth = 2. The root task is depth 0, a delegated control or coding branch is depth 1, and that branch may dispatch one bounded worker layer at depth 2. In paired use, Agentic Runner owns upper cross-output control, Coding Agents owns the coding workflow branch, and official Codex subagents execute bounded work. These are host Codex limits, not separate per-plugin pools, and simpler standalone runs can use a shallower topology.

Agentic Runner and Coding Agents had been under development long before OpenAI Build Week. With the arrival of GPT-5.6, we used GPT-5.6 Sol ULTRA to carry out a large-scale refactor so both plugins would operate correctly in the new Codex environment. GPT-5.6 Sol ULTRA accelerated architecture inspection, specification discussion, cross-file implementation and review, test execution, and the conversion of accepted decisions into public documentation. This was a modernization of a mature baseline, not a claim that the entire project was created during Build Week.

The explicit plugin route adds inspectable route ownership, workflow state, and executable validation gates that ULTRA mode does not define by itself. ULTRA and these plugins can coexist in one installation, and neither plugin detects, disables, or claims technical exclusivity with the host's selected intelligence level. To keep orchestration ownership predictable, choose one primary orchestration route for each task: either rely on ULTRA's proactive delegation, or explicitly select the plugin route so the selected contracts govern the work. In the paired plugin route, Agentic Runner owns upper cross-output control, Coding Agents owns the coding branch, and actual workers are dispatched through official Codex subagents.

Selecting Agentic Runner or Coding Agents does not change the host model or intelligence level, and selecting ULTRA does not by itself apply either plugin's workflow contract. The recommendation to choose one primary route is an ownership rule, not an enforced incompatibility. Agentic Runner and Coding Agents remain independently installable and usable, may optionally be paired within the explicit plugin route, and keep source repositories separate from disposable plugin cache. Using GPT-5.6 Sol ULTRA for the refactor described above is distinct from choosing the primary orchestration route for a later task.

The control-plane baseline predates the Build Week eligibility window, so we ask judges to evaluate the post-window extensions: Agentic Runner a432c84 added lazy Git discovery, cached root resolution, batched state appends, no-op rewrite avoidance, and a machine-checkable creator contract. Coding Agents a68c1b6 removed the CLI-spawned Codex worker route, and 678f9a9 centralized scaffold contracts and reduced workflow-state overhead.

The current source suites contain 82 passing tests for Agentic Runner and 61 passing tests for Coding Agents. npm run doctor:self validates each source-tree CLI; it is intentionally not presented as evidence that a separately installed live plugin cache was refreshed or activated.

Challenges

The first challenge was preserving the value of composition without turning the projects into a set-only product. Their responsibilities had to remain useful and testable on their own. The second was removing a custom child-process execution path while retaining auditable coding lifecycle records. The third was reducing filesystem and state overhead without weakening historical compatibility, route checks, or fail-closed behavior. Finally, we had to describe the Build Week work honestly by separating the pre-existing baseline from the eligible extensions.

What we learned

A useful agentic control plane is not simply 'more agents.' Its value comes from explicit ownership, sealed constraints, observable lifecycle, and evidence-backed convergence. We also learned that specification consultation is part of coding execution, not a disposable prelude: turning confirmed decisions into an instruction document gives implementation and verification the same source of truth. Keeping the two plugins independent makes those lessons reusable for both small coding tasks and larger multi-output workflows.

Built With

• codex
• git
• github
• gpt-5.6
• javascript
• node.js
• plugins