What Will You Build With Coding Agents That Don’t Quit? | DevDay 2026

OpenAI's Codex/Astra agents, combined with features like threads, compaction, remote environments, plugins, child threads/worktrees, ultra mode, and schedule

By Sean Weldon

Long-Horizon Agentic Delegation: From Prescriptive Plans to Goal-Based Autonomy

Abstract

This synthesis examines a transition in agentic software engineering from prescriptive, plan-driven orchestration to goal-based delegation, in which an operator supplies only an objective, a desired outcome, and governing trade-offs, leaving step selection entirely to the model. Evidence is drawn from OpenAI's Codex agent operating on the Astra and Sol model families, including a continuous-integration (CI) repair agent that ran unsupervised for six weeks, accumulating over 1,000 hours of runtime, nearly 500,000 tool calls, and more than 5,800 sub-agent sessions. The analysis identifies the mechanisms enabling multi-day to multi-month autonomy - context compaction, persistent work logs, remote execution substrates, and hierarchical sub-agent delegation - and quantifies operating economics, which halved from approximately $32/hour to $16/hour across a single model generation. Practical adoption criteria for engineering organizations are derived from these observations.

1. Introduction

Long-horizon autonomy has been the principal unresolved constraint on agentic software engineering. An agent capable of completing a thirty-minute task functions as a productivity tool; an agent capable of sustaining coherent, goal-directed behavior across six weeks begins to function as an organizational unit. This distinction is not primarily a matter of raw model capability but of context durability (the ability to retain intent across hundreds of thousands of discrete steps), delegation topology (how work is distributed to subordinate processes), and execution substrate (whether the agent's runtime survives interruptions to its host environment).

This analysis addresses a central question: what architectural and procedural changes convert an agent from an executor of human-specified plans into a delegate pursuing human-specified outcomes? Goal-based delegation is defined here as an operating mode in which the operator specifies a goal, a success criterion, and acceptable trade-offs, without prescribing implementation steps, code samples, or an interrogable plan. This is contrasted with the prior-year methodology, exec plans, under which the operator authored detailed, prescriptive prompts and the agent produced a plan subject to human review before execution.

The evidence base comprises three documented deployments - two creative rendering tasks and one long-running infrastructure-maintenance agent - together with six platform features (/goal, AGENTS.md, compaction, remote environments, plugins, and child threads/worktrees) and two additional mechanisms (ultra mode and scheduled heartbeats) that collectively enable sustained autonomous operation. Section 2 establishes the prior methodology against which these results are contrasted. Section 3 analyzes the deployments in detail. Section 4 presents the enabling technical substrate. Sections 5 and 6 discuss implications and derive adoption criteria.

2. Background and Related Work

Under the exec-plan methodology, operators front-loaded cognitive effort into specification: prompts contained explicit libraries, code samples, and step sequences, and the agent's output - a plan - was reviewed and amended before execution began. This approach encodes an implicit assumption that the model's step-selection capability is the weakest link in the system, such that human-authored decomposition should substitute for autonomous planning. Under this regime, seven continuous hours of unsupervised operation was considered a significant milestone.

The deployments examined in this synthesis indicate that this assumption no longer holds for the Astra and Sol model generations. The operator's role shifts from author of a procedure to author of a specification - supplying the goal, the definition of "done," and the trade-offs bounding acceptable solutions, while the model determines the steps. This reframing is consistent with a broader industry trajectory in which agent orchestration moves from micromanagement toward delegation analogous to management of human teams, a parallel made explicit in the source material's framing of the operator's role shifting from "manager of agents" to "director of agents."

3. Core Analysis

3.1 Creative Long-Horizon Demonstrations

Two rendering tasks illustrate the expanded scope of unsupervised execution. In the first, Codex with Astra constructed a 3D model of a Ferrari and an explorable website from seven reference photographs, additionally generating clay and wireframe renditions that had not been explicitly requested - evidence of the model exercising discretion beyond the literal specification. In the second, the agent produced a fly-through video of the 21 km Nürburgring Nordschleife circuit, approximately three times the length of an average Formula 1 track and encompassing all 70 turns, using only the track's name as a prompt.

The Nürburgring task is the more instructive of the two. Execution spanned slightly over two days, with the majority of elapsed time consumed by Blender rendering rather than model reasoning, indicating that compute-bound rendering latency, not agent decision-making, was the binding constraint. Codex employed sub-agents to research the track's geometry, verify correctness, and plan the render - a delegation pattern recurring throughout the analyzed deployments. The render was interrupted multiple times by RAM exhaustion and CPU overheating; in each case, Codex resumed automatically from saved frames, demonstrating resilience to infrastructure failure without human intervention.

3.2 The Six-Week CI-Repair Agent

The most extensive deployment analyzed is an agent tasked with monitoring OpenAI's continuous-integration pipeline, diagnosing flaky test failures, and proposing or landing fixes. The agent was initialized from a 200-word prompt containing no prescribed implementation details and ran continuously for six weeks, terminating only because colleagues began deploying similar agents of their own.

A structural shift occurred approximately four days into the deployment: the operator instructed the agent to delegate slow investigative work to sub-agents rather than performing all work within a single thread. This change is characterized in the source material as a "paradigm shift" in productivity. Thereafter, the main thread was responsible for triggering tests, collecting failure information, and coordinating sub-agents and human communication, while sub-agents performed the slower work of retrieving code, implementing fixes, and iterating. This bifurcation - a fast coordination layer and slow execution layer - parallels conventional distributed-systems design, in which a lightweight scheduler dispatches work to resource-intensive workers.

Over six weeks, the agent opened more than 100 pull requests per week, pushed over 1,000 commits, sent over 600 Slack messages to coordinate with human engineers, and merged 213 of its own fixes. When the agent detected that a colleague had already produced an equivalent fix, it deferred to the existing work rather than duplicating effort, indicating a degree of situational awareness about concurrent human activity. A retrospective generated by the agent itself noted that its most productive period was a five-day stretch during which the operator sent no messages, suggesting that human interjection did not uniformly improve throughput and may in some cases have introduced friction.

Quantitatively, the agent made just under 500,000 tool calls and used over 5,800 sub-agent sessions across more than 1,000 hours of runtime. Of these tool calls, over 67,000 were spent idly waiting for external processes, such as test runs, to complete - indicating that a substantial fraction of nominal "agent activity" is latency absorption rather than reasoning, and that wait-state handling is itself an architectural concern for long-horizon systems.

3.3 The Heisenbug Case Study

A specific incident illustrates the agent's capacity for sustained, multi-week diagnostic reasoning. The agent encountered a non-deterministic floating-point error in a GPU test - a so-called "Heisenbug" - and resolved it by reproducing the failure, correlating logs across weeks, isolating the fault to a specific compute node, and teaching itself to repeatedly execute the test on that node until intermittent reproduction was achieved. The agent proactively contacted the researchers owning the affected GPU system to determine whether the fault originated in software or hardware. When uncertain whether deleting a failing test constituted the correct remediation, the agent spawned a separate agent to review and interrogate its own proposed solution prior to requesting human review - an instance of automated adversarial self-checking preceding human-in-the-loop escalation.

4. Technical Insights

Six platform features are identified as jointly necessary for sustaining long-horizon autonomy. First, a one-thread-per-outcome model, invoked via a /goal command, directs persistent pursuit of a single objective. Second, AGENTS.md files contextualize long tasks by defining test locations, behavioral constraints, and a running work log, enabling resumption after interruption without loss of state. Third, compaction - a built-in, unconfigured mechanism for context management - mitigates context rot across threads spanning months; it is characterized in the source material as reducing the long-horizon problem to a solved instance of the context-management problem. Fourth, remote execution environments (SSH-connected virtual machines, or the newer Codex Cloud) decouple agent runtime from the operator's local machine, with Codex Cloud periodically refreshing checked-out code and dependencies. Fifth, plugins integrating with systems such as GitHub and Linear provide the agent with issue, discussion, and pull-request context, avoiding uninformed operation. Sixth, child threads paired with Git worktrees allow large jobs to be partitioned into parallel sub-projects without merge conflicts, since each child thread operates on an isolated checkout; a /side command forks context for tangential questions without disrupting the main thread.

Two additional mechanisms address distinct failure modes. Ultra mode allocates extended reasoning time and spins up sub-agents for a single, non-parallelizable hard problem - exemplified by the GPU floating-point bug - as distinguished from "embarrassingly parallel" work suited to child threads. Scheduled heartbeats permit periodic resumption within an existing thread (e.g., checking every 30 minutes for review feedback) with full retention of prior context, and scheduled tasks can additionally initiate fresh, recurring work such as weekly or overnight status summaries.

A practical trade-off is cost per unit of autonomy. Running the CI-repair agent cost approximately $32/hour on GPT-5.6 Sol; this fell to $16/hour under GPT-6 Sol, attributed to a token budget extending roughly twice as far, with GPT-6.1 Sol offering further efficiency gains approaching parity with Astra.

5. Discussion

The CI-repair deployment suggests that the primary bottleneck in long-horizon agentic work is no longer model reasoning capability per se, but the surrounding infrastructure for context retention, delegation, and resumption. The observation that 67,000 of roughly 500,000 tool calls were spent in idle waiting indicates that architectures optimized purely for reasoning throughput may understate the engineering effort required for robust handling of asynchronous, latency-bound operations - a consideration relevant to any system orchestrating long-running external processes rather than purely computational ones.

The finding that the agent's most productive period coincided with an absence of human messaging raises an open question about the optimal cadence of human oversight in goal-based delegation. This does not establish that supervision is counterproductive in general, but it suggests that interruption cost may be non-trivial for agents maintaining complex, multi-week state, and warrants further empirical investigation across other long-horizon deployments.

The roughly 50% cost reduction across a single model generation, combined with increasing token efficiency, indicates that the economics of continuous agentic operation are improving independently of task-specific engineering, which has implications for the pace at which organizations can expand the scope of delegated work.

6. Conclusion

This synthesis documents a shift from prescriptive, human-authored execution plans toward goal-based delegation, enabled by a specific set of platform mechanisms: context compaction, persistent work logs, remote execution substrates, plugin-mediated context access, hierarchical sub-agent delegation via child threads and worktrees, and scheduled heartbeat resumption. The six-week CI-repair deployment demonstrates that these mechanisms, in combination, support autonomous operation at a scale - nearly 500,000 tool calls, 1,000+ hours, 213 merged fixes - that was not achievable under the prior exec-plan methodology, where seven hours of unsupervised operation was notable.

Practically, organizations considering adoption are advised to identify tasks that consume time without contributing to higher-value work (e.g., backlog grooming, speculative pull requests, log monitoring, CI maintenance), provide the agent a mechanism for verifying its own output (end-to-end tests), define explicit completion criteria, and establish escalation and resource-consumption limits before delegating open-ended, long-horizon work.


Sources


About the Author

Sean Weldon is an AI engineer and systems architect specializing in autonomous systems, agentic workflows, and applied machine learning. He builds production AI systems that automate complex business operations.

LinkedIn | Website | GitHub

Sean Weldon builds apps and custom software at 22Atlas.

Start your build

More about Sean