OpenAI Acquires Pierre and Opens Codex to All Tiers: 3 Changes in AI Coding Agent Infrastructure Explained

Author’s note: A look at OpenAI’s acquisition of Pierre, the company behind Code Storage, and the rollout of Codex to all tiers: which tools are involved, how existing users are affected, and where the AI coding agent toolchain may be headed.

OpenAI recently announced two developments that might not seem like much on their own, but together tell a bigger story. First, OpenAI announced its acquisition of Pierre Computer Company, the company behind Code Storage and several open-source developer tools. Second, alongside Images 2.6, it announced that Codex is available to all tiers across web, desktop, and mobile.

This is more than just an acquisition of a team and its products. Pierre’s Trees and Diffs libraries already power file browsing and code change review in the Codex app. The acquisition brings those underlying components, which Codex already relies on, in-house. This article covers the tools involved, what the deal means for different users before and after closing, and where we think the coding agent toolchain is headed.

What you’ll take away: You’ll understand what OpenAI’s acquisition of Pierre means for your open-source dependencies, your Code Storage account, and your day-to-day use of Codex.

OpenAI’s Acquisition of Pierre: Key Facts

Here’s a summary of the information made public so far. The sources are summaries of official announcements, and neither the deal value nor a specific timeline has been disclosed. Unknown details are marked accordingly below.

What roles do Pierre’s Trees and Diffs play in Codex?

When working with a coding agent, developers frequently need to check which files the agent touched and review the code it changed. The first task calls for a file tree component that efficiently displays the project structure; the second needs a clear diff display and review component. According to the official announcement, these two capabilities in the Codex app are powered by Pierre’s Trees and Diffs libraries, respectively.

This highlights an easily overlooked point: the coding agent experience depends on more than a model’s ability to write code. When an agent changes a dozen or more files at once, a confusing review interface can make developers hesitant to merge. No matter how capable the model is, the process can stall at the human approval step. Trees and Diffs address precisely this part of human-agent collaboration, so OpenAI’s decision to bring in the team behind them makes sense.

Codex Opens to All Tiers: AI Coding Agents Become a Standard Feature

At the same time as the acquisition news, OpenAI announced that Codex is now available across all tiers on the web, desktop, and mobile. The announcement came alongside Images 2.6, with GPT-Image-2.6 Flare and Sunburst also becoming available through the API. For developers, though, the Codex news has a more direct impact.

“All tiers” means coding agents are no longer just an add-on for higher-tier subscriptions—they’re now a standard capability available to ChatGPT users. That said, the official summary didn’t specify differences in usage limits, task duration, or concurrency across tiers. These limits will likely vary, so check OpenAI’s official pages for the latest details rather than assuming every tier is identical when planning for your team.

Taken together, the two announcements show a clear direction: OpenAI is expanding access to Codex while strengthening its infrastructure for file browsing, change review, and even code storage. As the user base grows, the reliability of these “non-model” components becomes more important. Bringing them in-house ahead of time is a sensible way to prepare.

How OpenAI’s Acquisition of Pierre Affects Developers

Impact on Pierre Open-Source Project Users

If your project depends directly on Trees, Diffs, or Pierre’s other open-source tools, the official commitment is that they’ll remain open source after the acquisition closes. There’s no immediate need to look for alternatives; just keep up with releases as usual.

That said, “remaining open source” doesn’t mean “the roadmap won’t change.” After an acquisition, open-source libraries often evolve to better serve the acquirer’s products—for example, by prioritizing Codex use cases. Consider pinning versions in your dependency files, and watch for changes to repository licenses, maintainers, and issue response times.

Impact on Existing Code Storage Customers

According to the official announcement, Code Storage customers can continue using the product, and its features will gradually be integrated into Codex. Two points remain unclear: the timeline for that integration and whether Code Storage will remain available as a standalone product in the long term. Until those details are settled, it’s prudent to keep your data exportable and avoid tying critical workflows too closely to a single service.

The Impact on the AI Coding Agent Toolchain

This acquisition shows that competition among coding agents is expanding from “who has the best model for writing code” to “who has the most complete workflow.” A complete coding agent involves at least four layers: the model layer generates code, the storage layer manages code and versions, the review layer helps people understand and approve changes, and the interaction layer provides access across different devices.

We believe the review layer will become a key battleground for coding agent products. The more capable agents become, the more changes they can make in a single submission—and the heavier the burden on human reviewers. Teams will be more likely to trust products that make changes across dozens of files easy to understand at a glance.

🎯 Technical tip: Coding agents ultimately consume model invocations. If you’re configuring custom models in tools like Cursor or Cline, or building your own code review scripts, you can use one API key through APIYI apiyi.com to access models from OpenAI, Claude, Gemini, and others. This makes it easier to compare their review quality on the same diff.

Build Your Own Diff Reviewer With an OpenAI-Compatible API: A Minimal AI Coding Agent Approach

Codex’s review capabilities are currently available only within its own app, and OpenAI hasn’t explained how Codex relates to third-party API integrations. But any developer can use an OpenAI-compatible API to bring the idea of “having a model review a code change” into their own pipeline. Here’s a minimal example that reads the staged diff and asks a model for review feedback.

