# Coding-agent harnesses and their model API protocols — research notes

**Researcher:** harness-researcher (team task-2)
**Access date for all sources:** 2026-10-25 (Asia/Shanghai).
**Purpose:** source-backed input for a Chinese-language report on model API protocols for experienced LLM engineers building/operating coding-agent harnesses. This file is *notes*, not the final report.

**Method & confidence.** Facts were checked against official docs, repo source, release metadata, or npm/PyPI on 2026-10-25; raw fetches are cached under `research/sources/harness/`. Version pins: Codex CLI `rust-v0.164.0` (2026-10-23) [S6], Claude Code `2.1.310` / Agent SDK `0.3.310` [S11], Gemini CLI `v0.65.0` (2026-10-20) [S16], OpenCode `1.19.4`, Continue CLI `1.5.47`, Copilot CLI `1.0.103`, ADK `2.3.0`, Aider `0.86.2` [S38]. Closed products (Cursor, Amp, Warp, hosted Copilot, Factory, Antigravity backend) have non-observable wire protocols; claims are limited to their BYOK docs. "Default protocol" = protocol used with no special config; "native" = implemented by the harness, "via gateway/shim" = proxy translation.

## (a) Summary

The 2026 protocol landscape has two hard walls and a wide middle. The hard walls are **OpenAI Responses** and **Anthropic Messages**: OpenAI Codex CLI now accepts *only* `wire_api = "responses"` (its docs say current releases do not support `wire_api = "chat"` or any Chat-Completions-only endpoint) [S1][S2][S3], while Claude Code (and the Claude Agent SDK that wraps it) speaks only Anthropic Messages, Amazon Bedrock InvokeModel, or Vertex `rawPredict` — never OpenAI Chat Completions [S7][S8][S10]. Everything else lives in the middle: most open multi-provider harnesses (Cline, Kilo, OpenCode, Continue, Goose, Crush, Zed, OpenHands, SWE-agent, Aider) route each vendor to its *native* protocol through an abstraction layer (Vercel AI SDK, LiteLLM, or bespoke provider trait implementations), and offer an "OpenAI-compatible" escape hatch that is effectively Chat Completions. Which protocol a bare key gets therefore depends on the harness's abstraction stack: AI-SDK-based/OpenAI-first harnesses default OpenAI keys to Responses; older/LiteLLM-based tools still default to Chat Completions. Gemini is the exception in 2026: the **Interactions API became GA in June 2026** and Google says all new models/agentic features launch there first [S72], but harness support is thin (AI SDK `google.interactions()`, ADK opt-in flag, OpenCode route) — and Gemini CLI, the most popular Gemini harness, is still on `generateContent` and was replaced by the Google-account-locked Antigravity CLI in June 2026 [S12][S15][S17].

## (b) Main matrix

