Changelog

This changelog covers public developer-docs and API-contract changes.

On this page 1 of 48

Entries summarize customer-visible documentation and compatibility updates for the paid beta public API. Private operational and deployment notes stay out of the public changelog.

2026-11-17#

  • The data retention summary is now version data-retention-2026-11-17, superseding data-retention-2026-11-15. Its new zero data retention section covers how the designation is turned on and off, what changes for your requests, what is still recorded, and how long short-lived state is kept.
  • New error codes for an API key with a zero data retention policy: zero_retention_not_supported (403), when the requested model does not support zero data retention yet; and not_available_for_data_retention (400), when the request asks for web search, another tool that runs outside the model, or a longer prompt-cache lifetime, with error.param naming the field.
  • eb1 orchestration on eb1-preview and eb1-frontier-preview now draws on two newer models, which replace their predecessors. Nothing changes in how you call either model: request and response formats, context windows, prices and the faster setting on eb1-frontier-preview are the same. The first request of a conversation that was in progress at the change may report no cached input tokens, because a prompt cache does not carry over to a newer model.

2026-11-14#

  • New: groups in the organization API, one for each of your own customers. POST /v1/organization/groups creates a group directly under your organization or inside another group, at most five levels deep, with an optional external_id that carries your own id for the customer. GET /v1/organization/groups lists groups, GET /v1/organization/groups/{group_id} returns one, and DELETE /v1/organization/groups/{group_id} archives one. Creating or registering a key accepts group_id, the key object shows it, and the key list filters by it; every request made with a key in a group is recorded against that group. New error codes: group_external_id_taken (409), group_limit_reached (409) and group_not_empty (409). An organization holds at most 10,000 active groups.

2026-11-12#

  • A streamed tool call whose arguments are larger than 1 MiB, such as a large file write, now streams to the end on every format. The stream used to stop with an internal_error event, while the same request without streaming returned the call.
  • On /v1/messages, an assistant thinking block replayed with "signature": null is now accepted as unsigned, as an empty signature already was. It used to return 400. See Messages.
  • JSON mode (response_format: {"type": "json_object"} on Chat Completions, text.format: {"type": "json_object"} on Responses) is now served when the model serving the request has it. It used to be refused with 409 on every model. When the model serving the request has no JSON mode, the request is still refused with 409 capability_conflict, now naming your field in error.param and json_mode_not_supported in details.lossiness; send a json_schema format instead. See Structured output conflicts.
  • New: the organization API manages your organization's API keys with an admin key. GET /v1/organization/api_keys lists keys, POST /v1/organization/api_keys creates one, POST /v1/organization/api_keys/register registers a key you already hold, and DELETE /v1/organization/api_keys/{api_key_id} revokes one. Admin keys are issued by support and call only these endpoints; a regular key calling them gets 403 with code admin_key_required, and an admin key calling a model gets 403 with code admin_key_route_forbidden. Registering a secret already registered and active in your organization returns 200 with that key, so a retry is safe; a 503 with code api_key_not_yet_active means the key is saved and starts working on its own. New error codes: api_key_already_registered (400), api_key_limit_reached (409), last_admin_key (409), key_change_limit_reached (429) and api_key_not_yet_active (503). An organization holds at most 500 active keys, counting keys created in the console, and makes at most 60 key changes a minute through the organization API.

2026-11-11#

  • During a silent stretch of a Messages stream while a text, tool_use or thinking block is open, each ping is now followed by an empty delta of that block's own kind (text_delta, input_json_delta or thinking_delta), the first within about 12 seconds of the last event and then about every 8 seconds. Claude Code abandoned such a stream about 10 minutes into the silence, because its stall timer stops counting ping events after 30 in a row, and sent the turn again without streaming. The delta adds nothing to the block, and the ping still arrives as before. See Silence while the model thinks.
  • A Messages stream that is silent before its first content block, on a request whose thinking.type is enabled or adaptive, now carries an empty thinking block at index 0: it opens at the first silent tick, about 8 seconds after message_start, gets an empty thinking_delta after each ping, and closes before the first text or tool_use block, which now starts at index 1. This applies to any wait of more than about 8 seconds for the first block, not only a long think, so a streamed answer can be at index 0 or 1 depending on latency: find it by block type, not by position. If the model's own thinking follows, it continues in that block. Claude Code counted only ping in that wait and abandoned a turn silent for about 10 minutes. Requests without thinking get ping events only, as before. See Silence while the model thinks.
  • user on /v1/chat/completions and /v1/responses now accepts any string. An empty string or one with leading or trailing spaces used to be refused with a 400. Responses echo the value as sent.
  • A request field Keiro does not accept now gets 400 invalid_request_error with error.param naming the field, on every format and in both modes. It used to get 409 capability_conflict. That 409 already carried x-should-retry: false, so only clients that ignore that header retried it. Fields Keiro holds back on purpose still get the 409: on /v1/messages service_tier, container and betas, and on /v1/responses prompt, context_management, access_programs and moderation. An integer seed on /v1/chat/completions is now accepted and ignored instead of refused. See Unsupported request fields.
  • On /v1/messages, every thinking block now carries signature, as the native API's do: the reasoning summary is unsigned, so its signature is "", in non-streaming responses and in the stream's content_block_start. The Anthropic SDKs' strict response validation no longer rejects these replies, and a client that replays the block unchanged is accepted. See Messages.
  • When an upstream dependency fails and says when to retry, the upstream_server_error (502, or 500 when the upstream answered 500) now carries that interval as Retry-After and retry-after-ms, and a stream's error event carries it as retry_after_seconds, on every format. It used to carry none, so SDKs retried after their own short backoff. An interval longer than a day is not passed on.
  • An upstream rate limit's retry interval now keeps its precision: 1.9 seconds is no longer rounded down to 1, a retry-after-ms interval is honoured, and a half-second interval is no longer stretched to 60 seconds. See Rate and spend limits.
  • POST /v1/v1/chat/completions, POST /v1/v1/responses and POST /v1/chat/completions/ (a doubled /v1 in the base URL, or a trailing slash) now return 404 with code not_found whatever the API key, so a misconfigured base URL reads as a wrong path. A method other than POST on /v1/messages now returns 405 with code method_not_allowed and Allow: POST, whatever the API key. Before, a missing or invalid key got 401 on all of these. Every other request with a missing or invalid key still returns 401. See Errors.
  • A stop sequence (stop on Chat Completions and Responses, stop_sequences on Messages) now ends the turn at the match on every model. On some models the reply used to stop showing text at the match but could still end with a tool call the model made after it, reported as finish_reason: "tool_calls" or stop_reason: "tool_use". Now nothing after the match is returned: no tool call, reasoning or search item, and the turn ends with finish_reason: "stop", stop_reason: "stop_sequence" with the matched stop_sequence, or a completed Responses turn. A tool call made before the match still ends the turn as a tool call, and a stop sequence that a tool call splits in two does not match; streaming and non-streaming requests now agree on both. If your agent sends a general stop sequence such as "\n\n" together with tools, expect a text-only turn where it used to get a tool call after that text. On eb1 requests, output tokens count the reply you receive, so a tool call dropped this way is no longer counted. On direct model requests, output tokens are the model's own count and still include what it wrote after the match, as before.
  • context_length_exceeded (on Messages, a message starting prompt is too long) now means only that the request's input is longer than the model's context window. An error whose description only mentioned a context window used to arrive as that 400, which made coding agents compact the conversation. On every format it now arrives as what it is: a server error keeps its status and retry signal, and a rejection of something else in the request is an invalid_request_error.
  • Two errors that a client retry does not fix no longer ask for one. An upstream_auth_error (502) is the platform's to fix: the platform now takes the refused upstream credential out of service itself, and the error carries "retryable": false and x-should-retry: false, on every format, and a stream's error event says "retryable": false; SDKs used to retry it. A per-request token-budget or per-request spend-cap 429 no longer carries Retry-After, as announced; it keeps x-should-retry: false and "retryable": false. See Errors and Deterministic denials.
  • On Responses, the response.failed event that ends a failed stream now carries in response.output the items the stream had already finished (each one sent before in a response.output_item.done event), in order. It used to carry an empty output. An item still open at the failure is not included. See Handle in-band errors.
  • A non-streaming request that had already received its 200 (after 30 seconds of work) and then failed in a way a retry may fix, such as an upstream fault, a stalled model call or a gateway restart, returned an error JSON body under the 200. The OpenAI and Anthropic SDKs read that body as a reply with empty fields and did not retry. The connection now closes before the body is complete, so your client raises a connection error and the OpenAI and Anthropic Python SDKs retry the request. A failure a retry cannot fix still arrives as the same error body under the 200. See Long non-streaming requests.

