Three OpenAI Engineers Shipped A Million Lines. Your Ten-Hour Agent Run Starts Here.

Overview

This summary analyzes how to run long-running AI agent coding/planning sessions (6–10+ hours, across many model calls) without the agent’s instructions and prior context overwhelming the actual task.

The core claim is that success comes from “progressive context shaping”:

• Start with a clear brief.
• Repeatedly update a small set of “current state” instructions/decisions that the agent uses going forward.
• Keep older information in a separate history/log/map, so it doesn’t masquerade as what’s currently true.

---

Key technical / practical ideas & examples

Internal OpenAI million-line agent engineering

An internal product was shipped about 10× faster than manual effort:

• The codebase grew to >1 million lines
• Produced with ~1,500 polling requests
• Not a line typed by humans
• Individual coding runs lasted 6+ hours

A classic failure mode appeared:

• A giant instruction manual crowds out the live task, becoming a “graveyard of stale rules.”

Fix: Replace the large manual with a very short “map” pointing the agent to:

• Active execution plans
• Decision logs
• Design/architecture documents
• Quality grades for each part of the codebase

As the project evolves, these artifacts change—so the agent finds the best current information rather than relying on old instructions.

---

Anthropic Claude long-running harness uses “progress files”

For long-running scientific computing, Claude code uses a progress file as portable memory across sessions:

• Records current state
• Records completed work
• Records known limitations / failed approaches with reasons

New sessions read the progress and continue without repeating dead ends.

A similar pattern appears in their coding harness:

• progress file
• structured handoffs
• version history

---

Why larger context windows aren’t enough

The talk argues that context window size doesn’t solve “what should be true now.”

Even if more tokens are available:

• retrieval/compaction can pull irrelevant earlier details
• the agent may follow outdated guidance

The missing capability is the ability for human judgment to update the agent’s governing state during the run.

---

“Progressive context shaping” (main method)

Separate and prioritize four kinds of context:

1. Stable instruction (rarely changes)

   • How to work, where to find files, approval rules, standards
   • Example locations: claude.markdown, agents.markdown, “project rules”

2. Current project state (changes often)

   • What the goal means right now
   • Active decisions
   • What remains unresolved
   • When the agent should stop
   • Stored separately from approvals/guardrails

3. Map / resource index

   • What materials exist and where they live
   • Helps the agent quickly find the right docs, research, drafts
   • The speaker claims many users skip this and dump everything instead

4. History / change log / decision log (keep as history, not authority)

   • What happened, why decisions were made, how to recover versions
   • Important—but it must not override the current state

---

How to steer agents during execution

Instead of treating prompting like a one-time order, treat it like directing work:

• Provide an opening prompt with boundaries and the first move.
• When new evidence emerges, update the current state so subsequent work follows the revised direction.

The speaker emphasizes “useful forgetting”:

• Keep evidence in history/change logs,
• but ensure failed attempts don’t remain in the active plan.

---

ARISE example: stopping “to-do shuffling” failure

ARISE’s agent, “Alex”, summarized multiple traces and made 27 model calls, largely reorganizing its own to-do list without finishing.

Instead of adding more forceful prompt text, the team moved the current plan outside the conversation window and stored it on disk.

On each model call, the system rebuilds a short plan message from the latest state and places it ahead of noisy history, so the agent consistently sees:

• what’s done
• what’s in progress
• what’s next

This mirrors the speaker’s approach using a maintained current markdown state file.

---

Real project anecdote: switching from “generate more” to “finish with best evidence”

A large coding agent run:

• found many sources (e.g., 339 sources)
• generated many questions
• produced verified answers

Then a delegated agent began repeatedly continuing itself during package synchronization (an unbounded loop).

Fix:

• Stop the run
• Update saved state to checkpoint and prohibit resuming the unbounded loop
• Change the next run objective to:
  • select top-value answers
  • validate and stop

Result: the same evidence pool became valuable again because the agent was guided by updated current state.

---

Human / agent roles (Claude code research)

In ~400,000 Claude Code sessions:

• The prompter (human) made about 70% of planning decisions
• Claude made about 80% of execution decisions

This supports the idea that long projects require ongoing human decisions carried forward via “current state” between check-ins.

---

Scaling to multi-agent work

Context switching limits were observed:

• OpenAI engineers could comfortably handle only 3–5 sessions at once.

Solution example: OpenAI Symphony

• Work moved into a project board
• Agents pull tickets
• Tickets act as carriers of:
  • deliverable
  • status
  • latest direction
• Team reported increases like +500% pull requests in the first 3 weeks

The speaker suggests you can adopt the same principle without Symphony:

• use a single project whose state is continuously updated
• use checkpoints / early deliverables

---

Recommended “starter kit” files (tool-agnostic)

The speaker claims you can implement the method in any environment (Claude, Code/ex, or standard chat) using ordinary files—not proprietary features:

• readme.markdown: explains the method to the agent
• current.mmarkdown: holds the mutable current state
• contextmap.mmarkdown: indexes what exists and where it lives (helps the agent fill it out)
• decisions.mmarkdown: stores what was decided and why over time

Plus:

• an “initializer / current-state checkpoint” concept to review and correct mid-run.

---

Main speakers / sources

• Speaker: the video narrator (author) describing OpenAI/Anthropic engineering practices and providing personal anecdotes.

• Primary sources referenced:

  • OpenAI
    • million-line internal project
    • mentions “Symphony” and codec session handling
  • Anthropic
    • Claude long-running harness
    • progress files
    • ~400,000 Claude Code sessions research
  • ARISE
    • agent “Alex” example
    • plan-on-disk approach