Unlocking the Codex harness: how we built the App Server
By Celia Chen, Member of the Technical Staff
OpenAIโs coding agent Codex exists across many different surfaces: the web appโ (แแฎแกแแแแ แแฎแแ แคแแแฏแแ แแจแ), the CLIโ (แแฎแกแแแแ แแฎแแ แคแแแฏแแ แแจแ), the IDE extensionโ (แแฎแกแแแแ แแฎแแ แคแแแฏแแ แแจแ), and the new Codex macOS app. Under the hood, theyโre all powered by the same Codex harnessโthe agent loop and logic that underlies all Codex experiences. The critical link between them? The Codex App Serverโ (แแฎแกแแแแ แแฎแแ แคแแแฏแแ แแจแ), a client-friendly, bidirectional JSON-RPC1 API.
In this post, weโll introduce the Codex App Server; weโll share our learnings so far on the best ways to bring Codexโs capabilities into your product to help your users supercharge their workflows. Weโll cover the App Serverโs architecture and protocol and how it integrates with different Codex surfaces, as well as tips on leveraging Codex, whether you want to turn Codex into a code reviewer, an SRE agent, or a coding assistant.
Before diving into architecture, itโs helpful to know the App Serverโs backstory. Initially, the App Server was a practical way to reuse the Codex harness across products that gradually evolved into our standard protocol.
Codex CLI started as a TUI (terminal user interface), meaning Codex is accessed through the terminal. When we built the VS Code extension (a more IDE-friendly way to interact with Codex agents), we needed a way to use the same harness so as to drive the same agent loop from an IDE UI without re-implementing it. That meant supporting rich interaction patterns beyond request/response, such as exploring the workspace, streaming progress as the agent reasons, and emitting diffs. We first experimented with exposing Codex as an MCP serverโ (แแฎแกแแแแ แแฎแแ แคแแแฏแแ แแจแ), but maintaining MCP semantics in a way that made sense for VS Code proved difficult. Instead, we introduced a JSON-RPC protocol that mirrored the TUI loop, which became the unofficial first versionโ (แแฎแกแแแแ แแฎแแ แคแแแฏแแ แแจแ) of the App Server. At the time, we didnโt expect other clients to depend on the App Server, so it wasnโt designed as a stable API.
As Codex adoption grew over the next few months, internal teams and external partners wanted the ability to embed the same harness in their own products in order to accelerate their usersโ software development workflows. For example, JetBrains and Xcode wanted an IDE-grade agent experience, while the Codex desktop app needed to orchestrate many Codex agents in parallel. Those demands pushed us to design a platform surface that both our products and partner integrations could safely depend on over time. It needed to be easy to integrate and backward compatible, meaning we could evolve the protocol without breaking existing clients.
Next, weโll walk through how we designed the architecture and protocol so different clients can use the same harness.
First, letโs zoom in on whatโs inside the Codex harness and how the Codex App Server exposes it to clients. In our last Codex blog, we broke down the core agent loop that orchestrates the interaction between the user, the model, and the tools. This is the core logic of the Codex harness, but thereโs more to the full agent experience:
1. Thread lifecycle and persistence. A thread is a Codex conversation between a user and an agent. Codex creates, resumes, forks, and archives threads, and persists the event history so clients can reconnect and render a consistent timeline.
2. Config and auth. Codex loads configuration, manages defaults, and runs authentication flows like โSign in with ChatGPT,โ including credential state.
3. Tool execution and extensions. Codex executes shell/file tools in a sandbox and wires up integrations like MCP servers and skills so they can participate in the agent loop under a consistent policy model.
All the agent logic we mentioned here, including the core agent loop, lives in a part of the Codex CLI codebase called โCodex coreโ (แแฎแกแแแแ แแฎแแ แคแแแฏแแ แแจแ).โ Codex core is both a library where all the agent code lives and a runtime that can be spun up to run the agent loop and manage the persistence of one Codex thread (conversation).
To be useful, the Codex harness needs to be accessible to clients. Thatโs where the App Server comes in.
The App Server is both the JSON-RPC protocol between the client and the server and a long-lived process that hosts the Codex core threads. As we can see from the diagram above, an App Server process has four main components: the stdio reader, the Codex message processor, the thread manager, and core threads. The thread manager spins up one core session for each thread, and the Codex message processor then communicates with each core session directly to submit client requests and receive updates.
One client request can result in many event updates, and these detailed events are what allow us to build a rich UI on top of the App Server. Furthermore, the stdio reader and the Codex message processor serve as the translation layer between the client and Codex core threads. They translate client JSON-RPC requests into Codex core operations, listen to Codex coreโs internal event stream, and then transform those low-level events into a small set of stable, UI-ready JSON-RPC notifications.
The JSON-RPC protocol between the client and the App Server is fully bidirectional. A typical thread has a client request and many server notifications. In addition, the server can initiate requests when the agent needs input, like an approval, and then pause the turn until the client responds.
Next, weโll break down the conversation primitives, the building blocks of the App Server protocol. Designing an API for an agent loop is tricky because the user/agent interaction is not a simple request/response. One user request can unfold into a structured sequence of actions that the client needs to represent faithfully: the userโs input, the agentโs incremental progress, artifacts produced along the way (e.g., diffs). To make that interaction stream easy to integrate and resilient across UIs, we landed on three core primitives with clear boundaries and lifecycles:
1. Item: An item is the atomic unit of input/output in Codex. Items are typed (e.g., user message, agent message, tool execution, approval request, diff) and each has an explicit lifecycle:
item/startedwhen the item beginsoptional
item/*/deltaevents as content streams in (for streaming item types)item/completedwhen the item finalizes with its terminal payload
This lifecycle lets clients start rendering immediately on started, stream incremental updates on delta, and finalize on completed.
2. Turn: A turn is one unit of agent work initiated by user input. It begins when the client submits an input (for example, โrun tests and summarize failuresโ) and ends when the agent finishes producing outputs for that input. A turn contains a sequence of items that represent the intermediate steps and outputs produced along the way.
3. Thread: A thread is the durable container for an ongoing Codex session between a user and an agent. It contains multiple turns. Threads can be created, resumed, forked, and archived. Thread history is persisted so clients can reconnect and render a consistent timeline.
Now, weโll look at a simplified conversation between a client and an agent, where the conversation is represented by primitives:
At the beginning of the conversation, the client and the server need to establish the initialize handshake. The client must send a single initialize request before any other method, and the server acknowledges with a response. This gives the server a chance to advertise capabilities and lets both sides agree on protocol versioning, feature flags, and defaults before the real work begins. Hereโs an example payload from OpenAIโs VS Code extension:
This is what the server returns:
When a client makes a new request, it will first create a thread and then a turn. The server will send back notifications for progress (thread/started and turn/started). It will also send back inputs it registers as items, like the user message here.
Tool calls are also sent back to the client as items. Additionally, the server may ask for client approval before it can run an action by sending a server request. The approval will pause the turn until the client replies with either โallowโ or โdeny.โ This is what the approval flow looks like in the VS Code extension:

In the end, the server sends an agent message and then ends the turn with turn/completed. The agent message delta events stream pieces of the message back until the message is finalized with item/completed.
แแแแแ แแแแจแ แจแแขแงแแแแแแแแแ แแแแแ แขแแแแแฃแแแ แฃแแแ แฌแแแแแฎแแแกแแแแก. แแฃ แกแ แฃแแ turn-แแก JSON-แแก แแแฎแแ แแกแฃแ แ, แจแแแแซแแแแ Codex CLI-แแก แ แแแแแแขแแ แแฃแแแแแ แแแฃแจแแแ แขแแกแข-แแแแแแขแ:
แแฎแแ แแแแฎแแ, แ แแแแ แแแแแกแแแก แกแฎแแแแแกแฎแแ แแแแแแขแฃแ แ แแแแแแแ แ Codex-แก App Server-แแก แแแจแแแแแแ. แแแแแแฎแแแแแ แกแแ แแแขแแ แแก: แแแแแแแแ แแ แแแแแกแ แแ IDE-แแแก, Codex-แแก แแแ-แ แแแขแแแแก แแ TUI-แก.
แกแแแแแแจแ แขแ แแแกแแแ แขแ แแ แแก JSON-RPC stdio-แแ (JSONL). JSON-RPC แแแแ แขแแแแแก แแแแแแขแแก binding-แแแแก แจแแฅแแแแก แแฅแแแแแแแก แกแแกแฃแ แแแ แแแแจแ. Codex-แแก แแแแแแแ แแแแ แแ แแแ แขแแแแ แฃแแแ แแแขแแแ แแชแแแแแ App Server-แแก แแแแแแขแแแ แแแแแ แแแก แแกแแ แแแแแแ, แ แแแแ แแชแแ Go, Python, TypeScript, Swift แแ Kotlin. TypeScript-แแกแแแแก แแแแกแแแฆแแ แแแแแ แจแแแแซแแแแ แแแ แแแแแ Rust-แแก แแ แแขแแแแแแแแ แแแแแแแแ แแ แแ แจแแแแแแ แแ แซแแแแแแ:
แกแฎแแ แแแแแแกแแแแก แจแแแแซแแแแ JSON Schema-แก แแแแแขแ แแแแแแแแ แแ แแ แแ แแแแแกแชแแ แแฅแแแแแแแก แกแแกแฃแ แแแ แแแแแก แแแแแ แแขแแ แก แจแแแแแแ แแ แซแแแแแแ:

แแแแแแแแ แแแ แแแแแแขแแแ, แ แแแแ แช แฌแแกแ, แแแ แแแแแแแแ แแ แแฆแแแแ แแแแขแคแแ แแแกแแแแก แกแแแชแแคแแแฃแ App Server-แแก แแแแแ แฃแ แคแแแแก, แฃแจแแแแแ แแแก แ แแแแ แช แฎแแแแ แซแแแแแ แแแแฃแจแแแ แจแแแ แแ แแชแแกแก แแ JSON-RPC-แกแแแแก แฆแแแ แแแแ แฉแฃแแแแแ แแ แแฎแ แแ stdio แแ แฎแก. แแแแแแแแแ, แฉแแแแก VS Code-แแก แแแคแแ แแแแแแกแ แแ Desktop App-แจแ แแแฌแแแแแฃแแ แแ แขแแคแแฅแขแ แแแแชแแแก แแแแขแคแแ แแแกแแแแก แกแแแชแแคแแแฃแ Codex แแแแแ แก แแ แแแแแฃแแแ แจแแแแฌแแแแฃแ แแแ แกแแแแ, แ แแแ แแแแแแขแแ แงแแแแแแแแก แแฃแกแขแแ แแก แแแขแแแ แแแฃแจแแแก, แ แแแแแแแช แแแแแแแ แแแฃแแ แแแแฅแแก.
แงแแแแ แแแขแแแ แแชแแแก แแ แจแแฃแซแแแ แแแแแแขแแก แแแแแฎแแแแแแแก แฎแจแแ แแ แแแฌแแแแแ. แแแแ แแแ แขแแแแ แ, แแแแแแแแแ Xcode, แ แแแแแแก แชแแแแแแก แงแแคแก แแแแ, แ แแ แแแแแแขแก แกแขแแแแแฃแ แแ แขแแแแแก แแ แกแแญแแ แแแแแกแแก แฃแคแ แ แแฎแแ App Server-แแก แแแแแ แแ แแแฃแแแแแแก. แแกแ แแแ แจแแฃแซแแแแ แแแแฆแแ แกแแ แแแ แแก แแฎแแ แแก แแแฃแแฏแแแแกแแแแแ (แแแแแแแแแ, แฃแแแแแกแ แแแขแ-แแแแแแฅแขแแชแแ Codex core-แจแ แแ แแฎแแแ แแฎแแ แแแญแแ แแแ แแแแคแแแฃแ แแชแแแก แแแกแแฆแแแแแ) แแ แแแแแ แชแแแแ แจแแชแแแแแแแก แแแกแฌแแ แแแแแ แแแแแแขแแก แแฎแแแ แ แแแแแแก แแแแแแแก แแแ แแจแ. App Server-แแก JSON-RPC แแแแแแแ แ แจแแฅแแแแแแ แฃแแฃแแแแแ แแฃแแแ แแแแกแแแแแแ, แแแแขแแ แซแแแ แแแแแแขแแแก แจแแฃแซแแแแ แฃแกแแคแ แแฎแแ แแกแแฃแแ แแ แแฎแแ แกแแ แแแ แแแก.

Codex Web แแงแแแแแก Codex harness-แก, แแแแ แแ แฃแจแแแแก แแแก แแแแขแแแแแ แฃแ แแแ แแแแจแ. worker แแแแแแแแก แแแแขแแแแแ แก แแแแแขแแแแแ แกแแแฃแจแแ แกแแแ แชแแ, แแแก แจแแแแแ แฃแจแแแแก App Server-แแก แแแแแ แก แแ แแแแ แฉแฃแแแแก แฎแแแแ แซแแแ JSON-RPC over stdio2 แแ แฎแก. แแแ-แแแ (แ แแแแแแช แแแแฎแแแ แแแแแก แแ แแฃแแแ แแก แฉแแแแ แแจแ แแฃแจแแแแก) Codex backend-แก แแกแแฃแแ แแแ HTTP-แแ แแ SSE-แแ, แ แแแแแแช worker-แแก แแแแ แแแแแ แแ แแแฃแ task แแแแแแแแแก แกแขแ แแแแแก. แแก แแ แแฃแแแ แแก แแฎแแ แแก UI-แก แแกแฃแแฃแฅแก แขแแแแแก แแ แแแแแ แแ แแก แแแแซแแแแก แแแแแแแแแแ แฃแ แ แแแขแแแแก แแแกแแขแแแกแ แแ แแแแแ.
แ แแแแแ แแแ-แกแแกแแแแ แแคแแแแ แฃแแแ (แฉแแแแ แแแแ แแฎแฃแ แแแ, แฅแกแแแแแ แฌแงแแแแ), แแแ-แแแ แแแ แแฅแแแแ แฎแแแแ แซแแแแแ แแแแแแแแ แ แแแแชแแแแแแก แกแแแแ แฌแงแแ แ. แแแแแแแ แแแแแกแ แแ แแ แแแ แแกแแก แกแแ แแแ แแ แจแแแแฎแแ แแแจแแแแก, แ แแ แแฃแจแแแแ แแ แซแแแแแแ แแแจแแแแช แแ, แแฃ แฉแแแแ แแ แแแฅแ แแแ. แกแขแ แแแแแแแก แแ แแขแแแแแ แแ แจแแแแฎแฃแแ thread แกแแกแแแแ แแแแ แขแแแแแก แแฎแแ แกแแกแแแก แฎแแแแฎแแ แแแแแแจแแ แแแแก, แแแแ แซแแแแแแก แแฅแแแแ, แกแแแแช แแแฉแแ แแ, แแ แแแแแแแ แแแแแก แแแแแแขแจแ แแแแแแแ แแฌแงแแแแก แแแ แแจแ แแแฌแแแแก.

แแกแขแแ แแฃแแแ, TUI แแงแ โแแแขแแฃแ แโ แแแแแแขแ, แ แแแแแแช แแฃแจแแแแแ แแแแแ แแ แแชแแกแจแ, แกแแแแช แแแแแขแแก แชแแแแ, แแ app-server แแ แแขแแแแแแก แแแชแแแแ แแแ แแแแแ Rust core แขแแแแแก แแกแแฃแแ แแแแแ. แแก แแแ แแฃแ แแขแแ แแชแแแก แแฉแฅแแ แแแแ, แแฃแแชแ TUI-แก แแแแกแแแฃแแ แแแฃแ แจแแแแฎแแแแแแแช แแฅแชแแแแ.
แแฎแแ, แ แแชแ App Server แฃแแแ แแ แกแแแแแก, แแแแแแแแ TUI-แแก แ แแคแแฅแขแแ แแแแกโ (แแฎแกแแแแ แแฎแแ แคแแแฏแแ แแจแ), แ แแแ แแก แแแแแแงแแแแก แแ แแแแแกแแแแ แ แกแฎแแ แแแแแแขแแแแ แแแแฅแชแแก: แแแฃแจแแแก App Server-แแก แจแแแ-แแ แแชแแกแ, แแกแแฃแแ แแก JSON-RPC-แแ stdio-แแ แแ แแฉแแแแแก แแแแแ แกแขแ แแแแแ-แแแแแแแแแ แแ แแแแขแแแชแแแแแ. แแก แฎแกแแแก แแกแแ แกแแแฃแจแแ แแ แแชแแกแแแก, แกแแแแช TUI-แก แจแแฃแซแแแ แแแฃแแแแจแแ แแแก Codex แกแแ แแแ แก, แ แแแแแแช แแแกแขแแแชแแฃแ แแแแฅแแแแแ แแฃแจแแแแก, แจแแแแแ แฉแฃแแแก แแแแแขแ แแแแแแแแแกแแแ แแฎแแแก แแ แแแแแ แซแแแแก แแฃแจแแแแ แแแจแแแแช แแ, แแฃ แแแแขแแแ แแแแซแแแแแก แแ แแแแจแแ แ แแแฌแงแแแแ, แแ แแแแแช แแแแแแแแ แแแแ แแแแแฌแแแแ แชแแชแฎแแแ แแแแแฎแแแแแแ แแ แแแแขแ แแแแแ.
Codex App Server แแฅแแแแ แแแ แแแแ แแแแกแแก แแแขแแแ แแชแแแก แแแแแแ, แ แแแแแกแแช แแแแแแแแจแแช แจแแแแแแ แฉแฃแแแแ, แแฃแแชแ แแ แกแแแแแก แกแฎแแ แแแแแแแแแช แฃแคแ แ แจแแแฆแฃแแฃแแ แคแฃแแฅแชแแแแแแแ. แแแแฃแแแกแฎแแแแแ, แแแแแแขแแแก แแฃแ แฉแแแ Codex-แแแ แแแขแแแ แแชแแแกแแแแก แแแแแแงแแแแ Codex App Server, แแแแ แแ แฆแแ แก แกแฎแแแแแกแฎแแ แแแขแแแ แแชแแแก แแแแแแแก แแแฎแแ แแ แแแแ แแแฃแกแแแแกแ แแ แแแแฃแกแแแแก แแแแแแแช. แฅแแแแแ แแแงแแแแแแแ Codex-แแก แแแ แแแแก แงแแแแแแ แแแแ แชแแแแแฃแแ แแแแแ แแ แจแแแแฎแแแแแแ, แ แแชแ แแแแแแฃแแ แแแแแแแ แจแแแซแแแแ แแแ แแ แแ แฉแแแแแ แแงแแก.
แแแฃแจแแแ codex mcp-serverโ (แแฎแกแแแแ แแฎแแ แคแแแฏแแ แแจแ) แแ แแแฃแแแแจแแ แแแ แแแแแกแแแแ แ MCP แแแแแแขแแแแ, แ แแแแแกแแช stdio แกแแ แแแ แแแแก แแฎแแ แแแญแแ แ แแฅแแก (แแแแแแแแแ, OpenAI Agents SDKโ (แแฎแกแแแแ แแฎแแ แคแแแฏแแ แแจแ)). แแก แแแ แแ แแ แฉแแแแแแ, แแฃ แฃแแแ แแแฅแแ MCP-แแ แแแคแฃแซแแแแฃแแ แกแแแฃแจแแ แแ แแชแแกแ แแ แแกแฃแ แ Codex-แแก แแแแแซแแฎแแแแแ แแแกแขแ แฃแแแแขแแก แกแแฎแแ แแแแแงแแแแแ. แแแแฃแกแ แแกแแ, แ แแ แแฆแแแ แแฎแแแแ แแแแก, แ แแกแแช MCP แแฉแแแก, แแแแขแแ Codex-แกแแแชแแคแแแฃแ แ แแแขแแ แแฅแชแแแแ, แ แแแแแแแช แฃแคแ แ แแแแแแ แกแแกแแฃแ แกแแแแแขแแแแก แแงแ แแแแแ (แแแแแแแแแ, diff แแแแแฎแแแแแแ), แจแแแซแแแแ MCP แกแแแแแแ แฌแแ แขแแแแแแ แกแฃแคแแแ แแแ แแแแขแแแก.
แแแแ แแแแกแแกแขแแแ แแแแแแแแแแก แแแ แขแแขแฃแ แแแขแแ แคแแแกแก, แ แแแแแกแแช แจแแฃแซแแแ แแแแแ แแแก แแ แแแแ แแแแแแแก แแแแฌแแแแแแแกแ แแ แ แแแขแแแแก. แแก แแแ แแ แแ แฉแแแแแแ, แแฃ แแกแฃแ แ แแ แแ แแแกแขแ แแฅแชแแ, แ แแแแแแช แแ แแแแ แแแแแขแก แแแแ แแแแแชแแแก แแแฃแฌแแแก. แแแแแ แแแแกแ แแกแแ, แ แแ แแกแแแ แแ แแขแแแแแแแ แฎแจแแ แแ แจแแกแแซแแแแแแแแแแก แกแแแ แแ แแแแแแฃแแแ แแงแ แแแ แแแแก, แ แแช แฃแคแ แ แแแแแแ แ แแแขแแ แแฅแชแแแแแก แฌแแ แแแแแแแแก แแ แแฃแแแแก, แแแแกแแแฃแแ แแแแ แแแจแแ, แ แแชแ แแแแจแแแแแแแแแแ แแแแฌแแแแแแแกแแแแก แกแแแชแแคแแแฃแ แ แแแกแขแ แฃแแแแขแแแแกแ แแ แกแแกแแแแแก แกแแแแแขแแแ. แแก แกแแแ แชแ แกแฌแ แแคแแ แแแแแ แแแแ แแ แแแแแ, แ แแ แแแขแ แกแแแ แแ แกแขแแแแแ แขแ แแแฉแแแแแ, แ แแชแ แ แแแแฃแ แ แแแแแขแฃแ แ แกแแแฃแจแแ แแ แแชแแกแแแแก แฌแแ แแแกแแแแแ แกแแฃแแแแแกแ แแ แแแแขแแแแแก แฃแแแ แแแแแ แแแแแ (skillsโ (แแฎแกแแแแ แแฎแแ แคแแแฏแแ แแจแ) แแแแก แแแ แแ แแแแแแแแแ).
แแแ แฉแแแ App Server แแแจแแ, แ แแชแ แแกแฃแ แ แกแ แฃแแ Codex harness แแงแแก แฌแแ แแแแแแแแแ แ แแแแ แช แกแขแแแแแฃแ แ, UI-แกแแแแก แแแกแแฎแแ แฎแแแแแ แแแแแแแแแแก แแแแแแ. แแฅแแแ แแฆแแแ แ แแแแ แช agent loop-แแก แกแ แฃแ แคแฃแแฅแชแแแแแแก, แแกแ แกแฎแแ แแแแฎแแแ แ แจแแกแแซแแแแแแแแแกแแช, แ แแแแ แแชแแ Sign in with ChatGPT, แแแแแแแก แแฆแแแฉแแแ แแ แแแแคแแแฃแ แแชแแแก แแแ แแแ. แแแแแแ แ แคแแกแ แแแขแแแ แแชแแแก แกแแแฃแจแแแ, แ แแแแแ แแแแแแขแแก แแฎแแ แแก JSON-RPC binding แฃแแแ แแแฌแงแแ แแฅแแแแก แแแแจแ. แแ แแฅแขแแแแจแ แแ Codex-แก แจแแฃแซแแแ แแซแแแ แกแแแฃแจแแแก แแแแ แแแฌแแแแก แจแแกแ แฃแแแแ, แแฃ JSON schema-แก แแ แแแแฃแแแแขแแชแแแก แแแแฌแแแแ. แแแแ แแ แแฃแแแแ, แ แแแแแแแแแแช แแแแฃแจแแแแ, Codex-แแก แแแแแงแแแแแแ แกแฌแ แแคแแ แจแแซแแ แแฃแจแ แแแขแแแ แแชแแแก แจแแฅแแแ.
แแกแฃแแฃแฅแ, แกแแ แแแขแแ แแแแแ CLI แ แแแแแ แแ แแฏแแ แแแ แแแแชแแแแแแกแ แแ CI แแแจแแแแแแแกแแแแก. แแก แแแ แแ แแ แฉแแแแแแ แแแขแแแแขแแแแชแแแกแ แแ pipeline-แแแแกแแแแก, แ แแชแ แแกแฃแ แ แแ แแ แแ แซแแแแแ แแ แแแแขแแ แแฅแชแแฃแแแ แแแแแแแ แจแแกแ แฃแแแแก, แแฃแ แแแแแแแกแแแแก แแแแกแขแ แแแแก แกแขแ แฃแฅแขแฃแ แแ แแแฃแแ แแแแแแแแแแ แแ แแแกแ แฃแแแแก แฌแแ แแแขแแแแก แแ แฌแแ แฃแแแขแแแแแแแก แแแแคแแ แกแแแแแแแ.
TypeScript แแแแแแแแแแ, แ แแแแแแช แแฅแแแแ แกแแแฃแแแ แ แแแแแแแชแแแแแ แแแแแแแแ แแแ Codex แแแแแขแแแแก แแ แแแ แแแฃแแแ แกแแแแ แแแแแ แแแแแแงแแแแแ. แกแแฃแแแแแกแแ แแแจแแ, แ แแชแ แกแแ แแแ แแก แแฎแแ แแก แแแกแขแ แฃแแแแขแแแแกแ แแ แกแแแฃแจแแ แแ แแชแแกแแแแกแแแแก แแกแฃแ แ แแแขแแฃแ แ แแแแแแแแแแฃแ แ แแแขแแ แคแแแกแ แชแแแแ JSON-RPC แแแแแแขแแก แแแแแแก แแแ แแจแ. แ แแแแแ แแก App Server-แแ แแแ แ แแแแแแแแ, แแแแแแแ แแแแแแ แแแแกแ แแ แฃแคแ แ แแชแแ แ แแแแแแแ แก แฃแญแแ แก แแฎแแ แก. แแฃ แแแแแแแแแ แแแแก แแแขแแ แแกแ แแฅแแแแ, แจแแแซแแแแ แแแแแขแแแแแ SDK-แแแแช แแแแแแแขแแ, แ แแแแแแแช App Server-แแก แแ แแขแแแแแก แจแแแแแฎแแแแก, แ แแแ แแฃแแแแแแ harness-แแก แแแแแแแ แแก แแแขแ แแแฌแแแ แแแคแแ แแ JSON-RPC binding-แแแแก แแแฌแแ แแก แแแ แแจแ.
แแ แแแกแขแจแ แแแแแแแแ แแ, แ แแแแ แแฃแแแแแแ แแแแแขแแแแแ แฃแ แแแแ แแแแแก แแฎแแแ แกแขแแแแแ แขแแก แแแแแแแก แแ แ แแแแ แแแฅแชแแแ Codex harness-แก แกแขแแแแแฃแ , แแแแแแขแแกแแแแก แแแกแแฎแแ แฎแแแแ แแ แแขแแแแแแ. แแแแแแฎแแแแ, แ แแแแ แแฉแแแก App Server Codex core-แก, แ แแแแ แแซแแแแก แแแแแแขแแแก แกแ แฃแแ agent loop-แแก แแแ แแแแก แกแแจแฃแแแแแแก แแ แ แแแแ แแแแซแ แแแแแก แแ แแแแแคแแ แแแแ แแแแแแแ แแแก, แแแ แจแแ แแก TUI-แก, แแแแแแแแ แแ IDE แแแขแแแ แแชแแแแก แแ แแแ-แ แแแขแแแแก.
แแฃ แแแแ Codex-แแก แแฅแแแแก แกแแแฃแจแแ แแ แแชแแกแแแจแ แแแขแแแ แแชแแแก แแแแแแ แแแแแฉแแแแ, แฆแแ แก App Server-แแก แแแแแชแแ. แแแแแ แกแแฌแงแแกแ แแแแ แแแแแแแกแแแฃแแแ Codex CLI-แแก แฆแแ แแแแแก แ แแแแจแโ (แแฎแกแแแแ แแฎแแ แคแแแฏแแ แแจแ). แแแแแแแ แแแแแแแแแ แแ แแฅแแแแ แฃแแฃแแแแจแแ แ แแ แคแฃแแฅแชแแแแแก แแแแฎแแแแแแ. แแแแฎแแ แแ แแฅแแแแแแ แแแกแแแแ แแ แแแแแขแแแแก แงแแแแแกแแแแก แฃแคแ แ แฎแแแแแกแแฌแแแแแแ แฅแชแแแแก แแแแ แซแแแแแ.
แแแขแแ แ
แแแแแแแแแ
แแแแกแแแฃแแ แแแฃแแ แแแแแแแ Michael Bolin-แก, Owen Lin-แก, Eric Traut-แก แแ Rasmus Rygaard-แก, แ แแแแแแแแช แแ แแแกแขแจแ แฌแแแแแ แจแแแขแแแแก, แแ แแแแ Codex แแฃแแแก, แ แแแแแแแช App Server-แแ แแแฃแจแแแ.
แกแฅแแแแแแแ
- 1
แฉแแแ แแแงแแแแแ โJSONโRPC liteโ แแแ แแแแขแก: แแก แแแแ แฉแฃแแแแก แแแแฎแแแแแก/แแแกแฃแฎแแก/แจแแขแงแแแแแแแแก แคแแ แแแก, แแแแ แแ แขแแแแแก
"jsonrpc": "2.0"แกแแแแฃแ แก แแ strict JSONโRPC 2.0-แแก แแแชแแแแ stdio-แแ JSONL-แแ แแ แแก แฉแแ แฉแแแแจแ แแแฅแชแแฃแแ. - 2
ย โstdioโ แแฃแแแกแฎแแแแก app-server-แแก stdin/stdout-แก แแแแขแแแแแ แแก แจแแแแแ. แฐแแกแขแแ แแแฃแ แแแแแแแแแแแจแ แแก แแแแแแแแ แฎแจแแ แแ แแฃแแแแ แฅแกแแแฃแ แแแแจแแ แแแ แแแแ แแแแ แแแแแงแแแแแแ (แแแแแแแแแ, WebSocket-แแก แแกแแแแกแ แแแแ) แแแแขแแแแแ แแก แ แแแขแแแแแแแ โ แแแแขแแ แแก stdio-แกแแแแ แแฅแชแแแ, แแแจแแแแช แแ, แแฃ แแแ แแแแแ แ แแแแแแแแ แแแ pipe แแ แแ แแก.