2026-11-10#

  • During a silent stretch of a stream, Chat Completions and Responses now send an event a client's stall timer counts on every keepalive tick, the first within about 12 seconds of the last output and then about every 8 seconds, each right after the : keepalive comment, which still arrives as before. See Silence while the model thinks. - Chat Completions: the chunk with one space in delta.reasoning_content now comes in every phase of the stream, not only before the first output; it used to carry an empty delta after output had started. - Responses: after the first output item, the event is keepalive; that stretch used to carry comments only. A client that turns on the OpenAI SDK's strict response validation, which is off by default, rejects it. - Messages is unchanged.

2026-11-09#

  • Some prompt content was left out of input_tokens (prompt_tokens on Chat Completions), so it was not billed and did not count toward rate limits or the model's input window. It now counts as text, like the rest of the prompt. See Usage and billing. - On /v1/responses: tool calls and tool results in every accepted spelling. That covers tool_use and tool_result blocks, whether nested in a message or sent as items; shell_call commands and shell_call_output stdout and stderr; tool_search_call arguments and the tool definitions in tool_search_output; function_call arguments sent as a JSON object; assistant thinking parts; and plain strings in the input array. - On /v1/messages: thinking blocks you send back in assistant turns. A thinking block that eb1 returned beside its sealed redacted_thinking block still counts once, through the sealed block. - On /v1/responses and Chat Completions: assistant refusals you send back. Requests whose history carries this content now report and bill more input tokens, and a very large one can reach a rate limit or the input window where it did not before. Newly counted content also goes through the check the rest of the prompt already had: text with one unbroken run of 524,288 or more characters that cannot be split into tokens (for example one character repeated, or one very long word) is refused with status 400, type and code invalid_request_error, not retryable. Such a request was admitted before when the run sat only in the newly counted content. Tool output in the shapes that were already counted, such as function_call_output, has always been checked this way.
  • A replayed reasoning item that carries a content list was counted twice, as text and as encrypted reasoning. It now counts once, so these requests report and bill fewer input tokens.

