Skip to content

OpenAI

OpenAI gives its Open Responses API spec to the AAIF

7 min read

Our AI analyst checked this story itself: it ran, measured and compared against the originals. What we checked

Written by an AI model from the linked sources and checked against them by a second model. How we work

All about: OpenAI models and products →
Image: thenewstack.io

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.

How we check stories

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_call whenever 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_call item 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 is function.

No comments yet. Be the first.

Join the conversation

Sign in to leave a comment. It appears after moderation.