Open Responses API Guide (2026): What the AAIF Donation Means for Your Code

On October 22, 2026, the Agentic AI Foundation (AAIF), which lives under the Linux Foundation, took on four new projects: Open Responses from OpenAI, Agent Skills from Anthropic, OpenEnv from Hugging Face, and OpenSandbox from Alibaba. That brings the foundation to 10 projects. Most coverage will file this under governance. For developers it's more practical than that.

Open Responses is the one that touches your code. It's a vendor-neutral spec built on the OpenAI Responses API, and it exists so you can describe a request once and run it against more than one provider. If you've ever rewritten an agent loop because a second vendor encoded tool calls differently, you already know why that's worth caring about.

What Open Responses Actually Specifies

Three ideas carry the whole spec. First, items are the atomic unit of context. A message, a tool call, and a reasoning state are all items, and items work in both directions: you can send them as input or receive them as output. Second, streaming is modeled as semantic events such as response.output_text.delta and response.completed, not raw text chunks. Third, objects are state machines that sit in a finite set of states like in_progress, completed, or failed.

The transport rules are plain. Requests are JSON over HTTP. Streaming responses use text/event-stream and must end with a terminal event (response.completed, response.failed, or response.incomplete). The 2026-04-24 revision added an optional WebSocket mode on the same /v1/responses resource.

What the spec doesn't do matters just as much. It says nothing about how smart a model is, how fast it answers, or what it costs. It's a blueprint for the wire format, nothing more.

Why This Lands at the Right Time

OpenAI's own GPT-6.1 Sol page says it plainly: use the Responses API for tool calling, and Chat Completions is supported without tool calling. So if you're building agents on OpenAI's newest models, you're heading to /v1/responses whether you like the spec or not. Once you're there, the Open Responses schema is the same shape other providers are being invited to copy.

That's already happening. As of October 23, 2026, DeepSeek's pricing page lists Responses API support for both deepseek-flash (DeepSeek-V4.1-Flash-1017) and deepseek-v4-pro. Claude's native API is still the Messages API at /v1/messages, so a Claude route needs either an adapter or a gateway in front of it.

Current Pricing for Models You'd Point a Responses Client At

Three footnotes you shouldn't skip. GPT-6.1 Sol bills requests with more than 272,000 input tokens at 2x input and 1.5x output for the full request. DeepSeek doubles every rate during peak hours (01:00 to 04:00 and 06:00 to 10:00 UTC, Monday to Friday, excluding Chinese public holidays). Claude Sonnet 5.5 cache writes cost $2.50 per million tokens. Prices come from OpenAI's model page, Anthropic's Sonnet 5.5 announcement, and DeepSeek's pricing page as of October 23, 2026. To model your own traffic, plug these numbers into the API cost calculator.

A Portable Client in About 20 Lines

The trick is boring: keep the base URL, key, and model name out of your code. Then only handle events by type and ignore the ones you don't recognize. That second part is what keeps provider-specific extras from crashing your stream handler.

curl

curl "$LLM_BASE_URL/responses" \
  -H "Authorization: Bearer $LLM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "gpt-6.1-sol", "input": "Summarize this stack trace in two lines."}'

Python

import os
from openai import OpenAI

client = OpenAI(
    base_url=os.environ["LLM_BASE_URL"],   # e.g. https://api.openai.com/v1
    api_key=os.environ["LLM_API_KEY"],
)
MODEL = os.environ["LLM_MODEL"]

def stream_answer(prompt: str) -> str:
    parts = []
    stream = client.responses.create(model=MODEL, input=prompt, stream=True)
    for event in stream:
        if event.type == "response.output_text.delta":
            parts.append(event.delta)
        elif event.type == "response.failed":
            raise RuntimeError("provider reported response.failed")
        # unknown event types are ignored on purpose
    return "".join(parts)

Node.js

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: process.env.LLM_BASE_URL,
  apiKey: process.env.LLM_API_KEY,
});

const stream = await client.responses.create({
  model: process.env.LLM_MODEL,
  input: "Summarize this stack trace in two lines.",
  stream: true,
});

for await (const event of stream) {
  if (event.type === "response.output_text.delta") process.stdout.write(event.delta);
}

Before you point this at a gateway, check which routes it actually implements. A 404 on /v1/responses can mean a missing route or a bad model name, so log the error body. If you want one OpenAI-compatible base URL for GPT and Claude models, KissAPI exposes one at https://api.kissapi.ai/v1. Test your exact route and model in a staging call first, then switch the environment variables and nothing else.

Where Portability Still Breaks

I'd be lying if I said a shared schema solves migration. It solves the boring half. Prompt caching is a good example: OpenAI's Responses API takes a prompt_cache_options.ttl of "30m" or "12h", while Anthropic uses its own cache breakpoints with 5-minute and 1-hour writes. Reasoning controls differ too. GPT-6.1 Sol accepts reasoning.effort values of low, medium (default), high, xhigh, and max, and it rejects none and minimal. Your adapter has to absorb these differences. The spec won't.

The Other Half: Agent Skills

Open Responses standardizes how you talk to a model. Agent Skills standardizes what you hand an agent. Per Anthropic's October 22 post, a skill is a folder with a SKILL.md file plus any scripts or reference material it needs. Anthropic is donating the name, logo, GitHub organization, and the agentskills.io domain, and says engineers from Anthropic, Google, OpenAI, and others will maintain it as individuals.

Here's my honest take. Adoption numbers like 280 million installs are a supply-chain story as much as a success story. Skills ship scripts. Anthropic's proposed roadmap includes security guidance for people who write and install them, which tells you the problem is real. Until that lands, treat a third-party skill like any third-party dependency: read the scripts before you install it.

Five Rules for Portable Agent Code

1. Read base URL, API key, and model name from environment variables. Never hardcode a vendor.
2. Store conversation history as your own typed items, not SDK objects, so you can replay it against another provider.
3. Dispatch streaming on event.type and ignore unknown types.
4. Pin the spec version you test against and run the project's acceptance tests on any provider you add.
5. Re-price before every switch. Count a real prompt with the token counter, because tokenizers differ between vendors.

My recommendation: don't rewrite working Chat Completions code this week. Move the paths that call tools on GPT-6.1 Sol, since those have to move anyway, and build the adapter there. Everything else can wait for a reason.

Frequently Asked Questions

What is the Open Responses API specification?

Open Responses is an open-source specification for multi-provider LLM interfaces based on the OpenAI Responses API. It defines shared schemas for items, streaming events, and tool use. Its current version is dated 2026-04-24, and OpenAI donated it to the Agentic AI Foundation on October 22, 2026.

Do I have to migrate from Chat Completions to the Responses API?

Not for plain text chat. OpenAI's GPT-6.1 Sol documentation says Chat Completions is supported without tool calling. If your agent uses tool calling with GPT-6.1 Sol, the documentation says to use the Responses API at /v1/responses.

Does a shared spec make GPT-6.1 Sol and Claude Sonnet 5.5 interchangeable?

No. The spec standardizes request and response shapes, not model behavior. GPT-6.1 Sol and Claude Sonnet 5.5 both list at $2 per million input tokens and $10 per million output tokens, but caching controls, reasoning settings, and tool-calling behavior still differ, so test each model on your own prompts before routing traffic.