What Technology Does Pierre Actually Have? Breaking Down 5 Products Used by Codex, Including Trees, Diffs, and Code Storage

Author’s note: OpenAI has announced plans to acquire Pierre. This article breaks down Pierre’s five products—Trees and Diffs, which are already used in Codex, plus Highlights, DiffsHub, and the paid Code Storage service—to show you which open-source components you can use directly.

On November 4, 2026, OpenAI announced that it plans to acquire developer tools company Pierre Computer Company. Many people’s first reaction was, “OpenAI bought another Git hosting company,” but that’s not quite right. Pierre has a full technology stack spanning code browsing, diff comparison, online editing, syntax highlighting, and Git storage—and two of its products are already running in the Codex App.

This isn’t just a rumor or a news brief. OpenAI’s official announcement confirms that Codex uses Pierre’s Trees and Diffs libraries, and Pierre’s open-source repositories and NPM packages are publicly available. The deal hasn’t closed yet, and the acquisition price hasn’t been disclosed.

What you’ll get: By the end of this article, you’ll have a clear map of Pierre’s products, understand the distinction between its open-source components, online tools, and paid storage service, and know which components you can add to your own projects today.

Pierre Acquisition: Key Facts at a Glance

Let’s separate what’s confirmed from what isn’t. The table below includes only details explicitly stated in OpenAI’s announcement and Pierre’s official channels.

The two companies will continue to operate independently until the deal closes. Axios interpreted the deal as a move by Codex into the code collaboration space long dominated by GitHub. That’s the outlet’s assessment of the competitive direction, though—OpenAI hasn’t announced a full GitHub replacement.

Pierre’s Technical Map: Open-Source Components, Online Tools, and Paid Storage

The key to understanding Pierre is to break its products into three layers. Pierre doesn’t specialize in training Large Language Models or selling model APIs. Instead, it builds the software and infrastructure needed to display, edit, store, and manage code. Its website describes its offering as “low-level, composable infrastructure for machine-driven workloads.”

The open-source components are housed in the GitHub repository pierrecomputer/pierre, under the Apache License 2.0. As of 2026-11-05, the repository had approximately 6,500 stars, 266 forks, and 1,320 commits. These figures are a snapshot and will change over time. Note that the repository doesn’t contain all the commercial backend code for Code Storage.

Pierre Diffs Breakdown: Edit Mode, Review UI, and Merge Conflicts

The open-source Diffs package is @pierre/diffs. At the time of checking, the official homepage listed version v1.6.4, with @pierre/diffs/react as the React entry point. Its core functionality is rendering code files, patches, and differences between two versions in a web page. It supports both Split, a side-by-side view, and Stacked/Unified, a combined vertical view, with inline character- and word-level highlighting. Developers can provide either two versions of a file or a patch file directly.

Diffs Edit Mode: Edit Code Directly in the Diff View

OpenAI’s announcement called out this feature specifically: reviewers can edit a line of code directly in the Diff view. Edit Mode supports selections and multi-selection, auto-indentation, Undo/Redo, in-file search, lint markers, custom editing actions, and local and remote cursors. The project provides an EditProvider and related Editor APIs. Some editing features are still marked as Beta.

It solves a specific pain point: in a traditional workflow, when you spot a problem in a line of AI-generated code, you have to switch to a full editor, locate the file, make the change, and return to the review interface. Edit Mode brings finding and fixing problems into the same interface, which is especially useful when an agent generates lots of changes and a human reviews them piece by piece.

Diffs Code Review UI: A Pluggable Annotation Framework

Diffs provides a flexible Annotation framework that lets you attach line-level comments, CI results, AI review feedback, and third-party tool output to specific lines of code. Developers can also add custom buttons such as Accept Change and Reject Change to the diff view, support replies to comments, and attach explanations to selected lines.

It’s important to draw a distinction here: Diffs is a display and interaction component, not an AI model that automatically discovers vulnerabilities. Your own system determines where review feedback comes from—for example, you could connect a Large Language Model API to generate suggestions, then have Diffs render them.

Diffs Merge Conflict: Structured Conflict Resolution

When a plain-text diff encounters a merge conflict, it can only display a collection of conflict markers. Diffs provides a dedicated conflict-resolution UI that presents the conflicting sections as structured additions and deletions. Users can choose to keep the current version, accept the incoming version, or keep both, then preview the resolved file.

On the implementation side, the official documentation says Diffs supports Vanilla JavaScript and React, uses Shiki for syntax highlighting, and uses CSS Grid and Shadow DOM for parts of its rendering structure. It also provides SSR utilities, a Worker Pool, and virtualized rendering. Virtualization prevents the browser from rendering large amounts of off-screen content all at once.