Legend: **R** = OpenAI Responses; **C** = OpenAI Chat Completions; **M** = Anthropic Messages; **G** = Gemini `generateContent`; **I** = Gemini Interactions. OSS = client-repo license (hosted backend separate). Evidence refs [S#] point to (e).

| # | Harness | Owner (2026) | OSS | Default protocol | Other protocols / support | Custom endpoint mechanism | Notes / evidence |
|---|---|---|---|---|---|---|---|
| 1 | **OpenAI Codex CLI** | OpenAI | Apache-2.0 | **R only** | Built-in Bedrock/Azure providers also use `wire_api="responses"`; `--oss` Ollama/LM Studio go through the same Responses-shaped config; no Chat Completions | `~/.codex/config.toml`: `model_providers.<id>` (`base_url`, `env_key`, `http_headers`, `auth.command`, `wire_api="responses"`), `openai_base_url`, `--oss/--local-provider` | `wire_api` accepts only `"responses"` (also default); `wire_api="chat"` unsupported; gateway needs `POST /v1/responses` + streaming/continuation; "a working Chat Completions … endpoint doesn't establish Responses compatibility" [S1–S4] |
| 2 | **Claude Code** | Anthropic | Proprietary (repo = issues/docs) | **M only** | Amazon Bedrock InvokeModel, Vertex `rawPredict`, Microsoft Foundry, Claude Platform on AWS — all Anthropic-format; no C/R | `ANTHROPIC_BASE_URL` + `ANTHROPIC_AUTH_TOKEN`/`ANTHROPIC_API_KEY`/`apiKeyHelper`; managed settings | Gateway "must expose at least one of the following API formats": Messages, Bedrock InvokeModel, Vertex rawPredict [S7][S8][S9] |
| 3 | **Claude Agent SDK** | Anthropic | MIT SDK wrapping proprietary runtime | **M** | Same three formats as Claude Code | `ANTHROPIC_BASE_URL`/token in SDK options; model/fallbackModel | Same protocol wall as Claude Code [S10][S11] |
| 4 | **Gemini CLI** | Google | Apache-2.0 | **G** (`generateContent` via `@google/genai`) | Vertex `generateContent`; Code Assist for Google-account auth; no OpenAI compat, no Interactions found | `GEMINI_API_KEY`, Vertex env vars/ADC, Code Assist login; `/model`, settings.json | Source `client.ts` calls `generateContent`; replaced by Antigravity CLI 2026-06-18; "not optimized for Gemini 4 Argon" [S12–S16] |
| 5 | **Antigravity CLI + SDK** | Google | CLI/App proprietary; Python SDK Apache-2.0 | Google-hosted backend (Gemini; partner Claude/GPT-OSS served by Google) | With `GEMINI_API_KEY`: "requests go directly to the Gemini API" (`modelProvider:"gemini"` is the only accepted value); SDK local models: LiteRT, or OpenAI-compatible via `LocalOpenAIAgentConfig` | No CLI base-URL/BYOK provider config; `~/.gemini/antigravity-cli/settings.json`; SDK `AgentConfig` classes | Gemini CLI successor for consumer tiers; Google-account lock; ToS forbids third-party use of the login; exact Gemini API flavor undocumented — **uncertain** [S17–S22] |
| 6 | **Cline** | Cline Bot Inc. | Apache-2.0 | Provider-native: OpenAI→**R**, Anthropic→**M**, Google→**G** | OpenAI-compatible→**C**; Bedrock/Vertex/Ollama; Codex and Claude Code subscription paths | Per-provider key + custom base URL; `openai-compatible` provider; `@cline/llms` accepts `baseUrl`/`headers` | Source: OpenAI vendor `provider.responses(modelId)`; Anthropic uses `@ai-sdk/anthropic`; Google uses `createGoogleGenerativeAI` [S23–S28] |
| 7 | **Roo Code** | Roo Code, Inc. | Apache-2.0; **repo archived, shut down 2026-05-15** | Historical: OpenAI **C** (`chat.completions`), Anthropic **M**, Gemini **G** | OpenAI-compatible **C** only; ChatGPT Plus/Pro OAuth provider separate; native tool calling only, no XML fallback | Provider settings; custom base URL for Anthropic; base URL for OpenAI-compatible | README shutdown notice; community fork ZooCode; protocol facts are historical [S29–S32] |
| 8 | **Kilo Code** | Kilo Org | MIT | Configurable; unknown endpoints default to **C** | Explicit **Provider API** selector: OpenAI Compatible (**C**, default), OpenAI Responses (**R**), Anthropic Messages (**M**); Gemini via Google AI Gemini API (**G**); AI-SDK package per protocol | Provider settings/`Providers` tab; custom OpenAI-compatible base URL; provider registration with `npm` protocol package | Docs: "Use OpenAI Responses for OpenAI and xAI… Anthropic Messages for Anthropic and MiniMax… OpenAI Compatible is the default for other OpenAI Chat Completions-compatible endpoints" [S33–S35] |
| 9 | **Aider** | Aider-AI (community) | Apache-2.0 | **C** via LiteLLM (`openai/` prefix) | Native per LiteLLM (Anthropic **M**, Gemini **G**, OpenRouter, etc.); changelog claims Responses-API model support (v0.85.0) but no first-class wire switch — delegated to LiteLLM | `OPENAI_API_BASE` + `OPENAI_API_KEY`; `--model provider/model`; `--api-key provider=key` | `litellm==1.82.3`; PyPI 0.86.2; last push 2026-05-22 — project quiet; Responses claim indirect/**version-dependent** [S36–S38] |
| 10 | **OpenHands** | OpenHands (ex All Hands AI) | MIT | **C**-first via LiteLLM | Native per LiteLLM (**M**, **G**, Bedrock, Azure, OpenRouter…); Agent SDK has Responses stream handling; ChatGPT subscription OAuth; ACP delegation to Claude Code/Codex/Gemini CLI | Model string + `Base URL`/key; LiteLLM proxy; local servers | "OpenHands can connect to any LLM supported by LiteLLM"; OpenAI = LiteLLM chat models/compatible endpoints; reasoning docs mention Responses API [S39–S41] |
| 11 | **SWE-agent** | SWE-agent team | MIT | **C**-first via LiteLLM | Native per LiteLLM (Anthropic **M**, Gemini **G**, Bedrock…) | YAML model config; LiteLLM `api_base`/env conventions; custom cost registry | Research benchmark harness; protocol is LiteLLM-mediated [S42] |
| 12 | **OpenCode** | Anomaly (formerly sst) | MIT | Provider-native via AI SDK + Models.dev (75+ providers): OpenAI provider exposes **R**+**C** routes, default Responses; Anthropic **M**; Google **G** or **I** | Explicit routes: openai-chat, openai-responses, openai-compatible-chat, anthropic-messages, gemini, google-interactions, vendor responses/messages (xAI, Alibaba, Meta, ZAI…) | `provider.<id>.options.baseURL`; custom provider declares `npm: "@ai-sdk/openai-compatible"`; `/connect` auth | Source: `routes = [OpenAIResponses.route, OpenAIChat.route]`, default factory `.responses(modelID)`; google: `routes = [Gemini.route, GoogleInteractions.route]` [S43–S45] |
| 13 | **Goose** | AAIF (donated by Block) | Apache-2.0 | Provider-specific: OpenAI **C**, Anthropic **M**, Gemini **G** | Codex/ChatGPT subscription + some Copilot/Databricks paths use **R**; Bedrock, Vertex, Azure, Databricks, LiteLLM, many OpenAI-compatible endpoints | `goose configure`; env vars `OPENAI_HOST`, `ANTHROPIC_HOST`, `LITELLM_HOST`, cloud credentials | Rust provider crates per vendor (`openai_compatible.rs`, `anthropic.rs`, `google.rs`); Responses in `chatgpt_codex.rs`/Copilot/Databricks v2; Z.AI doc shows separate Anthropic- vs OpenAI-compatible endpoints [S46–S48] |
| 14 | **Continue** | Continue | Apache-2.0 | Mostly **C**; OpenAI→**R** only for o-series/GPT-5+ ("minimal draft" in source) | Anthropic **M**, Gemini **G**, 40+ providers; OpenAI-compatible via `apiBase` | `config.yaml`: provider/model/apiKey/apiBase; Hub/CLI | Source OpenAI.ts gates Responses on `isOSeriesOrGpt5PlusModel`; Gemini.ts calls `:streamGenerateContent` [S49–S51] |
| 15 | **Crush** | Charmbracelet | FSL-1.1-MIT (source-available) | Via `charm.land/fantasy` provider types: `openai` (OpenAI routing; Responses-capable; ChatGPT OAuth = Responses), `openai-compat` (**C**), `anthropic` (**M**), `google` (**G**), plus ollama/azure/vertex/bedrock | Custom OpenAI-compatible (**C**) or Anthropic-compatible (**M**) providers | `crushrc`; `provider add <id> --type openai-compat --base-url …`; env vars (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `GEMINI_API_KEY`, `AZURE_OPENAI_*`, `VERTEXAI_*`) | README: "`openai` when proxying or routing requests through OpenAI, `openai-compat` for non-OpenAI providers"; OAuth transport targets `chatgpt.com/backend-api/codex/responses` [S52][S53] |
| 16 | **Zed Agent** | Zed Industries | Editor GPL-3.0; hosted AI proprietary | Hosted/provider-native; custom OpenAI-compatible models default to `openai_chat` (**C**) | Per-model `protocol`: `anthropic` (**M**), `openai_responses` (**R**), `openai_chat` (**C**), `google` (**G**); subscriptions (ChatGPT/Claude/Copilot), gateways, local models | Agent settings / `settings.json` `language_models.openai_compatible`/`anthropic_compatible`: `api_url`, `available_models`, `protocol`, `capabilities`, `custom_headers` | Docs: protocol enum default `"openai_chat"`; "If a model only works with the Responses API, set `capabilities.chat_completions` to `false`" [S54][S55] |
| 17 | **Amp** | Amp (Sourcegraph lineage; closed) | Proprietary | Native per connection; Amp-hosted default | API keys (Anthropic/Google/OpenAI/xAI/Meta), subscriptions (ChatGPT/SuperGrok/Copilot), cloud platforms (Bedrock/Vertex/Foundry), routers/gateways, Custom URL (OpenAI- or Anthropic-compatible); per-model routing | Settings → Model Routing; CLI `amp config model-providers`; model mappings | Connection types documented; per-connection wire protocol not public — **evidence limit** [S56][S57] |
| 18 | **Cursor** | Anysphere | Proprietary | Internal Cursor backend (all requests routed through Cursor servers) | BYOK keys: OpenAI/Anthropic/Google/Azure/Bedrock; OpenAI BYOK = "standard, non-reasoning chat models"; "Custom API keys only work with chat models" | Settings → API keys per provider; key forwarded to Cursor backend with each request, not persisted | Protocol not documented; Chat-Completions-class inference only — **evidence limit** [S58] |
| 19 | **GitHub Copilot CLI** | GitHub (Microsoft) | Proprietary (repo = README/issues; license "Other") | GitHub-hosted Copilot backend (internal) | BYOK types: `openai` = any Chat Completions-compatible endpoint (**C**, default), `azure`, `anthropic` (**M**); `COPILOT_PROVIDER_WIRE_API` selects protocol; local Ollama | Env vars: `COPILOT_PROVIDER_BASE_URL/TYPE/API_KEY/WIRE_API/MODEL_ID/WIRE_MODEL`, `COPILOT_MODEL` | BYOK shipped 2026-04-07, enterprise 2026-06-17; requires native tool calling + streaming [S59–S61] |
| 20 | **Warp Agent** | Warp | Proprietary | Warp-provided hosted inference | BYOK OpenAI/Anthropic/Google keys; custom OpenAI-compatible endpoint (**C**); ChatGPT subscription; SuperGrok; enterprise BYOLLM via Bedrock/Vertex | `/api-keys` in app/CLI; `--set-provider-api-key`; custom inference endpoint settings; team-managed keys | Protocols not documented per provider — **evidence limit** [S62] |
| 21 | **Factory Droid** | Factory | Proprietary | Configurable; BYOK requires explicit provider type | Four documented types: `anthropic` = **M** (`v1/messages`), `openai` = **R** ("required for newest models like GPT-5/GPT-5-Codex"), `generic-chat-completion-api` = **C**, `bedrock-converse` = Bedrock Converse | Custom model entries: `baseUrl`, `apiKey` (optional for keyless gateways), `provider`, `model`, `authMode` (`bearer` for Anthropic), Bedrock blocks | Rare closed harness publishing an explicit provider→API-format table; only Anthropic/OpenAI official APIs fully tested [S63][S64] |
| 22 | **OpenAI Agents SDK** | OpenAI | MIT | **R** (`OpenAIResponsesModel` is the recommended default) | **C** via `OpenAIChatCompletionsModel`/`set_default_openai_api("chat_completions")`; non-OpenAI via LiteLLM/Any-LLM/MultiProvider; Responses WebSocket transport | `set_default_openai_client(AsyncOpenAI(base_url=…))`, `set_default_openai_key`, per-agent model/ModelProvider | Docs recommend Responses; source `_config.py` toggles `use_responses_by_default`; `openai_provider.py` builds `OpenAIResponsesModel` [S65][S66] |
| 23 | **Google ADK** | Google | Apache-2.0 | **G** via `google-genai` `generateContent` | **I** opt-in via `Gemini(use_interactions_api=True)`; Claude connector; OpenAI/LiteLLM/Ollama/vLLM/Apigee connectors; model routing | Model string or `LiteLlm(model=…)`/`ApigeeLlm`; connector classes; Vertex env/ADC | Source: `use_interactions_api: bool = False`; docstring: "uses the interactions API … instead of the traditional generate_content API" [S67][S68] |
| 24 | **Vercel AI SDK** | Vercel | Apache-2.0 | Model abstraction: `@ai-sdk/openai` → **R** (`openai(modelId)`, AI SDK 5+); `@ai-sdk/anthropic` → **M**; `@ai-sdk/google` → **G** | `openai.chat()` → **C**; `google.interactions()` → **I**; `createOpenAICompatible()` → **C**; Azure defaults **R** (opt with `azure.chat()`); xAI defaults **R** in AI SDK 7 | `createOpenAI({baseURL,apiKey,headers})`, `createAnthropic`, `createGoogle`, `createOpenAICompatible`; gateway provider | "In AI SDK 5, the default OpenAI provider instance uses the Responses API…"; "Use `google(...)` for `:generateContent`… and `google.interactions(...)` for the new Interactions endpoint" [S69–S71] |

*Excluded for lack of public protocol evidence:* Devin, Kiro, Auggie, Pi, Hermes, Grok Build, Qwen Code / ZooCode (Gemini CLI / Roo forks; pipelines inherited but not individually verified here). The **Agent Client Protocol (ACP)** seen in OpenHands/Goose/Warp is an agent-to-editor/harness protocol, not a model API protocol — do not conflate it with R/M in the final report.


## (c) Protocol-centric view (answers to the six questions)

### Q1. Which harnesses *require* OpenAI Responses?
- **Hard requirement:** OpenAI **Codex CLI** — `wire_api = "responses"` is the only supported value; Chat Completions endpoints are explicitly unsupported [S1][S3], and its gateway guide says a working Chat Completions/Anthropic Messages endpoint does not establish Responses compatibility [S4].
- **Responses-default (escape hatch exists):** **Agents SDK** (`OpenAIResponsesModel`; `set_default_openai_api` switches) [S65][S66]; **AI SDK** `@ai-sdk/openai` since v5 (switch `openai.chat`) [S69]; **Cline** (`provider.responses`) [S27]; **OpenCode** OpenAI primary route [S44]; **Factory** `openai` type [S63]; **Kilo** "OpenAI Responses" [S34]; **Zed** `protocol: "openai_responses"` [S55].
- **Responses-for-a-subset:** **Continue** (o-series/GPT-5+) [S50]; **Goose** ChatGPT/Codex provider [S47]; **Crush** ChatGPT OAuth/Copilot [S53]; subscription paths in OpenHands/Roo/Cline — vendor backends, not api.openai.com.
- **Consequence:** an "OpenAI-compatible" endpoint that only implements `/chat/completions` is unusable for Codex CLI, and only partially usable for the responses-default tools above.

### Q2. Which require Anthropic Messages?
- **Hard requirement:** **Claude Code** and the **Claude Agent SDK** — the gateway compatibility guide lists exactly Anthropic Messages, Bedrock InvokeModel, and Vertex `rawPredict`; there is no OpenAI-format mode [S7][S8][S10]. A Chat-Completions-only endpoint cannot serve Claude Code without a translating gateway.
- **Messages-provider type:** **Factory Droid** `anthropic` type is `v1/messages` [S63]; **Zed** `protocol: "anthropic"`; **Kilo** "Anthropic Messages … for Anthropic and MiniMax models" [S34]; **Copilot CLI** BYOK `anthropic` type [S60]; **Crush** `anthropic`/Anthropic-compatible custom providers [S52]; plus every provider-native harness when you supply an Anthropic key (Cline, Continue, OpenCode, Goose, OpenHands/SWE-agent/Aider via LiteLLM).
- **Notable:** Messages is rarely consumed via a compat shim; Anthropic-compatible endpoints are spreading (Zed, Factory, Crush, Cline) because Claude Code pushed gateways to implement `/v1/messages` natively.

### Q3. Which can only consume Chat Completions / OpenAI-compatible endpoints?
Treat "only" as "for custom/self-hosted endpoints". The **Chat-Completions-only compatibility paths** are:
- **Aider** (`OPENAI_API_BASE` + `openai/<model>`) [S36]; **SWE-agent** and **OpenHands** custom/proxy endpoints (LiteLLM OpenAI-compatible) [S39][S42]; **Continue** `apiBase` [S49]; **Cline** `openai-compatible` provider [S24][S26]; **Kilo** "OpenAI Compatible" provider API (the default for unknown endpoints) [S34]; **Roo Code** "OpenAI Compatible" (historical) [S30]; **OpenCode** custom provider `npm: "@ai-sdk/openai-compatible"` [S43]; **Crush** `openai-compat` [S52]; **Zed** OpenAI-compatible provider defaulting to `openai_chat` [S55]; **GitHub Copilot CLI** BYOK `openai` type (default) [S60]; **Warp** custom OpenAI-compatible endpoint [S62]; **Amp** "Custom URL" OpenAI-compatible connection [S56]; **Goose** `OPENAI_HOST` [S46].
- Truly single-protocol chat harnesses are rare; Chat Completions is the universal fallback, not usually the only native protocol.

### Q4. Which support Gemini Interactions vs only `generateContent`?
- **Interactions-supported (explicit):** **Vercel AI SDK** (`google.interactions()`, `POST /v1beta/interactions`) [S70]; **Google ADK** (opt-in `use_interactions_api=True`) [S68]; **OpenCode** (a `google-interactions` protocol route alongside `gemini`) [S45]. Others are unverified.
- **`generateContent`-only (verified or strongly implied):** **Gemini CLI** (source calls `generateContent`; no Interactions usage in core found) [S15]; **Cline**, **Kilo**, **Roo** (historical), **Continue** (explicit `:streamGenerateContent`), **Goose**, **Crush**, **OpenHands/SWE-agent/Aider** (Gemini via LiteLLM/Google SDK), and the BYOK Gemini paths of **Cursor/Warp/Amp** are all `generateContent`-class. **Antigravity** is Google-hosted and reaches "the Gemini API" with a Gemini key, but Google does not document which Gemini API surface it uses — **uncertain** [S18].
- **Why it matters:** Google says Interactions is GA (June 2026) and all new models/tools/agentic features launch there first; `generateContent` is legacy but supported [S72], and v1beta had breaking changes (legacy schema removal 2026-06-08) [S73]. Harnesses without Interactions support will lag on new Gemini agentic features even though basic chat works.

### Q5. For multi-provider harnesses, what protocol is used with a bare OpenAI / Anthropic / Gemini key?
- **OpenAI key:** Responses in AI-SDK-based and OpenAI-first harnesses (Cline, OpenCode, Kilo's "OpenAI Responses" selection, Factory `openai`, Agents SDK, AI SDK default). Chat Completions in older/compat-oriented paths (Roo's OpenAI API-key provider source, Continue's default, Goose's OpenAI provider, LiteLLM-based Aider/OpenHands/SWE-agent). Codex assumes Responses regardless.
- **Anthropic key:** Messages almost universally (Claude Code hard; Cline, Continue, OpenCode, Goose, Kilo, Crush, Zed, Factory, Copilot BYOK, LiteLLM-based tools all use native Messages).
- **Gemini key:** `generateContent` almost universally (Gemini CLI, Cline, Kilo, Continue, Goose, Crush, providers inside Cursor/Warp/Amp), with Interactions only where the harness explicitly exposes it (AI SDK `google.interactions`, ADK flag, OpenCode route).
- **Rule of thumb:** a bare key gets the vendor-native protocol in mature multi-provider harnesses; non-native protocols appear only with an "OpenAI-/Anthropic-compatible" custom base URL or an internal API choice (Continue GPT-5 path, SDK defaults).

### Q6. Which harnesses are locked to one vendor vs gateway-friendly?
- **Vendor-locked / hard-wired:** **Codex CLI** (Responses only), **Claude Code + Agent SDK** (Anthropic/Bedrock/Vertex/Foundry formats only), **Antigravity CLI** (Google account/Gemini API; no BYOK base URL; ToS forbids third-party login use), **Gemini CLI** (Gemini API/Vertex/Code Assist only). Closed **Cursor/Amp/Warp/Copilot CLI** are vendor-hosted by default with limited BYOK.
- **Gateway-friendly:** **Cline, Kilo, OpenCode, Continue, Goose, Crush, Zed, OpenHands, SWE-agent, Aider, Factory (explicit types), Amp/Warp (custom URLs)** — all can point at a self-hosted gateway, though the *set of protocols the gateway must terminate* differs. The most gateway-flexible are those that expose a protocol switch (Zed's `protocol`, Kilo's Provider API, Factory's provider type, Copilot's `COPILOT_PROVIDER_WIRE_API`, Crush's types).
- **Native vs via gateway/shim:** Codex behind a proxy must terminate/proxy Responses natively, not translate to Chat Completions; Claude Code behind LiteLLM needs an inbound Anthropic Messages side, while other clients of that gateway can use chat/completions. "OpenAI-compatible" almost always means Chat Completions, not Responses — a distinction gateway docs often blur.

## (d) Key takeaways for choosing a harness/protocol

1. **Responses-only is now a real compatibility wall, not a preference.** Codex CLI's refusal of `wire_api = "chat"` [S1][S3] means any internal gateway/aggregator that only speaks Chat Completions cannot serve Codex. If you must support Codex, implement `/v1/responses` with streaming event fidelity and `previous_response_id` semantics [S4], or front it with an OpenAI Responses-native gateway.
2. **Anthropic Messages is the other wall, and it is more widely spoken than it was in 2025.** Claude Code/Agent SDK only speak Anthropic-format [S7], and closed harnesses (Factory, Copilot BYOK, Zed, Crush, Cline) now offer Anthropic-compatible custom endpoints. A serious gateway should expose both `/v1/messages` and `/v1/responses` natively rather than being a chat-completions-only translator.
3. **"Multi-provider" no longer implies "Chat Completions".** In 2026 the default for a bare OpenAI key is increasingly Responses (AI SDK 5+, Cline, OpenCode, Factory, Kilo option, Agents SDK); assuming chat/completions will silently lose reasoning, hosted tools, and state features. Conversely, older or LiteLLM-based harnesses (Aider, OpenHands, SWE-agent, Continue, Goose) will use Chat Completions for OpenAI by default even when the provider supports more.
4. **Gemini Interactions adoption is the most under-served area.** Only AI SDK, ADK (opt-in), and OpenCode expose it; Gemini CLI is `generateContent`-only and being superseded by Antigravity, which is Google-account-hosted with no BYOK base URL (only `GEMINI_API_KEY` → direct Gemini API) [S12][S17][S18][S72]. For Gemini-based agentic work in late 2026, choose harnesses with explicit Interactions support or plan to bridge via AI SDK/ADK.
5. **Subscription OAuth is now a de-facto protocol channel.** Codex, Goose, Crush, OpenHands, Cline, Roo (historically), Copilot CLI, Amp and Warp implement vendor subscription flows against semi-documented backends (e.g. `chatgpt.com/backend-api/codex/responses` in Crush [S53]; ChatGPT OAuth in Goose/OpenHands [S41][S47]). Cheapest way to run agent workloads, but version-fragile and ToS-governed — label it unsupported/experimental.
6. **Version churn is significant; pin versions and re-verify.** AI SDK majors flipped OpenAI defaults (4 → chat, 5+ → Responses) [S69] and xAI defaults in v7; Roo Code shut down 2026-05-15 [S29]; Aider's repo has been quiet since 2026-05 [S38]; Gemini CLI was replaced for consumer tiers on 2026-06-18 [S12]; Gemini Interactions had breaking changes in June 2026 [S73]. Protocol-support tables age in weeks.
7. **Distinguish native support from shim support.** LiteLLM-based tools (Aider, OpenHands, SWE-agent) "support" Anthropic/Gemini/OpenAI by translation; harness-controlled features (native tools, reasoning state, cache markers, Responses-only items) may be lost or emulated. "OpenAI-compatible" modes in Cline/Kilo/Roo/Continue/Crush/Zed/Warp/Amp are Chat-Completions shims by definition.
8. **Choose by the protocol you must terminate, then by UX.** OpenAI-only/codex-style loops → Codex CLI/Agents SDK/AI SDK. Anthropic-first with enterprise gateways → Claude Code/Agent SDK. Many vendors or self-hosted gateway → prefer an explicit protocol switch (Zed, Kilo, Factory, Copilot CLI, Crush, OpenCode) or an AI-SDK-based layer (Cline/OpenCode). Avoid closed harnesses when protocol observability matters (Cursor, Amp, Warp, hosted Copilot hide it).

## (e) Source index (all accessed 2026-10-25)

Raw doc/README/source caches are under `research/sources/harness/` (some parent caches under `research/sources/`). Versions via npm/PyPI/GitHub API on the same date.

- [S1] Codex config reference (wire_api): https://learn.chatgpt.com/docs/config-file/config-reference.md
- [S2] Codex advanced config / custom providers / OSS mode: https://learn.chatgpt.com/docs/config-file/config-advanced.md
- [S3] Codex models (Responses-only note): https://learn.chatgpt.com/docs/models.md
- [S4] Codex gateway compatibility: https://learn.chatgpt.com/docs/enterprise/gateway-compatibility.md
- [S5] openai/codex repo: https://github.com/openai/codex
- [S6] Codex release `rust-v0.164.0` (2026-10-23): https://github.com/openai/codex/releases
- [S7] Claude Code gateway compatibility guide: https://code.claude.com/docs/en/llm-gateway-protocol.md
- [S8] Connect Claude Code to an LLM gateway: https://code.claude.com/docs/en/llm-gateway-connect.md
- [S9] Claude Code model configuration: https://code.claude.com/docs/en/model-config.md
- [S10] Claude Agent SDK configuration: https://code.claude.com/docs/en/agent-sdk/configuration.md
- [S11] npm `@anthropic-ai/claude-code` 2.1.310; `@anthropic-ai/claude-agent-sdk` 0.3.310: https://www.npmjs.com/package/@anthropic-ai/claude-code
- [S12] Gemini CLI README (Antigravity replacement; Gemini 4 Argon note): https://github.com/google-gemini/gemini-cli
- [S13] Gemini CLI authentication: https://geminicli.com/docs/get-started/authentication/
- [S14] Gemini CLI model selection: https://geminicli.com/docs/cli/model/
- [S15] Gemini CLI source `packages/core/src/core/client.ts`: https://github.com/google-gemini/gemini-cli/blob/main/packages/core/src/core/client.ts
- [S16] Gemini CLI release `v0.65.0` (2026-10-20): https://github.com/google-gemini/gemini-cli/releases
- [S17] Antigravity docs index: https://antigravity.google/llms.txt
- [S18] Antigravity install/auth (GEMINI_API_KEY; `modelProvider:"gemini"`; "requests go directly to the Gemini API"): https://antigravity.google/docs/install
- [S19] Antigravity models: https://antigravity.google/docs/models
- [S20] Antigravity SDK local models (`LocalOpenAIAgentConfig`; LiteRT): https://antigravity.google/docs/sdk/local-models
- [S21] Antigravity FAQ (third-party login prohibited): https://antigravity.google/docs/faq
- [S22] Antigravity SDK connections README (local harness WebSocket+protobuf; `GeminiAPIEndpoint`): https://github.com/google-antigravity/antigravity-sdk-python
- [S23] Cline README: https://github.com/cline/cline
- [S24] Cline OpenAI provider docs: https://docs.cline.bot/provider-config/openai
- [S25] Cline Anthropic provider docs: https://docs.cline.bot/provider-config/anthropic
- [S26] Cline SDK model providers (`openai-compatible`, `baseUrl`): https://docs.cline.bot/sdk/model-providers
- [S27] Cline source `llms/src/providers/vendors/openai.ts` (`provider.responses`): https://github.com/cline/cline/blob/main/sdk/packages/llms/src/providers/vendors/openai.ts
- [S28] Cline source Anthropic/Google vendors: https://github.com/cline/cline/tree/main/sdk/packages/llms/src/providers/vendors
- [S29] Roo Code README (shutdown 2026-05-15; archived): https://github.com/RooCodeInc/Roo-Code
- [S30] Roo Code OpenAI-compatible docs (native tool calling only): https://roocodeinc.github.io/Roo-Code/providers/openai-compatible
- [S31] Roo Code OpenAI/Anthropic/Gemini provider docs: https://roocodeinc.github.io/Roo-Code/providers/openai
- [S32] Roo Code source `src/api/providers/openai.ts` (`chat.completions.create`): https://github.com/RooCodeInc/Roo-Code/blob/main/src/api/providers/openai.ts
- [S33] Kilo Code README (MIT): https://github.com/Kilo-Org/kilocode
- [S34] Kilo Code AI providers docs (Provider API selector; `@ai-sdk/*` mapping): https://kilocode.ai/docs/ai-providers
- [S35] Kilo Code Gemini provider docs: https://kilocode.ai/docs/ai-providers/gemini
- [S36] Aider — OpenAI compatible APIs: https://aider.chat/docs/llms/openai-compat.html
- [S37] Aider requirements (`litellm==1.82.3`): https://github.com/Aider-AI/aider/blob/main/requirements.txt
- [S38] Aider release history (v0.85.0 Responses-API models); PyPI 0.86.2: https://aider.chat/docs/llms.html ; https://pypi.org/project/aider-chat/
- [S39] OpenHands LLM overview / OpenAI provider (LiteLLM): https://docs.openhands.dev/openhands/usage/llms/llms ; https://docs.openhands.dev/openhands/usage/llms/openai-llms
- [S40] OpenHands Agent SDK reasoning (Responses API) and source: https://docs.openhands.dev/sdk/guides/llm-reasoning ; https://github.com/OpenHands/software-agent-sdk
- [S41] OpenHands LLM subscriptions (ChatGPT OAuth): https://docs.openhands.dev/sdk/guides/llm-subscriptions
- [S42] SWE-agent model configuration docs (LiteLLM): https://github.com/SWE-agent/SWE-agent/blob/main/docs/config/models.md
- [S43] OpenCode models/providers docs (AI SDK + Models.dev; `baseURL`; custom provider `npm`): https://opencode.ai/docs/providers
- [S44] OpenCode source `providers/openai.ts` (Responses+Chat routes): https://github.com/anomalyco/opencode/blob/dev/packages/ai/src/providers/openai.ts
- [S45] OpenCode source `providers/google.ts` (Gemini + GoogleInteractions routes): https://github.com/anomalyco/opencode/blob/dev/packages/ai/src/providers/google.ts
- [S46] Goose providers docs (`OPENAI_HOST`, `ANTHROPIC_HOST`, compatible endpoints): https://goose-docs.ai/docs/getting-started/providers
- [S47] Goose source providers (`chatgpt_codex.rs`; `goose-providers`): https://github.com/aaif-goose/goose/tree/main/crates/goose/src/providers
- [S48] Goose README (AAIF, Apache-2.0): https://github.com/aaif-goose/goose
- [S49] Continue model providers overview: https://docs.continue.dev/customize/model-providers/overview
- [S50] Continue source `core/llm/llms/OpenAI.ts` (chat + gated Responses): https://github.com/continuedev/continue/blob/main/core/llm/llms/OpenAI.ts
- [S51] Continue source `core/llm/llms/Gemini.ts` (`:streamGenerateContent`): https://github.com/continuedev/continue/blob/main/core/llm/llms/Gemini.ts
- [S52] Crush README (custom providers; `openai` vs `openai-compat`; FSL-1.1-MIT): https://github.com/charmbracelet/crush
- [S53] Crush source `internal/oauth/openai` (Responses for ChatGPT OAuth): https://github.com/charmbracelet/crush/tree/main/internal/oauth/openai
- [S54] Zed LLM providers docs: https://zed.dev/docs/ai/llm-providers
- [S55] Zed API access docs (`protocol` enum; `capabilities.chat_completions`): https://zed.dev/docs/ai/use-api-access
- [S56] Amp model routing docs (connection types; Custom URL compatible): https://ampcode.com/docs/markdown/customize/model-routing
- [S57] Amp docs index (page lastModified 2026-10-20): https://ampcode.com/llms.txt
- [S58] Cursor — bring your own API key: https://cursor.com/docs/settings/api-keys
- [S59] GitHub Copilot CLI README: https://github.com/github/copilot-cli
- [S60] Copilot CLI BYOK docs (provider types; `COPILOT_PROVIDER_WIRE_API`): https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/use-byok-models
- [S61] Copilot CLI BYOK changelogs (2026-04-07; 2026-06-17): https://github.blog/changelog/2026-04-07-copilot-cli-now-supports-byok-and-local-models/ ; https://github.blog/changelog/2026-06-17-copilot-cli-supports-enterprise-bring-your-own-key-byok-models/
- [S62] Warp agents docs bundle (BYOK; custom OpenAI-compatible endpoint; subscriptions): https://docs.warp.dev/_llms-txt/agents.txt
- [S63] Factory Droid BYOK docs (four provider types / API formats): https://docs.factory.com/model-independence/byok
- [S64] Factory available models: https://docs.factory.com/models
- [S65] OpenAI Agents SDK models docs: https://openai.github.io/openai-agents-python/models/
- [S66] OpenAI Agents SDK source `_config.py`/`openai_provider.py`: https://github.com/openai/openai-agents-python/tree/main/src/agents
- [S67] Google ADK models docs (Gemini/Claude/LiteLLM/OpenAI): https://adk.dev/agents/models/
- [S68] ADK source `google_llm.py` (`use_interactions_api=False`): https://github.com/google/adk-python/blob/main/src/google/adk/models/google_llm.py
- [S69] AI SDK OpenAI provider (Responses default since v5; `openai.chat`/`openai.responses`): https://ai-sdk.dev/providers/ai-sdk-providers/openai
- [S70] AI SDK Google provider (`google()` vs `google.interactions()`): https://ai-sdk.dev/providers/ai-sdk-providers/google
- [S71] AI SDK Azure (Responses default; `azure.chat()`) and xAI (Responses default in v7): https://ai-sdk.dev/providers/ai-sdk-providers/azure ; https://ai-sdk.dev/providers/ai-sdk-providers/xai
- [S72] Gemini Interactions API overview (GA June 2026; new features launch there): https://ai.google.dev/gemini-api/docs/interactions-overview
- [S73] Gemini Interactions breaking changes (legacy schema removal 2026-06-08): https://ai.google.dev/gemini-api/docs/interactions-breaking-changes-may-2026
- [S74] Repo license/activity metadata via GitHub API (2026-10-25), incl. Roo Code archived, Aider last push 2026-05-22, and OSS licenses cited in the matrix; npm/PyPI registry versions in the method note.