OpenClaw's Creator Joined OpenAI — And OpenAI Immediately Opened Codex to All Paid Users
Peter Steinberger built OpenClaw, then joined OpenAI. Days later, Codex became available to all paid OpenClaw users. Here's what that move signals.
Peter Steinberger Built OpenClaw. Then He Joined OpenAI. Then Codex Opened Up.
Peter Steinberger, the creator of OpenClaw, is now an employee at OpenAI. Shortly after he joined, OpenAI added a Codex OOTH route to OpenClaw’s provider docs and Sam Altman announced on May 1st that OpenClaw is now available under all paid ChatGPT plans. You can call that a coincidence. You probably shouldn’t.
This is one of those moments where the personnel move and the product move are the same move. When the person who built the most popular open-source agent runtime joins a lab, and that lab immediately makes its most agentic product a first-class citizen inside that runtime, something structural has shifted. Not just in OpenClaw’s roadmap. In the competitive dynamics of the entire agent layer.
To understand why this matters, you need to understand what OpenClaw actually is now — because it’s changed considerably from what it was six months ago.
What OpenClaw Became Before Steinberger Left
The early version of OpenClaw was compelling because it gave a model access to your computer, your files, your browser, your apps. It was powerful in the way a sharp knife is powerful — useful, a bit dangerous, and not particularly organized.
Hire a contractor. Not another power tool.
Cursor, Bolt, Lovable, v0 are tools. You still run the project.
With Remy, the project runs itself.
What OpenClaw shipped in April 2026 is a different thing. The docs now describe TaskFlow as “the orchestration layer above background tasks” — it manages durable multi-step flows with their own state and revision tracking while individual tasks remain detached units of work. That’s not a feature. That’s an architecture.
Memory got the same treatment. Early agent memory was personalization — the bot remembers you like TypeScript. The April memory model introduced a memory wiki, active memory, and what the docs call providence-rich recall. Memory entries carry labels: observed from source, confirmed by user, inferred by model, imported from transcript. That distinction matters enormously for any workflow that runs unattended. An agent that can’t distinguish between something a user confirmed and something it inferred is an agent you can’t trust with real work.
This is the OpenClaw that Steinberger handed off when he walked into OpenAI. Not a viral demo. A runtime with state, memory, channels, task queues, retry logic, and a provider abstraction layer that could route work to different models depending on the step. The question was always: which models would be available through that abstraction, and on what terms?
The Anthropic Divergence
The timing here is not incidental. In April, Anthropic made a policy decision that landed badly with the developer community: subscription use for always-on third-party agents at scale was restricted. The reasoning is defensible — agents aren’t normal chat users. They run longer, retry more, carry more context, sit in loops. A flat-rate consumer subscription was never priced to absorb that load. If Claude is being used as infrastructure, Anthropic wants it paid for like infrastructure.
But defensible reasoning and popular reasoning are different things. The effect for OpenClaw builders who had built their workflows around Claude subscriptions was immediate: Claude became a metered, premium component rather than the cheap always-on substrate for background loops. That’s a different design assumption, and it forced a rethink.
OpenAI read that moment correctly. They had more online compute. They had Codex, which was already an agentic product. And now they had the creator of the most popular open-source agent runtime on their payroll. The Codex OOTH route in OpenClaw’s provider docs and the Sam Altman announcement weren’t separate decisions — they were one decision expressed in two places.
For a deeper look at how these three labs are making structurally different bets on the agent layer, the Anthropic vs OpenAI vs Google agent strategy comparison is worth reading alongside this.
What the Codex Integration Actually Unlocks
The Codex /goal feature is the specific capability that makes this integration interesting. Philip Corey, who works on Codex at OpenAI, described it as “our take on the Ralph loop” — keep a goal alive across turns, don’t stop until it’s achieved. A16Z’s Andrew Chen ran /goal on an eGPU plus Mac device driver project for 14 hours unattended and reported it was still making progress. That’s not a chatbot. That’s a worker.
The practical implication for OpenClaw users is that they now have access to a model that’s designed to run the kind of long-horizon, multi-step work that OpenClaw’s TaskFlow layer was built to manage. The runtime and the model are now designed for the same use case. That’s a meaningful alignment.
Day one: idea. Day one: app.
Not a sprint plan. Not a quarterly OKR. A finished product by end of day.
But the more interesting implication is architectural. OpenClaw’s provider abstraction was always the right idea — build the action layer so the brain can change. The Anthropic restriction proved why that matters. The Codex integration proves that the abstraction works. If you built your OpenClaw workflow to be model-agnostic, you can now route hard implementation work to Codex, use Claude API for high-judgment architectural decisions where the metered cost is worth it, and use local Gemma-class models for cheap background classification and triage.
Google’s release of Gemma 4 under Apache 2.0 — explicitly positioned for agentic workflows and edge use — completes this picture. Not every agent step deserves frontier model pricing. Gemma 4 is a credible local branch for the classification and triage work that doesn’t need GPT-5.5 or Claude. The routing logic becomes: local Gemma for cheap classification, Codex for hard implementation, Claude API for high-judgment architectural work, cheaper hosted models for bulk summarization. Your workflow should be sophisticated enough to survive those routing decisions. If you want to build that kind of multi-model routing without writing the orchestration code yourself, MindStudio offers a no-code path — 200+ models, 1,000+ integrations, and a visual builder for chaining agents across exactly this kind of tiered workflow.
For a practical walkthrough of how to implement this kind of tiered model routing in OpenClaw specifically, the OpenClaw best practices guide from 200+ hours of use covers the specifics.
The Personnel Move as Product Signal
Here’s the thing about Steinberger joining OpenAI that most coverage is missing. It’s not just that OpenAI acquired goodwill with the OpenClaw community. It’s that OpenAI acquired the person who understands the runtime’s architecture better than anyone else.
OpenClaw’s extensibility was always its strategic asset. The reason it grew so fast is that it was built as a primitive — a set of composable pieces that could be extended in many directions. Steinberger built that. He knows where the seams are, where the abstraction is load-bearing, and where the current design creates friction for the use cases that matter most.
When OpenAI makes Codex more native to OpenClaw’s provider layer, they’re not just adding a model option. They’re shaping how the runtime evolves. The OOTH route is the first visible output of that influence. It won’t be the last.
This is also why the Anthropic situation is more complicated than “OpenAI wins, Anthropic loses.” Anthropic still has the model that many serious OpenClaw users prefer for high-judgment work. The API is still available. The restriction was on subscription-backed always-on agents, not on API usage. Builders who were already using the API correctly are largely unaffected. The ones who got caught were the ones who had built infrastructure on top of a consumer subscription — which was always a fragile foundation.
The real lesson from the Anthropic move isn’t “don’t use Claude.” It’s “don’t build your workflow’s survival on any single provider’s subscription policy.” That’s the same lesson the Steinberger/Codex announcement teaches, just from the other direction.
Memory Is the Layer That Outlives the Model War
There’s a third piece of this story that gets less attention than the personnel drama and the provider competition. It’s memory.
- ✕a coding agent
- ✕no-code
- ✕vibe coding
- ✕a faster Cursor
The one that tells the coding agents what to build.
If OpenClaw can now route work across Codex, Claude API, local Gemma, and whatever comes next, the memory layer has to live outside all of them. This is not a subtle point. An agent that remembers things inside a single model’s context window loses that memory the moment you swap the model. An agent that remembers things inside a single provider’s product is locked to that provider. Neither is acceptable for a workflow you intend to run for months.
The Open Brain project — an open-source GitHub repo of memory recipes for OpenClaw — addresses this directly. The code review memory recipe stores reusable lessons from PRs. The task flow worklog records what a long-running agent attempted, what changed, what blocked it, what the next agent should know. The memory provenance recipe labels where each memory entry came from: observed from source, confirmed by user, inferred by model, imported from transcript.
That last recipe is the one that matters most in a multi-model world. When you’re routing work across different models, you need to know which model produced which memory, under what conditions, with what confidence. Without those labels, memory accumulates into noise. With them, memory becomes operational context — the kind that lets an agent start the next incident response with the last one in view, or review a PR against the actual conventions the team has established over time, not just the ones in the current prompt.
The providence labels aren’t bureaucracy. They’re what makes the memory trustworthy when the brain changes.
What This Means If You’re Building on OpenClaw Now
The Steinberger/Codex announcement is a signal about where OpenAI is placing its bets on the agent layer. They’re not just building their own agent products — they’re making their infrastructure feel like the natural home for open agent workflows. The subscription access, the OOTH route, the /goal feature designed for exactly the kind of long-running work OpenClaw’s TaskFlow manages — these are consistent moves in a coherent direction.
For builders, the practical implication is that Codex is now a first-class option for the hard implementation steps in your OpenClaw workflows. The /goal feature in particular is worth experimenting with for tasks that have a clear objective and a long horizon. The A16Z report of 14 hours of unattended progress on a device driver project is a data point, not a guarantee — but it suggests the model is genuinely designed for the use case.
The broader implication is about architecture. The Anthropic restriction and the Codex opening happened in the same month. That’s not a coincidence — it’s the model war expressing itself through provider policy. The builders who are insulated from that war are the ones who built their workflows to be model-agnostic from the start: durable TaskFlow loops, memory that lives outside any single model, routing logic that can send different steps to different brains.
If you’re building on OpenClaw and you haven’t yet separated your workflow logic from your model choice, now is the time. Not because any particular provider is going to disappear, but because the provider landscape is actively contested and the terms will keep changing. The runtime should outlive the subscription policy.
Plans first. Then code.
Remy writes the spec, manages the build, and ships the app.
The Hermes Agent framework takes a different approach to this problem — building skills from experience rather than explicit memory recipes — and is worth understanding as a contrast. And if you’re thinking about the model side of this equation, the GPT-5.4 vs Claude Opus 4.6 comparison gives a concrete sense of where each model currently has an edge for different workflow steps.
One more thing worth considering as you build: the abstraction level is rising. Tools like Remy take this further — you write a spec in annotated markdown, and a complete full-stack TypeScript application gets compiled from it. The spec is the source of truth; the generated code is derived output. The same principle applies to agent workflows: the durable asset is the workflow definition, the memory architecture, the routing logic — not the model that happens to be executing it today.
Steinberger built OpenClaw as an extensible primitive. OpenAI is now shaping how that primitive evolves. The builders who understand that dynamic — and build accordingly — are the ones who will still be running their workflows when the next round of provider policy changes lands.