Pierre Trees and Highlights: Large File Trees and Streaming Syntax Highlighting

Trees: A File Tree Component Built for Large Repositories

Trees is available as the open-source package @pierre/trees. At the time of review, the official site listed version v1.0.0-beta.6. It powers the file browser sidebar in tools like Codex, with features including directory expansion and collapse, filtering by name and path, automatic compaction of single-child empty directory chains, file and directory drag-and-drop, creation and renaming, custom context menus, and file icons.

One feature that’s especially useful for AI coding is Git status display. Files can be marked M (modified), A (added and staged), D (deleted), R (renamed), or U (untracked). Parent directories containing changed files can also show indicators. When an Agent changes dozens of files at once, developers can scan the tree to see where those changes landed.

For performance, Trees uses automatic virtualization, prioritizing the rendering of visible rows. The official site demonstrates a directory tree containing 2,956 files when fully expanded, along with virtualized rendering of tens of thousands of entries. These are official demos, not independent benchmarks, and they don’t guarantee consistent performance across all devices. For accessibility, Trees provides arrow-key navigation, Tab focus management, ARIA tree/treeitem roles, and more. The project says its design follows relevant WCAG 2.1 guidance.

Highlights: A Highlighter That Keeps Up With Agent Output

Highlights is currently available in Beta in the official Diffs documentation. The docs say it includes lexers for 152 languages, is based on WebAssembly, and runs in browsers, Node.js, and Cloudflare Workers. It can output HTML or Shiki-compatible token objects.

Its four main APIs each have a clear role: codeToHtml() handles complete code, codeToTokens() outputs tokens organized by line, StreamTokenizer works with content received progressively and outputs completed lines, and LiveTokenizer provides incremental updates for documents being edited. In short, Highlights solves a display problem: keeping syntax highlighting up as an Agent streams code. It doesn’t improve the model’s coding ability.

DiffsHub: Replace github.com With diffshub.com

DiffsHub is Pierre’s online tool for demonstrating Trees and Diffs in real-world scenarios. Replace github.com with diffshub.com in a GitHub Pull Request, Commit, Comparison, Patch, or Diff link, and you can browse the same changes in Pierre’s interface. Official examples include repositories such as oven-sh/bun and nodejs/node.

To access a private repository, you’ll need to provide your own GitHub Personal Access Token with the appropriate permissions. The site says the token is stored in the browser’s localStorage; this doesn’t mean Pierre can freely read private repositories. The site also warns that mobile browsers may crash when displaying extremely large diffs. DiffsHub is neither a GitHub replacement nor the open-source Diffs library itself.

How Pierre Code Storage Differs from a Standard GitHub Repository

If Trees and Diffs are the interface layer for “viewing code,” Code Storage is the infrastructure layer for “storing code”—and the strategic focus of this deal. It’s a distributed, programmable storage service built on Git for AI products that need to create, read, modify, and sync repositories at scale.

GitHub is built around human collaboration: repositories, PRs, Issues, and CI/CD. Code Storage takes a headless, API-first approach. It supports creating repositories, commits, branches, and merges through an API; writing files directly; streaming file reads; and filtering codebases with Grep and Glob. It also offers ephemeral branches, webhooks, Git LFS, and syncing with GitHub, GitLab, and Bitbucket. Standard Git operations over HTTPS—clone, push, and fetch—are available too.

In a Hacker News discussion about Code Storage (66 points, 42 comments), Pierre gave an example: after an agent modifies 10 files, submitting the changes through the GitHub REST API requires fetching the branch SHA, creating a branch, blobs, a tree, and a commit, then updating the reference. That takes about 15 requests, and under heavy load, you may also need to handle 422 errors caused by eventual consistency. Code Storage, by contrast, can submit the full diff with a single createCommitFromDiff call. This is the vendor’s explanation in a community discussion, not an independent comparison test.

Pierre says the architecture uses a Git three-phase commit protocol and a “Spoke-like” quorum-based architecture to ensure consistency and durability in distributed environments, though it hasn’t published the full cluster topology. For enterprise customers, it also claims SOC 2 Type II, HIPAA-related support, per-tenant encryption, and annual penetration testing. Buyers should still verify the reports and contract terms.

The customer case studies were also published by Pierre itself. The Lovable case reports more than 8 million new repositories per week, with repository creation peaking at 250 per second. Poke uses Git to store agent memory and workflow configurations, reporting a P95 push latency of 90 milliseconds. Skydive gives more than 150 agents their own private repositories to store identity definitions, MCP configurations, skills, and persistent memory. These examples point to a trend: Git repositories are expanding from “storing code” to “storing agent state.”