import subprocess
import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # OpenAI-compatible API
)

diff = subprocess.run(["git", "diff", "--staged"], capture_output=True, text=True).stdout

resp = client.chat.completions.create(
    model="gpt-4o-mini",  # Can be replaced with any model available on the platform
    messages=[
        {"role": "system", "content": "你是资深代码审阅者，指出潜在 bug、风险和改进建议。"},
        {"role": "user", "content": f"请审阅以下代码变更:\n{diff}"}
    ]
)
print(resp.choices[0].message.content)

import subprocess
from typing import List
import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"
)

SYSTEM_PROMPT = (
    "你是资深代码审阅者。针对给定文件的 diff，"
    "按「严重问题 / 潜在风险 / 改进建议」三类输出，没有问题请明确说明。"
)

def changed_files() -> List[str]:
    """Get the list of files with staged changes."""
    out = subprocess.run(
        ["git", "diff", "--staged", "--name-only"],
        capture_output=True, text=True
    ).stdout
    return [f for f in out.splitlines() if f.strip()]

def file_diff(path: str) -> str:
    """Get the diff for a single file."""
    return subprocess.run(
        ["git", "diff", "--staged", "--", path],
        capture_output=True, text=True
    ).stdout

def review(path: str, diff: str, model: str = "gpt-4o-mini", max_chars: int = 12000) -> str:
    """Review changes to a single file, truncating diffs that are too long."""
    if len(diff) > max_chars:
        diff = diff[:max_chars] + "\n...（diff 过长，已截断）"
    try:
        resp = client.chat.completions.create(
            model=model,
            messages=[
                {"role": "system", "content": SYSTEM_PROMPT},
                {"role": "user", "content": f"文件: {path}\n\n{diff}"}
            ],
            max_tokens=1000
        )
        return resp.choices[0].message.content
    except Exception as e:
        return f"审阅失败: {e}"

if __name__ == "__main__":
    for path in changed_files():
        print(f"===== {path} =====")
        print(review(path, file_diff(path)))
        print()

Essentially, this script is a machine-review version of what components like Diffs do in coding agents: split changes by file and provide feedback on each one. Splitting by file avoids sending an excessively long context all at once and makes it easy to match feedback to specific files. It’s also straightforward to integrate with a Git hook or CI.

🚀 Quick start: If you’d like to compare how different models review your project’s code, register at APIYI apiyi.com to get free trial credits. You can switch models for comparison by changing only the model parameter—no other code changes needed.

FAQ: OpenAI’s Acquisition of Pierre and Codex Availability

OpenAI’s Acquisition of Pierre: Key Takeaways

• The acquisition target: OpenAI is acquiring Pierre, the company behind Code Storage and several open-source tools.
• Core components are already in use: Trees powers file browsing in Codex, while Diffs handles code change reviews.
• Open source remains open: Pierre’s open-source projects will remain open source after the deal closes.
• A smooth transition for Code Storage: Customers can continue using it, and its features will gradually be integrated into Codex.
• The deal hasn’t closed yet: It’s still subject to regulatory approval, and the price and timeline haven’t been disclosed.
• Codex is becoming a core capability: It’s available across all tiers on the web, desktop, and mobile.
• More flexible model evaluation: Teams building their own review workflows can compare models through the unified APIYI apiyi.com interface.

Summary

OpenAI’s acquisition of Pierre and the availability of Codex across all tiers point in the same direction: competition among coding agents is expanding beyond model capabilities to encompass the entire workflow.

1. The review layer is getting attention: Trees and Diffs show that helping people understand an agent’s changes is just as important as getting the agent to write code.
2. The storage layer is being integrated: Bringing Code Storage features into Codex means code storage will become a built-in capability for coding agents.
3. Access is expanding: With Codex available across all tiers and on three types of devices, coding agents are becoming a default tool.

For developers, the most practical approach right now is to pin open-source dependencies to specific versions and keep an eye on changes, make sure Code Storage data remains exportable, and check official guidance for Codex usage limits. Meanwhile, you can start building the parts you control, such as review and testing, using an OpenAI-compatible interface. We recommend using APIYI apiyi.com to quickly evaluate how different models review your project. We’ll continue to follow any updates as the deal moves toward closing.

📚 References

1. OpenAI Announces Acquisition of Pierre, the Company Behind Code Storage: Acquisition summary
2. Link: aihot.news/items/c39s97tylya5njp0nro6dwvbx

3. Details: Covers how Trees and Diffs are used in Codex, as well as plans for the open-source projects and Code Storage customers

4. OpenAI Releases Images 2.6 and Opens Codex to All Tiers: Summary of product updates announced around the same time

5. Link: aihot.news/items/o915zd1u1eq13gyo9x3nsgoq8

6. Details: Covers Codex availability across web, desktop, and mobile

7. OpenAI’s Official Images 2.6 Introduction: Official launch page

8. Link: openai.com/index/introducing-images-2-6
9. Details: Official information on Images 2.6 and GPT-Image-2.6 Flare and Sunburst

Author: APIYI Technical Team
Technical discussions: Contact us through the APIYI homepage, or visit docs.apiyi.com for more integration resources.