Inside OpenAI’s Codex Agent Loop How AI Is Learning to Build Software

Penned by Michael Bolin, OpenAI’s technical staff wizard with deep roots in developer tools (he built Kythe at Google), this January 22, 2026, post launches a series dissecting the agent’s guts. If you’re knee deep in AI agent development, software engineering automation, or just geeking out on large language model orchestration, buckle up. We’ll unpack the agent loop step by step, dive into performance hacks like prompt caching and context compaction, compare architectures, and show why Codex CLI’s open source foundation makes it a must try for every developer stack.

Launched April 2025 alongside o3 and o4 mini models, Codex CLI targets ChatGPT Plus, Pro, Business, Edu, and Enterprise users. Install via npm or Homebrew, and it integrates natively with your workflow. Fully Rust powered for terminal speed, it supports local models via Ollama or LM Studio too. Bolin stresses: The agent’s true output is your modified codebase, not chat fluff.

Core Architecture: The Heartbeat of AI Coding Agents

At its essence, the Codex agent loop is a state machine for AI driven software tasks. Bolin illustrates it with crystal clear diagrams: User prompt → Prompt assembly → Responses API call → Handle output (tool call or final message) → Loop or respond.

Unlike chatty copilots, Codex focuses on action. It uses OpenAI’s Responses API a streaming endpoint for structured tool calls over raw Chat Completions. Why? Tool parallelism, native caching, and ZDR compliance (stateless, no history storage).

Key loop phases:

• Input Processing: Your message joins conversation history. Codex injects system prompts first (config.toml or model md files), then developer instructions, aggregated AGENTS.md directives (global/repo/folder scoped, max 32KiB), env details (pwd, shell), and tools manifest.

• Inference: POST to /v1/responses (chatgpt.com or custom). Model samples tokens, streams SSE: text for display, json tool_calls for execution.

• Tool Handling: Sandboxed shell (e.g., ls, vim, git), MCP servers for custom tools. Output appends as tool message; re prompt with prefix match for caching.

• Termination: Assistant message sans tools ends turn. History persists for next.

This enables complex flows: “Implement user auth” → Inspect deps → Edit files → npm test → Fix fails → Commit.

Performance Mastery: Caching and Context Optimization

Without optimization, agent loops explode: N turns = O(N²) tokens. Codex flips this with prompt caching. Static prefixes (system instr, tools) cache perfectly; dynamic history prefixes match prior prompts. Cache hit? Reuse computation, linear scaling.

Bolin shares metrics: High hit rates from tool order consistency, no mid loop model swaps. ZDR? Stateless calls, encrypted compaction items.

Enter context compaction: Hit auto_compact_limit? Call /responses/compact. It summarizes history into a compact message + encrypted reasoning blob (type=compaction). Model “remembers” via this artifact. Evolved from CLI /compact command.

Git smarts add flair: status/diff/history in context; full repo preload for monorepos.

Codex CLI’s crown jewel? Open source (github.com/openai/codex). Rust core, active PRs/issues detail every decision. Bolin links src like AgentLoop::run(). 128k+ workflows prove vitality.

Extensibility rocks:

• MCP Servers: Remote tools (e.g., databases, APIs).

• Sandbox: Containerized, no net, configurable perms via md templates.

• Integrations: Datadog for metrics during tasks; Skyscanner JetBrains MCP.

Forks like open codex run local models. Community raves on Reddit/X: “Game changer for async coding.”

Real World Deployments and Developer Wins