What’s New in Pierre SDK, CLI, and Agent Skills

On November 3, 2026, the day before the acquisition announcement, Pierre released a new unified SDK and CLI. The biggest change is that the SDK, CLI, and HTTP API now use consistent operation names. For example, creating a branch is pierre.repos.branches.create(), pierre repos:branches create, and /api/repos/{repo_name}/branches/create, respectively. Agents can use the same “operation catalog” to switch between interfaces.

# TypeScript SDK (Node.js 22 / 24 / 26)
npm install @pierre/sdk

# Python SDK (Python 3.10+)
pip install pierre-sdk

# Go SDK (Go 1.25+)
go get github.com/pierrecomputer/sdk/go

# CLI
npm install -g @pierre/cli

# Install Pierre Skills for coding agents
npx skills add pierrecomputer/skills

# Create a branch from main using the CLI
pierre repos:branches create feature/preview --repo-name my-repo --base-ref main

Authentication uses two environment variables, PIERRE_ORG and PIERRE_PRIVATE_KEY. For each operation, the SDK issues a token with matching permissions that’s valid for five minutes. The new SDK replaces @pierre/storage, pierre-storage, and code-storage-go. The old packages still work, but they won’t receive new releases. Note that this SDK and CLI are for Code Storage; they don’t mean OpenAI’s Codex CLI has gained new built-in commands.

How Pierre Code Storage Pricing Works

Code Storage pricing is easy to misread. Starter is listed at $20/month and Scale at $200/month, but those figures are minimum monthly charges, not fixed subscription fees added on top of usage. If a Starter user’s usage exceeds $20 in a month, they pay for actual usage; if it falls short, they pay $20.

The example in the official calculator uses 20GB of hot storage, 250GB of cold storage, and 250GB each of writes and reads, for an estimated $162/month. Using roughly 730 hours per month, that works out to about $73 for hot storage, $36.5 for cold storage, $15 for writes, and $37.5 for reads—a total of exactly $162. Reads account for a sizable share, which is one reason some developers on HN have criticized the network traffic charges. This is a simulated estimate, not an actual bill, and the pricing is entirely separate from Codex subscriptions and OpenAI model token pricing.

Getting Started with the Pierre Stack: Build an AI Review Prototype with Diffs

Pierre components don’t provide model capabilities. A practical setup is to extract changes with git diff, call a Large Language Model API to generate line-level feedback, and pass the results to Diffs as annotations for rendering. The architecture below is an example; it doesn’t imply that OpenAI offers a corresponding all-in-one API.

The minimal example takes just a few lines: send the diff to a model and ask it to return JSON.

import subprocess, openai

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

diff = subprocess.run(["git", "diff", "HEAD~1"], capture_output=True, text=True).stdout
resp = client.chat.completions.create(
    model="gpt-4o-mini",  # Replace with any model available on the platform
    messages=[{"role": "user", "content": f"逐行审查以下 diff，返回 JSON 列表 [{{file, line, comment}}]：\n{diff}"}]
)
print(resp.choices[0].message.content)

import json
import subprocess
from typing import List, Dict
import openai

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

SYSTEM_PROMPT = (
    "你是资深代码审查员。只针对 diff 中新增或修改的行给出意见，"
    "严格输出 JSON 数组，每项包含 file、line、severity、comment 四个字段。"
)

def get_diff(base: str = "HEAD~1") -> str:
    result = subprocess.run(
        ["git", "diff", base], capture_output=True, text=True, check=True
    )
    return result.stdout

def review_diff(diff: str, model: str = "gpt-4o-mini") -> List[Dict]:
    if not diff.strip():
        return []
    resp = client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": diff[:60000]},  # Simple truncation to avoid excessive length
        ],
        temperature=0.2,
    )
    text = resp.choices[0].message.content.strip()
    text = text.removeprefix("```json").removesuffix("```").strip()
    try:
        return json.loads(text)
    except json.JSONDecodeError:
        return [{"file": "", "line": 0, "severity": "info", "comment": text}]

if __name__ == "__main__":
    annotations = review_diff(get_diff())
    # Write results to a file for the frontend to attach to the corresponding lines using @pierre/diffs annotations
    with open("review_annotations.json", "w", encoding="utf-8") as f:
        json.dump(annotations, f, ensure_ascii=False, indent=2)
    print(f"生成 {len(annotations)} 条审查意见")

For the frontend, install @pierre/diffs, then attach the comments from review_annotations.json to the Diff view by file and line number. Use Edit Mode to let reviewers make changes in place. Refer to the official documentation at diffs.com/docs for component parameters.

