# Why OpenAI Codex builds the agent first, not the product | LinearB Blog

> OpenAI’s Thibault Sottiaux reveals how the Codex team ruthlessly simplifies agent design by removing manual scaffolding, solving context compaction at the model level, and leveraging vertical integration to turn frontier research into the world’s most capable autonomous coding agent.

_This is a markdown rendering of a live HTML page on linearb.io, generated for AI/LLM consumption — it is not a markdown-only site. To get the full HTML page instead, request this URL with an explicit `Accept: text/html` header (no wildcard, no markdown preference)._


```json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://linearb.io/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog",
      "item": "https://linearb.io/blog"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Why OpenAI Codex builds the agent first, not the product",
      "item": "https://linearb.io/blog/openai-codex-thibault-sottiaux-agentic-autonomy"
    }
  ]
}
```

[Home](https://linearb.io/)

/

[Blog](https://linearb.io/blog)

/

Why OpenAI Codex builds the agent first, not the product

# Why OpenAI Codex builds the agent first, not the product

![Photo of Andrew Zigler](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Headshot3_d7231cbda7?_a=BAVMn6ID0)

By [Andrew Zigler](https://linearb.io/blog/openai-codex-thibault-sottiaux-agentic-autonomy#andrew-zigler)

|

February 8, 2026

![Blog_Redefining_agentic_autonomy_2400x1256_98ff8e15fc](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Redefining_agentic_autonomy_2400x1256_98ff8e15fc?_a=BAVMn6ID0)

When [Thibault Sottiaux](https://linearb.io/dev-interrupted/podcast/openai-codex-thibault-sottiaux-agentic-autonomy) and the Codex team at OpenAI set out to build a coding agent, they flipped the traditional product development script. Instead of starting with a roadmap or a specific use case, they started with a radical question: what happens if we build a capable agent first, and _then_ figure out where to put it to work?

That shift in mindset, prioritizing agent capability over product endpoints, has shaped everything about how Codex approaches autonomy. Sottiaux, who works at the intersection of research and engineering, is helping to solve one of the hardest problems in tech: [creating agents that act independently](https://linearb.io/blog/how-agentic-ai-will-disrupt-your-software-delivery-lifecycle), perform economically valuable work, and scale predictably as models improve.

For engineering leaders navigating the rapid evolution of AI-assisted development, the lessons from Codex offer a blueprint for building systems that remain simple, scalable, and adaptable, even as the underlying models shift beneath their feet.

## Unlocking true autonomy at scale

The core objective for the Codex team extends far beyond simple code generation; they are focused on building agents capable of true, generalized autonomy. As Sottiaux explains, this means looking at the entire developer workflow, not just the IDE.

"It's not just about code generation, it's about solving many other parts of the day-to-day that are actually the bottlenecks. Building that general agent is what we're after."

This framing shifts the focus from narrow use cases to broad applicability. The agent is not designed to solve one specific problem; it is designed to identify and tackle economically valuable work across diverse contexts. That means addressing bottlenecks beyond writing syntax, such as reviewing pull requests, analyzing logs, running performance tests, and even interviewing users to gather requirements.

This "agent-first" mindset drives a different kind of product thinking. Sottiaux notes that when you shift your mindset to building an agent first, you discover a remarkable number of places where it can perform economically valuable work—opportunities that are often invisible when you start with a narrow product definition.

This approach demands simplicity. The "harness," or the software scaffolding that supports the agent, must be lightweight enough to adapt as model capabilities grow. Sottiaux describes the harness as temporary infrastructure meant to be removed over time. The goal is to minimize artificial constraints that could create "capability overhang," where the harness limits the model's true potential.

## Accelerating innovation through open source

Building the agent before the product requires discipline. It means resisting the urge to optimize for a single use case and instead focusing on flexibility. Sottiaux emphasizes that focusing on the agent first opens the door for "great ideas that you don't necessarily have ahead of time."

Open-sourcing the agent framework was a strategic decision to demystify these systems. The team wanted to demonstrate that building effective agents does not require mysticism or complex scaffolding; it requires well-chosen primitives and simplicity. The open-source repo serves as both a reference implementation and a platform for experimentation.

The community response has been remarkable, with over a thousand forks emerging for tasks ranging from spreadsheet editing to browser automation. However, maintaining an open-source project while preserving a clear vision requires balance. The team’s migration to Rust was a deliberate choice to [prioritize scalability and reliability](https://linearb.io/blog/ai-demo-is-a-lie), reinforcing their commitment to building for millions of concurrent agents.

Interestingly, developers newer to the field often adapt more readily to this paradigm. Without legacy practices to unlearn, they embrace new workflows and innovate within the system. Sottiaux highlights one new grad on the team, Ahmed, who has become a trusted contributor by bringing fresh ideas that challenge established norms.

## Scalable primitives and the risk of 'capability overhang'

The search for scalable primitives is both a research problem and an engineering challenge. Primitives must be simple, proven, and capable of scaling with model improvements. Complexity introduces fragility and bias, limiting the agent's ability to express new capabilities as models advance.

"Once you discover those primitives, they often seem delightfully simple. But the search for those primitives is a complex matter and you might not find those primitives immediately."

The concept of "capability overhang" is central to this philosophy. If the harness introduces constraints that prevent the model from expressing its full potential, then improvements in model capability won't translate to improvements in agent performance. The team mitigates this risk by aligning primitives with scaling laws and minimizing artificial constraints.

Primitives evolve through continuous refinement. For example, long-running sessions previously required heuristic-based compaction to summarize work and reset context windows. This approach was fragile and introduced bias. By training the model to handle compaction end-to-end, the team eliminated the complexity. Now, the agent can work across 20 context windows without losing track of prior work, a solution solved by the model rather than the harness.

## The strategic advantage of vertical integration

Vertical integration gives the Codex team unique leverage. Because they control both the model and the harness, they can choose exactly where to solve a problem. Sottiaux notes that they don't have to fix everything in the harness; they can often decide to fix issues downstream by training new models.

This flexibility [enables rapid iteration](https://linearb.io/blog/ai-driven-software-development-shift-speed-to-velocity). When the team identified issues with long context windows, they didn't just build more complex harness logic; they trained the model to handle the problem natively. That approach improved end-to-end system performance and removed obsolete scaffolding.

However, vertical integration comes with trade-offs. Building a tightly coupled agent optimized for a specific model series delivers maximum performance, but it sacrifices portability. For teams working with multiple foundation models, finding common ground often means accepting performance penalties. Sottiaux advises that while primitives should remain roughly similar across models, some degree of adaptation is always necessary to unlock the best results.

## Preserving the joy of programming

Building agentic autonomy is not just a technical challenge; it is a mindset shift. The Codex team's journey from complexity to simplicity, from product-first to agent-first, offers a roadmap for engineering leaders navigating the AI-assisted landscape.

The key takeaways are deceptively simple: build the agent first, discover scalable primitives, minimize scaffolding, and let the model do the work. But as Sottiaux reminds us, the search for those primitives is complex. The reward is a system that scales with model improvements and adapts to new use cases.

For developers, the advice is straightforward: make the agent your own. Build skills, automate the parts of your workflow you don't want to do, and [preserve the parts that bring you joy](https://linearb.io/blog/how-to-improve-and-measure-developer-experience). As Sottiaux puts it, it's like training a Pokémon: every week you teach it something new, and it gets a little better every time.

To dive deeper into the future of AI-accelerated development, listen to Thibault Sottiaux discuss these ideas in depth on the Dev Interrupted podcast.

## Improve developer productivity with LinearB

Find us on

[](https://www.linkedin.com/company/linearb)
[](https://devinterrupted.substack.com/)

![Headshot3_d7231cbda7](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Headshot3_d7231cbda7?_a=BAVMn6ID0)

## Andrew Zigler

Andrew Zigler is a GTM Engineer at LinearB and the host of Dev Interrupted, a twice-weekly podcast and newsletter where 40k+ builders decode the transition to AI-native development and agentic orchestration. A classicist by training with a degree from The University of Texas at Austin, Andrew spent his early career teaching in Japan before channeling his interdisciplinary instincts into the tech world. His polymath background informs everything he builds, from automated workflows to the stories he tells about the seismic shifts reshaping software creation.

### Connect with

[](https://www.linkedin.com/in/andrewzigler)
[](https://substack.com/@zigler)
[](https://x.com/andrewzigler)

## Your next read

[![Cover image for Your software factory needs a context layer](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/unnamed_4_b35455ae7a?_a=BAVMn6ID0)](https://linearb.io/blog/software-factory-2026-ai-benchmarks-code-review-roi)

AI

[Your software factory needs a context layer](https://linearb.io/blog/software-factory-2026-ai-benchmarks-code-review-roi)

Data from 2.7 million pull requests across 253 engineering organizations shows a widening gap between developers using AI deeply and everyone else. An adoption...

[![Cover image for You can now measure AI ROI with LinearB](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_1_dd1f47bae7?_a=BAVMn6ID0)](https://linearb.io/blog/ai-roi-dashboard)

AI

[You can now measure AI ROI with LinearB](https://linearb.io/blog/ai-roi-dashboard)

Today, we're launching the AI ROI dashboard in LinearB, live now for every customer with metrics builder enabled.

[![Cover image for AI agents are killing the pull request and reinventing CI/CD](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_5_496cdfde2d?_a=BAVMn6ID0)](https://linearb.io/blog/circleci-rob-zuber-ai-agents-pull-request-cicd-sdlc)

AI

[AI agents are killing the pull request and reinventing CI/CD](https://linearb.io/blog/circleci-rob-zuber-ai-agents-pull-request-cicd-sdlc)

CircleCI CTO Rob Zuber explains why AI adoption is killing the pull request and forcing engineering teams to completely reimagine the software development...

## Structured data

_Machine-readable metadata (JSON-LD) embedded in the page for search/AI context — not content rendered on the page itself._

```json
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "LinearB",
  "url": "https://linearb.io/",
  "logo": "https://assets.linearb.io/image/upload/v1715628027/logo-mark-lg.svg",
  "description": "LinearB is the engineering productivity platform that helps engineering leaders prove AI is improving throughput without sacrificing delivery confidence, flow efficiency, or developer experience.",
  "sameAs": [
    "https://www.linkedin.com/company/linearb"
  ],
  "award": [
    {
      "@type": "Award",
      "name": "LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms",
      "dateAwarded": "2026",
      "awardedBy": {
        "@type": "Organization",
        "name": "Gartner®"
      }
    },
    {
      "@type": "Award",
      "name": "Great Place to Work Certification",
      "dateAwarded": "2025-2027",
      "awardedBy": {
        "@type": "Organization",
        "name": "Great Place to Work"
      }
    },
    {
      "@type": "Award",
      "name": "America's Best Startup Employers 2025",
      "dateAwarded": "2025",
      "awardedBy": {
        "@type": "Organization",
        "name": "Forbes Magazine"
      }
    }
  ],
  "hasCertification": [
    {
      "@type": "Certification",
      "name": "SOC 1 Type 2"
    },
    {
      "@type": "Certification",
      "name": "SOC 2 Type 2"
    },
    {
      "@type": "Certification",
      "name": "GDPR Compliance certification"
    },
    {
      "@type": "Certification",
      "name": "ISO 27001"
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Why OpenAI Codex builds the agent first, not the product",
  "url": "https://linearb.io/blog/openai-codex-thibault-sottiaux-agentic-autonomy",
  "author": {
    "@type": "Person",
    "name": "Andrew Zigler"
  },
  "datePublished": "2026-02-08T08:00:00.000Z",
  "dateModified": "2026-02-08T08:00:00.000Z",
  "image": "https://assets.linearb.io/image/upload/v1770588578/Blog_Redefining_agentic_autonomy_2400x1256_98ff8e15fc.png",
  "publisher": {
    "@type": "Organization",
    "name": "LinearB",
    "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png"
  },
  "description": "OpenAI’s Thibault Sottiaux reveals how the Codex team ruthlessly simplifies agent design by removing manual scaffolding, solving context compaction at the model level, and leveraging vertical integration to turn frontier research into the world’s most capable autonomous coding agent."
}
```

## More on linearb.io

### Top navigation

- [Book a Demo](https://linearb.io/book-a-demo)
- [AI Code Reviews — Catch security risks, bugs, and spec mismatches](https://linearb.io/platform/ai-code-reviews)
- [AI & Productivity Insights — See how AI tools affect cycle time and delivery speed](https://linearb.io/platform/ai-developer-productivity-insights)
- [Measure AI Impact — Track AI adoption and tie it to delivery outcomes](https://linearb.io/use-case/measure-ai-impact)
- [MCP Server — Chat with your data to spot patterns and boost output](https://linearb.io/platform/mcp-server)
- [Resource Allocation — Cost initiatives and shape your investment strategy](https://linearb.io/platform/resource-allocation)
- [Cost Capitalization — Capitalize engineering costs with audit-ready reports](https://linearb.io/platform/cost-capitalization)
- [Dev Team Management — Set targets and tie throughput to business outcomes](https://linearb.io/platform/goals-and-reporting)
- [DevOps Workflow Automation — Policy-based PR routing, approvals, and tests](https://linearb.io/platform/ai-workflow-governance)
- [AI Powered Support — Unify AI and human code delivery in one clear view](https://linearb.io/use-case/ai-powered-support)
- [Optimization — Surface friction with feedback and MCP insights](https://linearb.io/platform/developer-experience)
- [Reporting — Spot what's working and what needs attention](https://linearb.io/use-case/measuring-developer-experience)
- [Surveys — Turn developer feedback into actionable signals](https://linearb.io/platform/developer-surveys)
- [Platform overview](https://linearb.io/platform/overview)
- [Watch now](https://linearb.io/resources/engineering-productivity-gap)
- [Customers](https://linearb.io/customers)
- [Pricing](https://linearb.io/pricing)
- [Why choose LinearB — Explore your data. Measure performance. Act to improve it.](https://linearb.io/why-linearb)
- [APEX framework — The operating model for AI-era engineering teams](https://linearb.io/resources/apex-framework)
- [Anti-FAQ — The questions other vendors won't answer](https://linearb.io/why-linearb/anti-faq)
- [Security — Enterprise-grade compliance and zero code access](https://linearb.io/security)
- [Build vs. buy — The hidden cost of building it yourself](https://linearb.io/resources/build-vs-buy)
- [Dev Interrupted Podcast — Conversations with engineering leaders](https://linearb.io/dev-interrupted/podcasts)
- [Reports & Guides — Deep dives on productivity and delivery](https://linearb.io/resources)
- [Webinars — Expert sessions on productivity and AI](https://linearb.io/resources?category=workshops)
- [Metrics Benchmarks — See how your engineering org stacks up](https://linearb.io/resources/software-engineering-benchmarks-report)
- [Blog — Product updates and practical insights](https://linearb.io/blog)
- [Help Center — Documentation, setup, and support](https://linearb.helpdocs.io)
- [API Docs](https://docs.linearb.io/api-overview)
- [Status](https://www.linearbstatus.com/)
- [Integrations](https://linearb.io/integrations)
- [LinearB Library](https://linearb.io/library)
- [Engineering metrics](https://linearb.io/library/engineering-metrics)
- [Platform engineering](https://linearb.io/library/platform-engineering)
- [Engineering glossary](https://linearb.io/library/engineering-glossary)
- [Developer productivity](https://linearb.io/library/developer-productivity)
- [AI in software development](https://linearb.io/library/ai-in-software-development)
- [Engineering management](https://linearb.io/library/engineering-management)
- [Developer experience](https://linearb.io/library/developer-experience)
- [DevOps](https://linearb.io/library/devops)
- [Engineering operations and the context layer](https://linearb.io/library/engineering-operations)
- [Engineering efficiency](https://linearb.io/library/engineering-efficiency)
- [Software delivery](https://linearb.io/library/software-delivery)
- [Research and data](https://linearb.io/library/engineering-benchmarks-and-research)
- [LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms](https://linearb.io/resources/gartner-magic-quadrant-dpi-platforms-2026)
- [Sign in](https://app.linearb.io/login)
- [Enterprise](https://linearb.io/solutions/enterprise)
- [Contact](https://linearb.io/contact-us)
- [About us](https://linearb.io/about-us)
- [Careers](https://linearb.io/careers)
- [Service agreement](https://linearb.io/services-agreement)
- [Privacy policy](https://linearb.io/privacy-policy)
- [DPA](https://linearb.io/data-processing-agreement)
- [Security FAQ](https://linearb.io/security-faq)
- [Substack](https://devinterrupted.substack.com/)

### Footer

_Additional links from the site footer, not repeated from the top navigation above._

- [GitHub](https://github.com/linear-b)
- [LinkedIn](https://www.linkedin.com/company/linearb)
- [Twitter](https://twitter.com/LinearB_Inc)