OpenAI gives its Open Responses API spec to the AAIF

OpenAI on October 22 handed Open Responses, its specification for a common LLM API, to the Agentic AI Foundation (AAIF). By our count, the schema it handed over defines one tool type, function. OpenAI’s own Responses API defines 18.
Open Responses is one of four projects joining the foundation, The New Stack reported. The other three are Anthropic’s Agent Skills, Hugging Face’s OpenEnv framework for agent environments, and OpenSandbox, which was created at Alibaba. The Linux Foundation’s announcement says the additions bring AAIF to 10 hosted projects. The six already there are MCP, A2A, AGENTS.md, goose, agentgateway and Agent Router. AAIF is part of the Linux Foundation and launched in December 2025 with MCP, goose and AGENTS.md as its first projects.
“Open Responses addresses another part of building agents by giving developers a shared format for working with models across endpoints that support it, so they have fewer provider-specific integrations to maintain,” an OpenAI spokesperson told The New Stack. The spokesperson added that Vercel AI Gateway and Databricks Model Serving already implement it, and that AAIF will give developers and providers a neutral place to keep developing the spec together.
What the spec actually defines
OpenAI announced Open Responses on January 15, and the case for it hasn’t changed since. Nearly every LLM provider offers the same building blocks, such as messages, tool calls and function calling, but each one represents them differently in its API. The spec’s repository builds everything out of items. An item is the smallest unit of a conversation: a message, a function_call, a reasoning state. Providers can also emit custom item types the spec doesn’t define. The spec is organised around an agentic loop, in which the model emits a tool call, gets the result and carries on. Streaming is described as semantic events rather than raw text deltas, so a client can parse any provider’s stream the same way.
The spec has had only two dated releases, on January 15 and April 24. We compared the April release with OpenAI’s current public OpenAPI. Open Responses defines 24 response.* type literals and OpenAI’s API defines 75, with 22 in both. The two that exist only in Open Responses are response.reasoning.delta and response.reasoning.done. OpenAI’s 75 also include some client and control literals, such as response.cancel and response.steer, so they aren’t all server events. The January release had 23 literals. The only addition since is response.create, which the client sends over WebSocket, so the server-side streaming vocabulary is still 23 events.
That is the number a user posting as _j gave in the OpenAI Developer Community thread the day after launch. The spec, _j wrote, “knocked down the streaming to 23 event types” and “imposes, embraces, and extends OpenAI’s limitations to ensure an uncompetitive surface if employed.”
The request body is trimmed in a similar way. The POST /responses endpoint takes 26 top-level parameters in Open Responses and 32 in OpenAI’s API, with 24 shared. The spec leaves out conversation, prompt, prompt_cache_options, prompt_cache_retention, user, moderation, context_management and access_programs. It adds two fields that OpenAI’s Responses endpoint doesn’t have: frequency_penalty and presence_penalty.
The tool gap is where the two APIs differ most. InfoQ described the spec as separating internal tools, which run on the provider’s infrastructure and can finish the loop in one round-trip, from external tools, where the provider pauses and the developer’s code returns the output. Only the external kind is in the schema. OpenAI’s API lists types such as web_search, file_search, code_interpreter, mcp, computer and image_generation, and none of them appears in the spec. Hosted tools are covered in the spec’s prose, which says that “implementers can expose their own hosted tools—distinct from standard function tools—by providing new capabilities directly within their Open Responses implementation.” The spec’s reasoning item lets each provider decide how much it discloses: raw reasoning, protected content or a summary.
The project is open about where it came from. Its contributor guide says the core schema files are copied from OpenAI’s API, and the charter’s mission statement describes a spec “built on the OpenAI Responses API.” InfoQ quoted commenter Rituj Pramanik’s reaction to the January launch: “Building an “open” standard on top of OpenAI’s API is slightly ironic, but practical.”
Who holds the votes
The New Stack wrote that a technical steering committee, made up at first of project maintainers, will handle technical decisions. The repository shows that process already under way. The Linux Foundation Projects technical charter was adopted on October 21, a day before the announcement. The initial voting members are the nine maintainers named in the contributor guide: two from OpenAI (Steve Coffey and Ji Huang), two from Hugging Face, and one each from Databricks, Amazon, Ollama, OpenRouter and Ramp.
Two clauses from the earlier governance text are gone. The old text named a “Lead Core Maintainer: Steve Coffey, OpenAI,” who was the “final technical decision-maker when consensus cannot be reached.” It also stated that “No single vendor may control a majority of Core Maintainer seats.” The adopted charter uses the standard Linux Foundation text, with decisions by majority vote and escalation to the foundation’s “Series Manager.”
Who supports it, and in what words
The New Stack’s list of supporters includes AWS (in Bedrock), Databricks, LM Studio, Ollama, Hugging Face, Nvidia, OpenRouter, Red Hat and Vercel, plus the open source projects vLLM and OGX, formerly Llama Stack. Anthropic is an AAIF member but still uses its own Messages API. Google offers developers its Interactions API. Anthropic’s format has spread too, helped in large part by Claude Code: DeepSeek, Moonshot, Z.ai, MiniMax and others expose Anthropic-compatible endpoints.
We checked what each vendor’s own documentation calls the feature. vLLM, OGX and Vercel AI Gateway name Open Responses explicitly. vLLM’s RFC says its implementation “aligns with the public Open Responses specification,” OGX’s README carries an “OpenResponses Conformance” badge, and Vercel’s docs have an “OpenResponses API” section. The docs pages we fetched for Ollama, LM Studio and AWS Bedrock refer only to OpenAI’s Responses API. Bedrock’s says that “Amazon Bedrock provides the OpenAI Responses API.” Ollama and LM Studio do appear as logos on openresponses.org, so this is about how the docs are worded and doesn’t show that they haven’t adopted the spec. The vLLM RFC also lists fields its server accepts beyond the spec: top_k, request_id and priority. We did not check OpenRouter, Databricks, Nvidia, Red Hat or Hugging Face.
Our analysis
What we checked
On October 23 we compared the spec’s April 24 release with OpenAI’s public OpenAPI, read the repository’s history and several vendors’ docs, and ran the spec’s compliance CLI on Bun 1.4.4 against a mock server we wrote.
The 23-event count a forum user gave in January still holds. The 30-second limit per request is real too, and it only fails the test that hits it. But passing the suite proves that responses have the right shape, and says little about how the server behaves. The New Stack also got two project names wrong: Hugging Face’s project is OpenEnv, not OpenEv, and the former Llama Stack is now OGX, not OGC.
- Our mock returned “Hello from mock.” for every prompt, and a hard-coded
function_callwhenever a request included tools. It passed 6 of 7 HTTP tests: basic text, streaming (9 events), system prompt, tool calling, image input and multi-turn. This was one run against a local mock. - We set the mock to never answer the compaction endpoint. That test failed at 30,001 ms with a timeout, and the other tests ran to completion. The deadline was added to the repository on October 15.
- The suite has 17 tests. Its validators check that output exists, that a
function_callitem is present and that events match their schemas, but they don’t check content. No test sends or validates a reasoning item, and the only tool any test exercises isfunction.
Up next
OpenAI’s monitoring audit yields a 61-page gap report
“Deep access to our infrastructure” is what OpenAI gave METR and Redwood Research for three weeks, and their 61-page report found gaps in its monitoring. Would you let outside auditors inside your systems, or only hand them reports?
Related stories
- OpenAI’s MCP Extensions put plugins in the ChatGPT sidebar
- Google donates gVisor, used by Anthropic and OpenAI, to CNCF
- OpenAI opens ChatGPT’s 1.2B weekly users to developers
- Codex harness goes managed in the new Agents API
- Two sample agents run code to drive browser and desktop
- WebMCP contest puts $35,000 behind agent-ready sites
Comments
No comments yet. Be the first.
Join the conversation
Sign in to leave a comment. It appears after moderation.