🚀 Quick start: When building this kind of prototype, consider using APIYI apiyi.com for model access. One key lets you switch between GPT, Claude, Gemini, and other models, making it easy to compare their review quality on your codebase. New users also get free testing credits.

Impact of the Pierre Acquisition

Impact on Developers

• Open-source components are ready to use: Diffs and Trees are already running in production in Codex. Both are licensed under Apache-2.0 and are suitable for AI coding assistant sidebars, internal review platforms, or Agent workbenches. OpenAI has also committed to keeping them open source.
• The review bottleneck is shifting earlier: OpenAI says its internal weekly PR volume has more than doubled compared with the previous Q4 period. As code generation gets faster, review interfaces that make code easy to understand and quick to change will become critical to productivity.
• A new approach to Agent state storage: The Poke and Skydive examples show that Git can store Agent memory and configuration, with history and rollback built in.

Impact on the Industry

• Codex covers more of the development lifecycle: It now extends from generation and review to storage. But as of 2026-11-05, there’s no evidence that GitHub integration will be discontinued.
• Don’t confuse Pando with Code Storage: Pando, announced by OpenAI on November 2, is a Git backend developed in-house to support its internal monorepo. It’s a separate project from Pierre’s Code Storage.
• Community feedback is inconclusive: In HN discussions, some people have raised questions about cold-storage archival and how the service differs from GitHub, while others have criticized its traffic-based charges. A few dozen comments don’t represent the entire developer community, and there are no independent, large-scale evaluations yet.

Frequently Asked Questions (FAQ)

Pierre Trees, Diffs, and Code Storage: Key Takeaways

• Three layers: Pierre consists of open-source components, online tools, and a paid storage service—not a single Git platform.
• What’s already integrated: The Codex App already uses Trees and Diffs; Code Storage integration is still planned for later.
• Diffs highlights: Inline editing with Edit Mode, an Annotation review UI, and structured merge conflict handling.
• Trees highlights: Virtualized rendering for large file trees, with native display of Git statuses such as M/A/D/R/U.
• Code Storage’s role: API-first Git infrastructure; all performance figures are self-reported by the vendor.
• Pricing: $20/$200 are minimum monthly spends, with charges based on storage and traffic—not additional subscription fees.
• Getting started: Install the Diffs component and connect to a model through APIYI at apiyi.com to build a review prototype.

Summary

Pierre’s technical offering comes down to three points:

1. The UI layer is proven: Trees and Diffs are already running in Codex, and both are open-source components you can integrate for free today.
2. The storage layer is the strategic focus: Code Storage turns Git into programmable infrastructure for agents, but its scale and performance figures are still self-reported by the vendor.
3. Keep the boundaries clear: The proposed acquisition hasn’t closed, Pando is unrelated to Code Storage, and storage pricing and model pricing are separate.

If you’re building an AI coding tool or an internal code review platform, the most practical approach is to start with @pierre/diffs and @pierre/trees for the interface, then connect a Large Language Model to generate review comments. We recommend using APIYI at apiyi.com to quickly test the results—you can compare how multiple models perform on your codebase through a single interface.

📚 References

1. OpenAI acquisition announcement: OpenAI to acquire Pierre Computer Company, Inc.
2. Link: openai.com/index/openai-to-acquire-pierre

3. Details: Primary source for the transaction status, components already used in Codex, and open-source commitments

4. Diffs website and documentation: Diffs components, Edit Mode, and Highlights

5. Link: diffs.com/docs

6. Details: Interactive examples and complete API documentation

7. Trees website: File tree component demo

8. Link: trees.software

9. Details: Git status, virtualization, and accessibility

10. Code Storage pricing: Official billing rates and pricing simulator

11. Link: code.storage/pricing

12. Details: Minimum monthly spend and usage-based pricing

13. Pierre SDK and CLI release notes: 2026-11-03 update

14. Link: code.storage/changelog/pierre-sdk-and-cli

15. Details: Installation commands, environment requirements, and unified naming

16. Pierre open-source repository: Apache-2.0 open-source code

17. Link: github.com/pierrecomputer/pierre

18. Details: Component source code and community activity

19. Scaling Git at OpenAI: Introduction to OpenAI’s in-house Pando

20. Link: openai.com/index/scaling-git-at-openai
21. Details: Helps distinguish Pando from Code Storage

Author: APIYI Technical Team
Technical discussions: If you’d like to compare Large Language Models for an AI code review project, visit APIYI at apiyi.com for testing credits and to connect with us.