Building Codex with Tibo Sottiaux

Codex’s Origin Story & Internal Agent Bot

• Tibo’s account: An internal “chat-like” Google bot—similar to ChatGPT—was built about a year earlier than ChatGPT’s public emergence.
• DeepMind-era roots: The work came out of exploration of large language models for “general intelligence.”
• Internal evolution: What began as research tooling grew into a widely shared conversational interface within the organization.

Codex Onboarding: “Have You Asked Codex?”

• New team members are encouraged with the prompt: “Have you asked Codex?”
• Codex is integrated into internal workflows and resources, such as:
  • Slack
  • Documents
  • Codebase access
• This enables Codex to answer broad engineering/product questions.
• Engineers use it to:
  • Understand project state and historical decisions
  • Contribute faster by reducing the “where is the answer?” friction

Rust as the Core Agent Implementation

Codex was implemented with a Rust-based core, even though Rust model tooling wasn’t as mature at the time.

Why Rust?

• Correctness, security, and efficiency at scale
• Compile-time / static verification
• Separation of concerns:
  • Keep the agent core distinct from the product layer
  • Avoid entangling code in ways that would slow future innovation

Tibo frames Rust as long-term scaffolding intended to reduce painful future rewrites.

Maintenance Philosophy: “Build Was Fun, Maintenance Is the Tax”

Maintenance is inevitable, but Codex aims to make it progressively automated.

• Automate dependency upgrades and repetitive update tasks with “reasoned-about” execution
• Reduce human overhead via automation such as:
  • Automated regression catching
  • Code review steps
  • Deployment-related checks
• Larger rearchitecting efforts can become cheaper if the system can rework big codebases faster than humans alone.

Code Review is Shifting

Codex uses code review models that go beyond syntax-level checks.

What the models can do

• Detect subtle logical/reasoning errors that require deep understanding of:
  • Dependencies
  • Documentation
• Perform security reasoning
  • Tibo notes security findings can be used to block merges automatically

What humans focus on

• Moving away from line-by-line correctness
• Toward discussing intent and design
• Once invariants/“the box” are agreed, automation validates changes inside those boundaries.

Open Source by Default

Codex’s CLI, SDK, and app server are described as open source.

Reasons

• Coding agents benefit from community contribution and shared improvement
• Open sourcing changes the role of code (more transparency, shared evolution)
• Faster onboarding via visible repo history, PRs, and accessible workflows

Downsides acknowledged

• More coordination due to repo boundaries
• Competitors can copy work before release
• Risk of a “tsunami” of low-quality contributions, increasing triage costs

Model-Agnostic / Permissive Integration

Codex’s harness is not tightly coupled to OpenAI models.

• It can support other model providers
• Motivation:
  • Avoid locking the harness to a single model
  • Preserve optionality as model ecosystems evolve
  • Build a reusable, excellent agent tool for the community

Execution Model: Local Sandbox vs Cloud

Default: local execution

• Codex executes by default on the user’s local machine in a sandboxed environment.

Optional: cloud execution

• A cloud execution mode uses a managed VM with containerized/sandboxed environments (e.g., kata-container mentioned).
• Cloud is positioned as the “next step” when tasks need more compute/resources than local machines.

Remote workflow support

• Codex also supports “remote” workflows by splitting:
  • Execution vs orchestration

How Codex Improves Over Time: Harness vs Model

Tibo’s framing: the harness is often ahead of the model.

• The harness provides crutches / guard rails, including:
  • Safety mechanisms
  • Efficiency constraints
  • Steerability through instructions injected each turn (developer message)
• As models improve, fewer crutches are needed.
  • Example: behaviors like “run unit tests” can become automatic rather than repeatedly reminded.

Long-Running Goals: “/go”

• A /go command is mentioned as enabling Codex to run for days/weeks on hard tasks.
• This is especially useful when the harness needs explicit guidance.
• Newer models may reduce reliance on such goal crutches.

“Merge” into ChatGPT (Cloud Unification Project)

Codex was merged into ChatGPT, requiring infrastructure changes because:

• Codex is fully local
• ChatGPT is managed cloud-based

What had to be built

• A cloud version that preserves Codex capabilities efficiently at scale
• Infrastructure/product engineering work including:
  • Unified plugin/architecture differences
  • Ensuring users can do in ChatGPT what they could do in Codex (and vice versa)
  • Codex acting like a “journalist,” capturing internal debates through shared channels/documents during development

Cloud execution capability

• The merged system includes powerful cloud execution (e.g., “CAS work” referenced),
• enabling tasks like installing/using tools, with illustrative examples such as 3D modeling.

Sponsor-Adjacent Technical Projects Mentioned

• Turbopuffer: a hybrid search engine on object storage

  • Namespaces-based architecture
  • Hot caching only for active namespaces
  • Focused on reliability/scale for connecting AI to very large unstructured datasets

• Entire: git hosting for an agentic era

  • Regional mirroring + high push throughput
  • Remains usable when GitHub is down
  • Also captures agent prompt history in repos

• Anticys: hostile deterministic simulation / testing

  • Automated targeted + fuzz testing in a deterministic environment
  • Produces reproducible bug cases
  • Positioned as beyond code review for verifying agent-written code

Explicit Takeaways (Review / Guide / Tutorial Emphasis)

• Codex as the workflow hub:
  • Onboarding and day-to-day engineering Q&A: “ask Codex first.”
• Code review automation:
  • Correctness and security checks increasingly handled by AI
  • Humans focus on intent/design, not minutiae
• Practical execution controls:
  • Default: local sandbox
  • Optional: cloud execution for scale
• Open source operational model:
  • Benefits: onboarding, transparency, community improvements
  • Downsides: copying risk, contribution noise, triage burden

Main Speakers / Sources

• Speaker: Tibo Sottiaux (OpenAI / Codex team lead)
• Host/Interviewer: Pragmatic Engineer podcast host (unnamed in subtitles)
• Referenced internal/open-source projects/tools:
  • Codex (CLI/SDK/app server)
  • AS3 / autonomous software engineer effort (pre-Codex)
  • ChatGPT merge (“work mode” referenced)
• Sponsors mentioned in audio:
  • Turbopuffer
  • Entire
  • Anticys