2026-11-07#

  • The Keiro Python client no longer treats a cut or failed stream as success, and every outcome names the gateway request id. Changes reach you with the next keiro release: - A stream that ends before its final event ([DONE], or response.completed/response.incomplete on Responses) raises KeirError with code stream_truncated. Before, it returned as if complete, and chat(stream=True) built a full-looking answer. The client doesn't retry it, because the gateway already accepted the request. - A response.failed event raises the failure's own code, before or after the first text. Before, it was reported as a protocol error, or passed through as an ordinary event. - request_id is on every reply (response.request_id, from Client and from keiro.models), on every Client stream (chat_stream() and responses_stream() now return a GatewayStream that iterates as before), and on every KeirError raised for a response. It is the response's X-Request-Id, except that a stream error event's own id wins. An error raised before any response arrives has request_id=None. - chat(stream=True) keeps the completion id and finish_reason. - Client.batch(raise_on_error=False) puts each failure's exception in its slot instead of None.
  • When an upstream provider keeps failing, Keiro pauses requests to it for a short cooldown. A request refused during that pause now gets 503 provider_unavailable, with the time left in the cooldown as Retry-After (or retry_after_seconds in a stream's error event). Before, it got 429 rate_limit_exceeded with a one-second retry hint and a message saying Keiro had retried, though nothing had been sent. A pause now covers only the models that share the failing provider limit, and a failing BYOK key pauses only that key. A pause for an exhausted quota or credit balance answers as that quota did: 429 insufficient_quota, not retryable, with no Retry-After.
  • A daily or monthly spend-cap refusal now says why, and is final only when the money already spent leaves this request no room: - Spend has reached the cap, or what is left is less than this request's estimated cost. The 429 carries x-should-retry: false and "retryable": false, and no Retry-After or retry-after-ms header. Before, its Retry-After ran to the end of the UTC day or month, and some clients slept that long. The reset time moves to the new error.details.resets_at (an RFC 3339 UTC timestamp) and the message. - Requests already running hold the rest of the cap. The 429 stays retriable, now with a 5-second horizon instead of one running to the end of the period. Clients that read Retry-After on a final refusal to schedule work should read details.resets_at instead. When both a daily and a monthly cap refuse, a final monthly refusal is reported first, since its reset comes last; a cap held by running requests never hides a final one. The messages name the next step: wait for the reset, lower the output token limit (max_tokens, or max_output_tokens on Responses), or contact support to raise your organization's cap. A cap set on an API key is named as that key's, checked against your organization's spend. A prepaid balance short of a request's estimate is named as such, with how to add credit. OpenAI-compatible SDKs stop at once on a final refusal; installed Keiro Python clients give up after a few seconds of short backoff, and the next release raises keiro.SpendCapError at once. Codes, types, statuses and details.dimension are unchanged. See Rate and spend limits.
  • Spend-limit 429s no longer carry error.details.estimate or a cost figure in the message. The figure was an internal estimate, not the price of the request; the per-request spend cap denial carried it before today. Token-limit denials keep details.estimate, which is a token count. See Errors.
  • A PDF input that needs more processing than Keiro allows now returns 400 with code pdf_too_complex, which says so. Previously it returned a retryable 503 that failed the same way on every retry. Reduce the file's page count or complexity, or split it. See Errors.
  • Rate-limit and capacity 429s now say whose limit it was. A requests-per-minute, tokens-per-minute or concurrency denial names your organization's limit or the API key's own limit, and details.binding_scope is now present on request and concurrency denials too. A key's own limit counts requests from every key in your organization, and the message says so. Platform load, shared capacity and an upstream 429 say they are not a limit on your organization or API key; before, the last two read "Rate limit exceeded." like your own limits. Codes, types, statuses and headers are unchanged. See Rate and spend limits.
  • The beta plan's limits are now published in a new Invite plans table: the requests, tokens and concurrent requests a beta organization gets for each public model, and its spend caps (no daily cap, $5,000 a month, $240 per request). Benchmark and Enterprise plans are set per organization. The console and the response headers stay authoritative, and per-model limits follow platform capacity, so they can change. Enterprise plan rate limits are now at least the beta plan's for every public model. See Invite plans.
  • A Responses stream that fails after response.created now ends with the standard response.failed event right after response.error, carrying the same error. Clients that read only the standard terminal events, such as Codex, now show Keiro's message instead of reporting that the stream closed early. See Handle in-band errors.
  • Messages stream error events now use the same Anthropic error.type as the non-streaming error body for the same failure, for example overloaded_error when the service restarts mid-stream and timeout_error when a request stops making progress. Previously these frames said server_error. A 504 on Messages, streaming or not, now reads timeout_error instead of api_error, and a cancelled Messages stream's error event carries code: "cancelled" with type api_error.
  • An exhausted upstream quota now answers 429 with code: "insufficient_quota" and retryable: false, streaming or not, as Errors describes. Most models answered a retryable 429 rate_limit_exceeded instead, which told a client to retry a request that could not succeed until the quota was restored.

2026-11-06#

  • A streaming /v1/messages request where the model called a tool with no arguments could end in internal_error after the call. It now arrives as a tool_use block with {} as its input.
  • On a streaming Chat Completions request, a tool call whose arguments arrived only with the final response now gets them in a tool_calls chunk before the one with finish_reason. Before, the call could end with no arguments at all.
  • When a client closes a stream, Keiro now stops the model call right away, on every surface and most model paths. Previously a call that was silent at that moment could run on to its end. What you are billed is unchanged. See Stream lifetime.
  • Streaming now describes what a client receives while the model thinks, why an idle timer shorter than that thinking ends the request, and how to set one.
  • A request the model declines now costs nothing if no text reached you, on every endpoint, streaming or not. Some streaming requests with tools used to bill the declined attempt. A request that ran hosted web search first still bills that work. See Usage and billing.
  • A request body that is still arriving is no longer cut off. Keiro now refuses a body with 408 request_body_timeout only when none of it arrives for 60 seconds; before, a body that took longer than 60 seconds in total to upload got the 408 even while it was still arriving, and failed the same way on every retry. An organization can upload at most its concurrency limit of request bodies at once; one more gets the usual concurrency 429 before Keiro reads it.
  • The faster setting on eb1-frontier-preview is now available on beta accounts: "service_tier": "ultrafast" on Responses and Chat Completions, and "speed": "fast" on Messages. See Chat Completions.
  • While a model works silently on a streaming Chat Completions request, before its first text or tool call, the idle chunk Keiro writes about every 16 seconds (at most about 24) now carries one space in choices[0].delta.reasoning_content instead of an empty delta. A client whose stall timer ignores empty deltas now sees progress during a long think. Keiro writes this value, not the model, and it is not a readable status. It is not billed, stays out of delta.content, and is dropped if a client sends it back as reasoning_content on a saved message. Some clients show it as an empty reasoning block. A timer that trims whitespace, or that counts only content or tool_calls, does not count it, and once text or a tool call has started these chunks keep an empty delta. See Streaming.
  • A model refusal that ends a request as an error no longer asks you to retry. It keeps code upstream_error, type api_error and status 502 (or a stream error frame after 200), but now carries retryable: false, x-should-retry: false on non-streaming requests, and the message The model declined this request. Rephrasing or changing it may help; sending it again unchanged is likely to get the same result. Previously it read as a retryable upstream failure. This applies to direct model requests, and to eb1 requests when Keiro can't handle the refusal itself.
  • A non-streaming eb1 request with no tools, whose model thought and then declined, now gets the same handling as its streaming equivalent. It used to return a retryable 502. See Model refusals.
  • A streaming eb1 request whose model started a tool call and then declined now ends with the refusal terminal described in Model refusals. It used to continue with text from another attempt after the call had started, then end with a retryable error. When no text was delivered before the refusal, it isn't billed.

2026-11-05#

  • eb1-frontier-preview now offers opt-in ultra requests. Send reasoning effort ultra (reasoning.effort on Responses, reasoning_effort on Chat Completions, output_config.effort on Messages) to have eb1 orchestration use more models and deeper reasoning on a request. It is available on paid self-serve plans and on alpha, beta and enterprise accounts. These requests cost more and can take many minutes. The new x-keiro-reasoning-mode response header reports the mode the request ran in. Effort max, requests without an effort, and other models are unchanged. See Responses.
  • A tool call cut off by the output limit or a content filter now ends as that stop instead of an error. Some streaming /v1/responses requests previously ended in an internal_error event; they now end in response.incomplete, with the unfinished call closed status: "incomplete". Chat Completions reports finish_reason length or content_filter, where it could previously report tool_calls or return an error. An unfinished call has nothing to run, so clients should not execute it.

2026-11-03#

  • When eb1 model selection does not finish in time, the response is now 503 server_error with the new code route_timeout and the message "Model selection timed out. Retry the request." It is retriable and carries a Retry-After horizon. These failures previously returned route_capacity with capacity wording, though no capacity limit was involved. No other model is substituted, as before. route_capacity now means only that the platform is at capacity. Clients that retry route_capacity should retry route_timeout the same way. See Errors.
  • Some non-streaming eb1 responses that contained both text and a tool call counted only the tool call in output_tokens (completion_tokens on Chat Completions), so they reported fewer output tokens than the same answer streamed. They now count and bill the text too, on Responses, Chat Completions and Messages. Streaming requests are unchanged. See Usage and billing.
  • Some streamed eb1 responses on Messages and Chat Completions whose output began with a tool call reported zero output tokens even though the call was delivered, and the call was not billed. They now count and bill the tool call's arguments.
  • Some non-streaming eb1 responses that contain both text and a tool call now return the text on Responses, as an assistant message item ahead of the call, and on Messages, as a text block ahead of the tool_use block. Those surfaces used to drop it; streaming and Chat Completions already returned it.

2026-10-30#

  • Fewer requests to eb1 models end in a partial answer or an error after a safety decline. When a non-streaming request is declined after output has begun, the platform discards that partial output and makes one further attempt, returning that answer as the response. Only the returned answer is billed. When a provider rejects a request's content on an eb1 model, the caller now receives the safety-refusal response with zero usage instead of an HTTP 400 or a stream error. A streaming request declined after its output has started is unchanged, and requests to a named model keep their rejection.

2026-10-29#

  • A request whose body is sent compressed, with a Content-Encoding header such as gzip, now returns 415 unsupported_media_type. Send request bodies uncompressed; Content-Encoding: identity is accepted. On the Messages endpoint, 415 errors now carry the invalid_request_error type instead of api_error. See Errors.

2026-10-27#

  • On eb1 models, reasoning effort none no longer caps reasoning at low. Like ultra, it sets no cap: eb1 chooses the depth on its own, as it does for a request without an effort, and none does not turn reasoning off. Codex sends none on every request, so Codex sessions on eb1 models now reason at the depth eb1 chooses. Some eb1-fast-preview requests with none or ultra failed with the retryable 502 upstream_error; they now succeed. See Models.
  • On other models, an effort value outside a model's effort vocabulary, such as ultra on a model whose efforts stop at max, now returns 400 invalid_request_error with param reasoning.effort instead of a retryable 500 internal_error. A supported value above the model's ceiling already returned this 400.

2026-10-26#

  • A model edit that fails the gateway's patch verification now returns the new retryable model_tool_call_invalid error (502, api_error) instead of upstream_error. Retrying samples a new edit. See Errors.

2026-10-10#

  • A run is now cancelled for lack of upstream progress after 10 minutes of complete silence, up from 5. Long silent reasoning between 5 and 10 minutes no longer ends with the retryable gateway_timeout error. See Streaming.

2026-10-09#

  • Context-overflow errors (context_length_exceeded) now name the largest item in the request and its approximate size, for example The largest input item is tool output call_8f2k, about 735K tokens, and say when a large share of that item is undecodable bytes (U+FFFD), which usually means a binary file was read as text. The same facts are in details.largest_input_item. This applies on Responses, Chat Completions and Messages, including streams; on Messages the sentence follows prompt is too long: {N} tokens > {M} maximum. See Errors.

2026-10-07#

  • A request now lives as long as the model keeps working. The per-effort wall-clock ceilings and idle windows are retired: no clock ends a stream or a non-streaming request while the model is still producing work, including long silent reasoning. A run ends early only when the model sends nothing for 5 minutes (the retryable gateway_timeout error, as an error frame on streams) or when your client disconnects, which now cancels the in-flight model calls on every endpoint. Streams no longer end with the stream_idle_timeout or stream_ceiling_timeout incomplete terminals. See Streaming.
  • A non-streaming request whose reply is not ready after 30 seconds now receives its 200 status and headers immediately, then one space every 15 seconds, then the JSON body, so client read timeouts that bound silence keep reading. A failure after that point arrives as the endpoint's error JSON body under the 200. Requests that finish within 30 seconds are unchanged. See Streaming.
  • New retryable error code gateway_restarting (503, short Retry-After): a service restart that ends a request after its reply began closes the reply with this error, in-band in the JSON body or as an error frame on a stream, instead of cutting it off. Retry the request. See Errors.
  • On eb1 models, a request's reasoning effort is now a ceiling: eb1 never reasons above it. Previously eb1's own choice could replace a lower requested effort. reasoning.effort on Responses, reasoning_effort on Chat Completions, and output_config.effort on Messages all apply; none and minimal cap at low, and ultra sets no cap. Requests without an effort are unchanged. See Models.
  • A request whose strict schemas exceed what the model accepts per request (too many strict tools, optional parameters or union-typed parameters across its strict tools and output format) now returns 400 with code strict_schema_too_complex and guidance to reduce them or send the tools without strict, on Responses, Chat Completions and Messages, including streams. It previously returned invalid_request with a generic message. The request is not retried.

2026-10-06#

  • Codex model limits now refresh from the gateway catalog instead of an install-time file. Setup migrates the managed Keiro profile to live discovery; older installs need one setup rerun and Codex 0.160.1 or newer. Updated Claude Code and OpenCode launchers resolve context windows before every launch. Pi's provider extension discovers limits at startup and on model refresh. Generated configuration previews remain review examples, not permanent client limits.
  • An upstream error relayed mid-stream now carries retryable in the nested error object on Responses, Messages and Chat Completions streams, like every other stream error frame. Upstream rate limits, overload, and upstream server errors and timeouts are retryable: true, matching the retryable 429 and 5xx the same failure returns without streaming. Invalid requests, context-length and content-policy rejections, authentication and permission failures, missing models, exhausted quota, and unrecognized upstream errors are retryable: false, and their message no longer advises a retry. On Chat Completions, read the nested retryable rather than the provider_error code's default.
  • The same rules now apply when an upstream error arrives while the platform reads an upstream response in full, including for non-streamed requests. Invalid requests and context-length or content-policy rejections return 400, and exhausted quota returns the non-retryable 429 insufficient_quota. Authentication, permission, missing-model and unrecognized upstream errors keep 502 upstream_error but now carry retryable: false and x-should-retry: false, with no Retry-After. Upstream rate limits, overload, and server errors stay retryable.

2026-10-05#

  • On /v1/responses, requests to models outside the eb1 family now report usage in the standard Responses shape that eb1 models already use, on streamed and non-streamed responses alike: input_tokens, input_tokens_details.cached_tokens (with cache_write_tokens), output_tokens, output_tokens_details.reasoning_tokens, and total_tokens. These responses previously could carry chat-style prompt_tokens and completion_tokens keys or top-level cache_read_tokens and reasoning_tokens, and reported cache reads outside cached_tokens. Read the standard fields instead; billing is unchanged.
  • /v1/messages now forwards caller-supplied output_config.task_budget to models outside the eb1 family that support it, for both buffered and streaming requests. Use {"type": "tokens", "total": N} with integer N >= 20000. Malformed budgets and budgets on unsupported models or eb1 ids return 400 before dispatch. Requests without a task budget keep their existing behavior; /v1/responses gains no new fields. See Task budget.
  • A response-format schema rejected for its complexity now returns response_format_schema_too_complex with guidance to simplify the schema and retry, on Responses, Chat Completions and Messages, including streams. The request is not retried.

2026-09-28#

  • eb1-delta-preview and eb1-preview-delta now serve eb1-preview: the same model at the same pricing. Responses to requests that use either identifier name eb1-preview. Both identifiers remain accepted on requests and in stored conversations until 2026-10-28 (UTC) and may stop being accepted after that date; use eb1-preview.
  • Fewer requests to eb1 models end in the safety-refusal response. When a request is declined before any output is produced, the platform now makes one further attempt in more cases than before and returns that answer as the response. Only the returned answer is billed; the declined attempt is not. A request that is still declined receives the same safety-refusal response as before, with zero usage.

2026-09-25#

  • When a platform dependency is temporarily unavailable, the 503 provider_unavailable response now advertises a retry horizon between 5 and 15 seconds in Retry-After, retry-after-ms, and the stream frame's retry_after_seconds, instead of one second. The value varies per request so clients refused together do not retry together. A stream that fails mid-response for the same reason now ends with the same provider_unavailable frame instead of internal_error.
  • Every other retriable response that carries Retry-After now advertises a horizon that varies per request, so clients refused together do not retry together. The value is the previous horizon lengthened by up to a quarter, and by at most 30 seconds; it is never shorter than before, and a horizon of 60 seconds or less stays at or below 60 seconds so the OpenAI and Anthropic SDKs keep honoring it. retry-after-ms, error.details.retry_after_seconds, and the stream frame's retry_after_seconds carry the same per-request value. Retry-After rounds it up to a whole second, so a response that sent Retry-After: 1 now almost always sends 2; read retry-after-ms for the spread. A 503 raised by a platform lookup outage now carries retry-after-ms alongside Retry-After, and a 503 for a request that timed out waiting for serving capacity advertises at least the time it already waited instead of one second. See Retry-After.
  • eb1-frontier-preview now reports a context_window (and max_input_tokens) of 869811 in /v1/models, up from 400000, and accepts prompts up to that size on every request, instead of refusing some long prompts. The other public eb1 models stay at 400000. The figure is a floor the API honors whatever max_output_tokens you set, and a prompt past it returns context_length_exceeded with the limit. Requests remain subject to the organization's per-minute token budget (request_exceeds_capacity). Existing Codex, OpenCode, and Pi setups pick up the new window on their next setup run; Claude Code sessions keep the default model's 400000 window.

2026-09-10#

  • Reasoning tokens on eb1 models are now itemized inside the output count on every surface: output_tokens / completion_tokens is the delivered text plus the reasoning tokens, total_tokens is input plus output, and the reasoning share appears in output_tokens_details.reasoning_tokens (Responses) and completion_tokens_details.reasoning_tokens (Chat Completions); on Messages it is inside output_tokens as on Anthropic's own API. The reasoning count is the model's own report and is no longer clamped to the length of the reply, so the four counts on a record multiply by the rate card to exactly the amount billed. See "Reasoning tokens" under Token counting on the usage and billing page.

2026-09-09#

  • A request whose body does not arrive in full within 60 seconds of the gateway starting to read it is now refused with 408 and the new error code request_body_timeout. The error is retriable, and the OpenAI and Anthropic SDKs retry a 408 by default. Before this change a stalled upload held its connection open until the server restarted.

2026-09-07#

  • Token counts on every eb1 model are now reported and billed in one unit, the o200k_base meter, on every request. The same request body yields the same prompt_tokens / input_tokens on every call, completion_tokens / output_tokens is the meter count of the delivered output, and total_tokens is their sum. Cache-read and cache-write counts are reported as proportional subsets of the metered prompt. The 400,000-token input window, /v1/messages/count_tokens, and rate-limit token accounting use the same unit. Counts you can reproduce locally with tiktoken's o200k_base encoding.
  • Follow-up corrections to the meter: image and file requests now report the same prompt count that is billed (the per-part media minimum), tool results sent as content-part lists and custom tool outputs are counted, and a safety refusal the gateway authors carries zero usage on streams as it already did on synchronous requests.
  • POST /v1/messages/count_tokens now counts an accepted body exactly as the request would be billed, tool definitions and tool history included; a body the Messages endpoint would reject still receives an advisory estimate.
  • A streamed request that ends early after delivering output (client disconnect or provider error) is billed for the delivered output and its prompt, in meter units, whether or not the provider reported usage; a stream that delivered nothing is not billed.

2026-09-06#

  • Content-limit refusals now return 400 invalid_request_error with media-removal or compaction wording recognized by Claude Code. Image, PDF, replay-byte, and content-node limits are unchanged; depth-only errors remain count-free.
  • A request that reaches the platform while an internal service is restarting now completes on a live instance of that service when one is reachable within the request's retry budget. When several instances are down at once and none of them has yet been re-probed, the retries can still all land on down instances and the request fails. When no instance can take the request, the response is 503 server_error with the new code route_unavailable, a retriable condition carrying a Retry-After horizon and the message "A platform service is restarting. Retry the request shortly." These failures previously surfaced as 503 provider_unavailable with "Capacity is temporarily limited", wrongly implying an upstream dependency and a capacity condition; no upstream is involved and an unchanged retry succeeds once the restart completes. provider_unavailable remains reserved for genuine upstream unavailability.
  • The 400,000-token eb1 input window uses unpadded cl100k prompt counts, including tool definitions and replay estimates. Gateway context-overflow errors now report their input count and binding limit in that same unit, so clients can compact and retry using consistent counts. Messages keeps the native prompt is too long: N tokens > M maximum grammar; provider rejections retain the provider's own counts.

2026-09-04#

  • Function tools declared with strict: true now keep strict: true on every request, so tool-call arguments are validated against your schema; previously the flag could be dropped without notice on some requests. This applies on /v1/responses, /v1/chat/completions, and /v1/messages alike, and to the custom + input_schema tool spelling. A strict schema must set additionalProperties: false and list every property under required; a strict declaration whose schema does not can now return 400 instead of running without the guarantee. Tool declarations lead the prompt-cache prefix, so the first strict request after this change can write a new cache entry.

2026-09-03#

  • Replayed tool history is validated once per request before any model is called. A duplicated call_id, a result for an unknown call, a second result for the same call, or a call left unanswered before the next user turn now returns 400 with code conversation_invariant and the offending call_id, on /v1/responses, /v1/chat/completions, and /v1/messages alike, instead of a less specific error that varied by request.
  • Streaming requests that replay function-call history can now be served by more of eb1's serving capacity. Requests that set parallel_tool_calls: false are still honored.
  • Tool names longer than 64 characters or using characters outside [A-Za-z0-9_.:-] (long MCP names, for example) now work on every eb1 request; the model sees a stable alias and every emitted call carries the name you declared.
  • Freeform apply_patch calls served through the compatibility path now carry the same call_eba1_… identity every other tool call carries. Ids issued under the earlier call_eb2.… format keep working for one release.

2026-09-02#

  • previous_response_id is now honored on /v1/responses for every eb1 model. Each response is retained for 24 hours, scoped to your organization, unless the request set store: false; a follow-up request that names the id continues the conversation without resending earlier turns. An unknown or expired id returns 400 with code previous_response_not_found, matching the OpenAI contract. Responses larger than 1 MiB are served normally but not retained for continuation.
  • /v1/messages now forwards output_config.effort and thinking: {"type": "adaptive"} as the request's reasoning effort instead of dropping them; effort above a model's ceiling is lowered to that ceiling.
  • /v1/responses accepts tool_choice: {"type": "allowed_tools"}, assistant refusal content on replayed turns, array-valued custom_tool_call_output, and input_image.detail: "original". item_reference items and conversation return a 400 naming the parameter.
  • Tool-call identities are now gateway-issued on every surface. A Responses call_id, a Chat Completions tool_calls[].id, and a Messages tool_use.id for the same call all render as the same call_eba1_… alias; hosted web-search correlation ids render as hist_eba1_… and output item ids as item_eba1_…. Replay them verbatim in continuation turns exactly as before; ids issued by earlier responses keep working. Provider-private continuation fields (such as thought_signature) no longer appear in customer payloads; the gateway carries them across turns for you.
  • /v1/messages now serves Anthropic-native web search with both current spellings, web_search_20250305 and web_search_20260209, on every eb1 model, and its server_tool_use and web_search_tool_result blocks come back in place. Previously the native declaration was refused.
  • Anthropic's client-executed agent tools (bash_20250124, the text_editor_* versions, and memory_20250818) are accepted on /v1/messages and served natively where the model supports them; the model's version support still applies. Previously these declarations were refused as unknown tools.

2026-08-27#

  • eb1-fast-preview now reports a context_window (and max_input_tokens) of 400000 in /v1/models, up from 240000. The larger window is now served, and the published figure tracks the enforced serving bound (capped at the product-wide 400000 ceiling shared by every eb1 model). As before, the figure is a floor the API honors on every request. Existing Codex setups pick up the new window on their next setup run.

2026-08-21#

  • A platform-internal admission refusal that previously surfaced as 500 internal_error now returns 503 server_error with code route_capacity and a Retry-After horizon, the same retriable contract introduced on 2026-08-05. No upstream is involved and an unchanged retry usually succeeds immediately; clients that already honor route_capacity need no changes.

2026-08-20#

  • The Codex model catalog written by the Keiro installer now declares the one reasoning level eb1 models accept. In stock Codex, choosing a model from /model previously applied the change but left the picker on screen until Esc; the picker now closes on selection. Existing installations pick this up by rerunning the installer, which rewrites ~/.codex/keiro.json in place. See Use eb1 with Codex.

2026-08-10#

  • New setup guides for two additional coding agents: OpenCode registers Keiro as an OpenAI-compatible provider in opencode.json, and Pi adds a Keiro provider entry to ~/.pi/agent/models.json. Both pages appear in the Build navigation alongside the existing Codex, Claude Code, and Omnigent guides.

2026-08-08#

  • /v1/messages usage adopts Anthropic's native disjoint input-side semantics for all callers, effective with the next deployment: input_tokens excludes the cached portions of the prompt, and input_tokens + cache_read_input_tokens + cache_creation_input_tokens equals the full prompt. The previous additive-subset shape — the full inclusive count in input_tokens with the cache fields as subsets of it — is retired. Clients that read input_tokens as the inclusive total should sum the three input-side fields to recover it; responses with zero cache activity are unchanged. See Messages.
  • Prompt tokens served from a prompt cache now bill at 0.1x the model's input rate on every public model. Cache writes carry no surcharge and bill at the standard input rate. The usage fields that report cached prompt portions are unchanged; only the billed amount drops. See Usage and billing.

2026-08-05#

  • Requests refused by a platform-internal capacity gate now return 503 server_error with the new code route_capacity, a retriable condition carrying a Retry-After horizon. These refusals previously surfaced as 502 upstream_server_error, wrongly implying an upstream dependency; no upstream is involved and an unchanged retry usually succeeds within seconds. provider_unavailable remains reserved for genuine upstream unavailability.

2026-08-02#

  • eb1-preview and eb1-efficient-preview now report a context_window (and max_input_tokens) of 400000 in /v1/models, up from 120000; eb1-fast-preview reports 240000. The previous figures understated the window the API was already serving. The published figure remains a floor the API honors on every request; eb1-frontier-preview is unchanged at 400000. Existing Codex setups pick up the new windows on their next setup run.
  • Context-overflow errors now report the enforced bound. The M in prompt is too long: {N} tokens > {M} maximum (and details.context_window) is the largest limit the rejected request was actually evaluated against, in the same units as {N}, rather than the requested model's published window; {N} > {M} holds on every such error, so clients that trim by the reported gap now trim the right amount.

2026-07-29#

  • Model IDs the API does not offer now return a uniform 404 model_not_found that names the public IDs, with 403 model_not_available reserved for public models your plan does not include. Previously some unknown IDs surfaced as availability errors.
  • Streamed Messages responses carry thinking summary blocks, delivered through thinking_delta events, when extended thinking is enabled. These blocks contain summary text constructed by the API and are unsigned; do not round-trip them as provider-signed thinking blocks.
  • POST /v1/messages/count_tokens now applies the same per-part minimums to image and document blocks that admission and billing apply, so multimodal estimates rise to match what is charged.
  • Validation errors on /v1/messages now name fields in Messages coordinates (messages[i].content[j]) instead of the Responses spelling.
  • /v1/messages error bodies now carry error.request_id, matching the X-Request-Id header, completing the 2026-07-15 error-identification contract on the Messages surface.
  • The Claude Code installer verifies the key with one authenticated request before storing it, reports incomplete setups honestly, and gains an uninstall command.
  • eb1-frontier-preview now reports a context_window of 400000 in /v1/models, up from 128000. The raised figure remains a floor the API honors on every request, with the same safety margins as before. The 120000 windows on eb1-preview, eb1-fast-preview, and eb1-efficient-preview are unchanged, as are the legacy request identifiers accepted for compatibility. Requests remain subject to the organization's per-minute token budget (request_exceeds_capacity, see 2026-07-19). Existing Codex setups pick up the new window on their next setup run.
  • Requests to preview models rejected purely for context size now return 400 invalid_request_error with code context_length_exceeded, matching every other context-overflow rejection. Previously this one path reported the generic request_requirements_unsatisfied. That code is now reserved for requests whose input, tool, reasoning, or media requirements cannot be satisfied together for reasons beyond context size alone.

2026-07-26#

  • Stream lifetimes are now documented per-effort time entitlements instead of one flat internal timeout. A stream that is actively working is never ended for taking long: streams end early only on a documented idle timeout (90 seconds without model activity; 120 seconds at xhigh and above) or on the wall-clock ceiling for the requested reasoning effort (5 minutes at none/minimal up to 60 minutes at max/ultra). Requests that do not set a reasoning effort resolve no lower than the medium row (10 minutes); eb1-frontier-preview defaults to the max row. Previously, long runs could be interrupted near 600 seconds even while the model was still working.
  • When a stream deadline fires, the run ends with one honest terminal instead of a spurious error: Responses streams carry response.incomplete with incomplete_details.reason of stream_idle_timeout or stream_ceiling_timeout; Chat Completions reports finish_reason length and Messages reports stop_reason max_tokens. Tokens consumed before the stop are billed; the terminal event is truthful about why the run stopped. See Streaming.

2026-07-22#

  • The discoverable model catalog is eb1-preview, eb1-frontier-preview, eb1-fast-preview, and eb1-efficient-preview, superseding the naming contract published on 2026-07-20. The eb1-preview-efficient, eb1-preview-fast, and eb1-preview-delta identifiers remain accepted on requests and in stored conversations with unchanged behavior and pricing, but no longer appear in /v1/models, Console menus, CLI listings, or Codex setup. Responses to requests that use one of those identifiers name the canonical id; responses to eb1-preview-delta requests name eb1-delta-preview, which remains callable but does not appear in discovery.
  • Invalid model-exclusion inputs now return the governed, non-retriable 400 invalid_request_error envelope with code bad_request. Previously these caller-fixable requests could be serialized as a retriable 502 upstream_error. Synchronous responses now carry x-should-retry: false; synchronous bodies and streaming error frames carry retryable: false with no retry horizon.

2026-07-20#

  • Public discovery, Console, CLI, and Codex now use one four-model naming contract: eb1-preview, eb1-preview-efficient, eb1-preview-fast, and eb1-preview-delta. Existing stored configurations using earlier preview spellings remain request-compatible, but new configuration and response identity use the current IDs.
  • Keiro 0.12.22 requests safe reasoning summaries for registered eb1 models and displays available segments while a response is in progress. These segments are terminal activity, not assistant answer text: they do not enter conversation history, copied code blocks, or piped stdout. Python callers can consume the same validated stream separately with ModelsAPI.responses_stream(on_reasoning_summary=...) or its admin sibling. Requests to models outside the eb1 family receive no implicit summary setting.

2026-07-19#

  • Responses usage now reports provider-supplied prompt-cache reads and writes in input_tokens_details.cached_tokens and cache_write_tokens, instead of always reporting zero. Both are subsets of input_tokens and do not change total_tokens. The Console chat tester preserves those reported cache-read counts and output_tokens_details.reasoning_tokens in a compact Token details disclosure when those subsets are positive; required structural zeroes remain undisclosed because they do not prove provider provenance. It labels arithmetic totals and remainders as derived and does not fabricate system-prompt, history, user-message, or tool-schema buckets that the API does not separately report.
  • Published context windows now match the limit the API enforces end to end. eb1-preview, eb1-efficient-preview, and eb1-fast-preview report a context_window of 120000 in /v1/models, down from the previously published 128000; eb1-frontier-preview is unchanged at 128000. Requests between the two figures could previously be rejected with a context-overflow error despite sitting inside the published window; the published figure is now a floor the API honors on every request.
  • Requests whose selected model cannot satisfy every input, tool, reasoning, and context requirement now fail before dispatch with non-retriable HTTP 400 code request_requirements_unsatisfied.
  • Requests whose token estimate exceeds a full minute of the organization's token-per-minute budget now return a terminal 400 invalid_request_error with code request_exceeds_capacity, instead of a 429 rate limit. The old 429 carried a Retry-After header even though no unchanged retry could ever succeed, trapping status-driven clients in an infinite retry loop. The new response carries x-should-retry: false, no retry horizon, and no x-ratelimit-reset-*-tokens header; the message and details.dimension: "token_budget_request" are unchanged. Reduce the input or max_output_tokens, or raise the limit, and resend.

2026-07-18#

  • Usage objects on OpenAI-format surfaces now itemize reasoning tokens and follow the standard arithmetic exactly. Chat Completions usage gains completion_tokens_details (with reasoning_tokens), and total_tokens always equals prompt_tokens + completion_tokens, with reasoning counted inside completion_tokens. Previously, reasoning-heavy requests could report a total_tokens larger than the visible sum with no breakdown.
  • Responses usage now matches the standard ResponseUsage schema: input_tokens, input_tokens_details.cached_tokens, output_tokens, output_tokens_details.reasoning_tokens, and total_tokens (= input_tokens + output_tokens). The former non-standard flat reasoning_tokens key and the prompt_tokens/completion_tokens aliases are removed. Strict typed SDK clients that previously failed to validate usage now parse it; clients reading the flat keys must switch to the nested fields.
  • /v1/messages output_tokens now includes reasoning tokens, matching the Anthropic convention that thinking is part of output.
  • usage detail objects report cached_tokens: 0 for now; prompt-cache accounting is not yet reflected in usage counts.

2026-07-17#

  • Retired the /v24b versioned endpoint path. It no longer differs from the current default deployment, so requests to /v24b/v1/* now return 410 endpoint_retired instead of serving the current default under a versioned label. Use the default API (/v1).
  • The Keiro CLI no longer offers a v24b endpoint preset. keiro endpoint v24b, saved v24b gateway URLs, and explicit v24b URLs surface the retirement guidance instead of binding to the default gateway.

2026-07-15#

  • Missing pricing for an otherwise valid model now returns the governed, non-retriable 404 model_not_found envelope with x-should-retry: false.
  • Chat Completions stream error frames now nest a full error object (code, type, message, retry signals, retryable, request_id, and details on limit denials) alongside the existing flat fields. OpenAI-compatible SDKs surface it as a typed error instead of failing to parse the frame. The flat fields are deprecated (removal is at least two releases out and gated on usage telemetry); Messages and Responses stream error frames gain the same details object on limit denials.
  • /v1/messages responses now also carry a request-id header (an alias of X-Request-Id) so Anthropic-compatible SDKs populate .request_id.
  • Responses that produced no output because reasoning consumed the entire completion budget now report status: "incomplete" with incomplete_details.reason: "max_output_tokens" and a warning naming the fix, instead of claiming success; Chat Completions report finish_reason: "length". Billed usage is unchanged and still reported.
  • Error messages no longer carry [Error NNNN] / [Recovery: …] bracket furniture; recovery guidance appears as a plain sentence only when it applies to the specific failure. Message text remains non-contractual.
  • Corrected upstream authentication failures to a fixed 502 with code upstream_auth_error. Previously an upstream 401 could pass through as your fault; SDKs raised AuthenticationError and stopped retrying for a platform-side condition. Your API key is valid when you see this code.
  • Replaced the 401 code authentication_error (which duplicated type) with three specific codes: missing_authorization, bearer_scheme_required, and invalid_api_key (with a redacted details.key_hint). Code-matching clients keep working: the old code's value remains as the error type. All 401 responses now carry WWW-Authenticate: Bearer.
  • error.param is now populated with the offending field name where known; previously documented as always null.
  • Documented every error code with per-code anchors, added 413 and 415 to the status table, and removed the never-emitted 408 row.
  • Added retry-signal headers to error responses: retry-after-ms (milliseconds, fractional precision) on retriable denials and x-should-retry: false on denials an unchanged retry cannot clear. Deterministic denials also carry "retryable": false in the error body.
  • Error responses now include error.request_id, matching the X-Request-Id header; stream error frames carry it on the Messages and Responses wires.

2026-07-10#

  • Added an API reference index and dedicated guides for Messages, function tools, image input, API-key lifecycle, usage and billing, and Codex setup.
  • Reworked Quickstart into an install-to-output workflow with one credential policy: saved Keiro credentials, interactive curl/Python secrets, and secret-file references for other runtimes.
  • Reconciled API-key guidance with the console's create, staged-replacement, and delete/revoke workflow.
  • Added contextual related-page paths throughout the documentation.
  • Corrected the subprocessor description: authenticated docs are served by Keiro-operated services, while Netlify hosts the public website, early-access intake, and published status artifact.

2026-07-01#

  • Documented idempotent requests, including the Idempotency-Key header, the X-Idempotent-Replay and X-Original-Request-Id replay headers, and 409 idempotency_key_conflict conflicts.
  • Documented the 409 status code and clarified that the error param field is always null.
  • Added a Responses streaming event taxonomy.
  • Documented Netlify's hosting purpose for the public website, early-access intake, and published status artifact.

2026-06-25#

  • Added shared Keiro Labs web-surface tokens to generated docs.
  • Added skip links, active sidebar navigation, canonical URLs, Open Graph URLs, and table scrolling to the docs shell.
  • Updated docs Markdown rendering for emphasis, blockquotes, h4-h6 headings, and in-list code fences.
  • Updated rate-limit retry guidance to honor Retry-After.

2026-06-15#

  • Added initial paid beta public docs surface.
  • Standardized runnable examples on one public base URL.
  • Documented chat completions, responses, streaming, models, rate limits, errors, SDKs, support, and migration guidance.
  • Kept local keiro gui scoped to chat UX only.

Search Keiro docs

Start typing to search pages and sections.

Start typing to search pages and sections.

Documentation

Console