When agent work needs loops, subagents and a shared log

Raj from OpenAI’s Applied AI engineering team says agent design changes as models improve. He and developer experience engineer Eric trace the move from single loops to longer-running and multi-agent work.

Raj remembers asking early ChatGPT to write FizzBuzz, then copying the code into an editor and running it himself. The next shift was allowing a model to act on its reasoning through tools.

In an image-analysis example, a model could zoom in, inspect details and decide what to do next. Raj calls the sequence of action, feedback and planning an agentic loop.

Codex extends this idea with computer access. Its model and surrounding harness are designed together: the harness supplies tools and feedback, while training helps the model work with them.

The harness manages instructions, tools, execution and context. Raj says Codex favors a small set of general-purpose tools such as a shell, filesystem and computer use, so the model can work out how to approach a task.

The Responses API carries context and tool definitions to the model; the harness executes requested tools in a sandbox and adds results to the conversation. Harness design and model training influence one another.

Long tasks fill the context window with instructions, files, tool calls and results. Compaction condenses the history so the agent can continue while retaining useful information.

Raj says Codex trains the model to understand compaction and resume from a compacted state. This allows work to continue across multiple context windows and compaction events.

Earlier models could make progress but stop before completing a task, so users repeatedly sent continue messages. Outer loops and Ralph-style loops automated repeated attempts, with files carrying state between runs.

Codex later added goals stored outside the conversation context. The harness tracks the objective and can continue after a turn ends, while stopping for a real blocker.

Raj says later training built more persistence into the model itself: it could identify useful steps and check its work without repeated continue prompts. Better coordination then made parallel work possible.

Eric recommends starting most work with one agent, a clear task and a way to check the result. Add agents only when the task supplies a reason, because extra agents consume tokens without necessarily improving speed or quality.

Independent reviews or parallel investigations can justify delegation. Each subagent gets its own working context, but complex agent structures can also create coordination work without adding value.

Eric describes effort scaling: a primary model can ask a stronger model for help on a difficult failure and delegate simpler support work to smaller agents. He cautions that this does not guarantee lower cost.

For an old game port, he paired one agent capturing the running original with another unpacking and visualizing its scene in Blender. They needed to exchange findings because the output format affected the capture approach.

He distinguishes user-visible chats from subagents: a coordinating chat can manage other chats, each of which may use its own subagents. Users can open and steer individual chats.

For a long game project, separate chats could own art, programming and testing. Eric warns that elaborate approval hierarchies can slow agents down and create what he calls a middle-management tax.

Frequent user steering can cause the original objective to drift after several compactions. Eric recommends a compact work log recording the goal, current work, ownership and decisions, rather than a diary of every failed test.

He cautions that best practices have a shelf life. Raj then discusses the challenges of coordinating agents at far larger scale.

Raj says an OpenAI mathematics effort used 10,000 agents, 2.7 million messages and about 130 billion output tokens. He describes teams pursuing different approaches to a shared objective and communicating findings across team boundaries.

Teams explored hypotheses, challenged assumptions and ran experiments. New teams were created or redirected as the work exposed promising questions, while the overall objective stayed fixed.

Raj reports that an internal model contributed to mathematical results and says more powerful models may allow more ambitious work. He encourages developers to revisit problems earlier models could not complete.