Skip to main content

Release 2026.11.19

Breaking changes​

Two tools with the same name are refused​

Since 19 November 2026, POST /v1/chat/completions and POST /v1/responses refuse a request that declares two function tools with the same name: HTTP 400 with type invalid_request_error and the message More than one tool is named 'X': each tool needs its own name.. param points at the second tool with that name, tools[<i>].function.name on chat completions and tools[<i>].name on the Responses API, and names are compared exactly, letter case included. Such a request used to be accepted, but the arguments of a call to that name were converted with the schema of the tool declared first, so your application could not tell which tool was meant: give each tool its own name. To fix a refused request, look in your tools for two entries with the same name, and rename or remove one. See Give each tool its own name.


Sandboxes​

Save a sandbox as a template, on request​

Set a sandbox up once, save it as a private template of your account with the E2B SDKs' create_snapshot, and create sandboxes from it that start where the saved one was, with its memory and disk. Templates are enabled on request, per account, for accounts that have Sandboxes (see Access). Each GiB a template stores is billed at 0.08 USD per GiB-month, the price of a paused sandbox, and an account keeps up to 10 templates and 20 GiB by default. See Save a sandbox as a template.

Known issue​

Deleting a template by the snapshot id that the SDKs return (<your account>/<name>:<tag>) gets HTTP 404 with edge_route_not_available, and delete_snapshot returns False: the template is not deleted. Until the fix, delete by the bare name, without your account's namespace, such as Sandbox.delete_snapshot("data-env"). See Known issues in the preview.


Documentation​

Release 2026.11.18

Version 1.3 of the legal documents takes effect today and replaces version 1.2. It adds the terms for media models, the models that generate or edit images, generate video or generate speech. The Legal document changelog lists what changes, in plain words and document by document:

  • Media models are covered by Annex 2 of the Terms of Service and Exhibit 5 of the Data Processing Agreement. Nothing changes for the other models.
  • Generated images and videos are kept in memory for up to 60 minutes so that you can download them, never on disk, and are then deleted. An image returned in the response itself, and generated speech, are not kept.
  • Automated safety checks apply to the prompts, input images and outputs of the image and video models. They keep no copy, and no person reviews them.
  • Every generated image, video and audio is marked as made by AI, with marks that do not identify you. Do not remove or alter them on purpose.
  • Voices and real people. The speech models' voices are synthetic presets; do not present them as a real person's voice. Do not depict a real, identifiable person, or imitate their voice, without their consent.
  • Fees may be stated per second of audio, per character, per image or per second of video, besides tokens.

Release 2026.11.17

API changes​

Read your sandbox usage with GET /v1/usage​

GET /v1/usage returns the usage records of the Sandboxes created with the API key you call it with: each interval of each sandbox, with its quantities and its amount, the records your sandbox invoice is computed from, page by page with cursor and limit. Each key reads its own records only, under limits of its own (2 requests in flight and 30 per minute) that never take the budget of your sandbox calls. Inference has no usage records to read. See Check your usage and the API reference.

Speech to text on POST /v1/audio/transcriptions​

POST /v1/audio/transcriptions transcribes audio files in the format of OpenAI's speech-to-text API, so the OpenAI SDKs work unchanged: send one file per request as a multipart/form-data form with model=vibevoice-asr. The answer is the transcript as json or text, and verbose_json adds segments with their start, end and speaker. More than 50 languages are detected automatically. Each request takes up to 5 minutes of audio and a body of up to 16 MiB, in FLAC, M4A or MP4, MP3, Ogg, WAV or WebM. See Speech to text.

Remove the tags for audio without speech​

The speech-to-text model marks audio without speech with tags in square brackets, such as [Silence] or [Noise], in the text and the segments. They are kept by default. Send remove_nonspeech_tags=true (with the OpenAI SDKs, in extra_body) to remove them from every format; billing does not change. See Non-speech tags.

Tool calls cut by the output limit end with length​

On POST /v1/chat/completions, an answer whose output limit cuts it in the middle of a tool call now ends with finish_reason: "length" instead of "tool_calls", with the same usage. On POST /v1/responses, such a response ends with status: "incomplete" and incomplete_details.reason: "max_output_tokens", and a stream ends with a response.incomplete event. Before you run a call, check that finish_reason is "tool_calls" and that usage.completion_tokens is below your max_tokens, and send tools on every request of the conversation. See Tool calling.


Models​

vibevoice-asr for speech to text​

vibevoice-asr (alias microsoft/vibevoice-asr) joins the OpenAI-style list (GET /v1/models?format=openai) with endpoints: ["/v1/audio/transcriptions"] and input_modalities: ["audio"]. It is billed per second of audio, rounded up per request, at $0.000047 per second ($0.1692 per hour), listed in audio_pricing.per_second instead of a price per token. A request that ends in an error is not billed. Current prices are listed live on Pricing and limits.


Documentation​

Release 2026.11.14

API changes​

One prompt cache per API key​

On POST /v1/chat/completions and POST /v1/responses, cached prompt content is never shared between API keys. A prefix is served from the cache only to requests made with the key that sent it, so the first request of each key with a given prefix is billed at the full input price, even when another key has sent the same prefix. See Cached input.

cache_salt splits a key's cache​

POST /v1/chat/completions takes an optional cache_salt: requests of one key with the same value share one cache, and requests with different values, or without one, do not. A platform that serves many users with one key can give each of them a cache of their own. The value must be a string of 1 to 128 characters without @, /, \ or NUL, or the request is refused with HTTP 400 and param: "cache_salt". The Responses API has no such parameter. See Cached input.

Reasoning effort levels​

reasoning.effort (and reasoning_effort on chat completions) now works as published. none and minimal turn reasoning off: minimal used to turn it on. On a model with reasoning levels, low, medium and high (or xhigh) are now three levels, from the least reasoning to the most, where all of them used to give the highest; on a model without levels, any of them turns reasoning on. Any other value is ignored, where it used to turn reasoning on. Reasoning lists the levels of each model.

Streams that end early are billed for what you received​

A stream that ends before its usage chunk, because you closed the connection or because it reached the 600-second limit, is billed for the output you received, on an estimate of its tokens; before, it was not billed. A stream that fails on our side, or that ends before any output, is still not billed. See Prices.


Version 1.2 of the legal documents takes effect today and replaces version 1.1. The Legal document changelog lists what changes, in plain words and document by document:

  • Sandboxes are covered by Annex 1 of the Terms of Service and Exhibit 4 of the Data Processing Agreement: what a sandbox stores and for how long, what is logged about it, and what not to put in a sandbox during the private preview.
  • Processing locations are stated in general terms. Inference runs on Substrate AI's own GPUs in facilities in the European Union, and request handling in Microsoft Azure data centres in the European Union. The documents no longer name individual sites or cloud regions.
  • With a Serenity Star account, your requests and their answers pass through Serenity Star's API, which authenticates and meters them.
  • Request metadata is described by category. It still never includes your prompts or completions, and it is still kept for 90 days.
  • The websites serenityedge.ai, with its playground, and docs.serenityedge.ai are both covered by the Legal notice, the Privacy Policy and the Cookie Policy.

Sandboxes​

One API host and one key for inference and sandboxes​

Set E2B_DOMAIN to serenityedge.ai and E2B_API_KEY to your Serenity Edge API key. The E2B SDKs then manage sandboxes through https://api.serenityedge.ai, the host and key you already use for inference, on the E2B API's paths (/sandboxes, /v2/sandboxes), which are not under /v1. See the quickstart.

Sandbox traffic goes to the sandbox domain​

A sandbox's commands, files, terminal and ports go to its sandbox domain, which the API now returns with each sandbox in the domain field of the create and connect answers. The SDKs use it for you, and you do not set it. In the preview it is vlc1.serenitysandboxes.cloud. What a sandbox serves is never served under serenityedge.ai. See The sandbox domain.

Request limits of the control API​

Each key may have 8 requests in flight to the sandbox control API and send it 120 requests a minute. Over either limit, the answer is 429 edge_key_request_concurrency_limit or 429 edge_key_request_rate_limit, with Retry-After. These limits are separate from those of the inference API, and from the running sandboxes and creates per minute of your account. A Serenity Edge API key whose account does not have Sandboxes enabled gets 403 edge_sandboxes_not_enabled. See Request limits and Errors.

If you set E2B_DOMAIN to the site's domain​

E2B_DOMAIN=vlc1.serenitysandboxes.cloud, the setting given on 12 November, keeps working with the same key. The documented setting is now E2B_DOMAIN=serenityedge.ai: change to it when you next update your configuration. Your code does not change.


Documentation​

  • Models gains a Reasoning section with the effort values and the levels of each model; Pricing and limits describes the cache per key and cache_salt; the chat completions reference adds cache_salt and reasoning_effort and the six effort values; the coding agents guide no longer says that low, medium and high behave the same.
  • Data residency and retention: processing locations in general terms, the edge network in the request flow, the Serenity Star route and a Sandboxes section.
  • The Sandboxes pages document one API host for inference and sandboxes, curl examples against https://api.serenityedge.ai, and ports reached on the host the SDKs give (sandbox.get_host(8080)). Sandbox network access and security gains a section on hosts and domains, Sandbox errors the codes of the control API, and the Sandboxes pages say where sandboxes run in general terms, in the European Union.

Release 2026.11.12

Sandboxes​

Sandboxes in private preview​

Serenity Edge Sandboxes, isolated microVMs for AI agents, are in private preview, by invitation: Linux machines that you create through an API, run commands in, pause, resume and kill. They are enabled on request for existing Serenity Edge customers and partners; once they are enabled, the Serenity Edge API key you use for inference works for sandboxes too. To ask for access, see Enterprise or write to contact@substrate.ai. See Sandboxes and the quickstart.

Compatible with the E2B SDKs​

The API is compatible with the E2B API and the official E2B SDKs (pip install e2b, npm install e2b), tested with version 2.63.0. Set E2B_DOMAIN to vlc1.serenitysandboxes.cloud and E2B_API_KEY to your Serenity Edge API key, and Sandbox.create() works with no other change. The preview runs in one site, in the European Union.

Prices​

A running sandbox is billed per second, with no minimum, for its reserved resources: 0.0504 USD per vCPU-hour and 0.0162 USD per GiB-hour of memory. CPU time may be shared under load, as on burstable instances. A paused sandbox is billed 0.08 USD per GiB-month actually stored. Billing started on 12 November 2026, and there are no welcome credits. See Pricing and usage.

The default template​

The preview has one public template, edge-agents, used by default, so Sandbox.create() needs no arguments (over HTTP, its templateID is base or edge-agents). It is Ubuntu 24.04 with tools for agents (Python 3.12 with uv and Jupyter kernels, Node.js 26 LTS, the .NET 10 SDK, compilers, git and the GitHub CLI, LibreOffice and document tools, and a headless Chromium with Playwright), with 2 vCPUs, 2 GiB of memory and about 26 GiB of disk, of which 20 GiB are free. See Templates.

Limits, network and lifetime​

Each account may run up to 48 sandboxes at once and create 60 per minute, and a sandbox runs for at most 24 hours; a paused sandbox keeps its files, memory and processes for up to 30 days. Commands, files and an interactive terminal go through the SDKs over HTTPS; there is no SSH access. A sandbox reaches public websites and APIs over HTTP and HTTPS (ports 80 and 443), through an egress proxy that the template sets up, and nothing else; private and internal addresses are refused. A sandbox created with allow_internet_access: false reaches nothing at all, and is billed the same. See Limits and quotas and Network access and security.

Not in the preview​

Desktops and computer use are coming soon. Template builds, public sandbox URLs, outbound network rules set by the client, sandbox logs, create fields outside the supported list, credentials added to outbound requests by Serenity Edge, a spending cap and reading usage records through the API are not available in the preview; each is refused with its own edge_ error code where a request can ask for it. When the site is full, a create or a resume gets 503 sandbox_capacity_unavailable: retry later. See Preview status and Errors.

Preview limitations​

Paused sandboxes are not backed up yet, so they can be lost if the site's storage fails: keep anything you need outside the sandbox. The preview has one site, and its limits and prices may change; changes will be announced here. Until the sandbox domain is on the Public Suffix List, do not rely on cookie isolation between sandbox host names (see Cookies and browsers). There is no service level, and the independent security testing of the service is not finished: do not put production secrets or personal data in a preview sandbox.

Known issues​

Writing a file with sandbox.files.write to a path under /tmp a second time fails with HTTP 500 ("permission denied"): write files under /home/user until the fix. Sandbox metrics are not available in the preview. See Known issues in the preview.


Documentation​

  • New section "Sandboxes (private preview)": overview, quickstart, API reference, errors, limits and quotas, pricing and usage, and network access and security.

Release 2026.11.06

Website​

Playground​

The new playground calls the API live from the browser, with no key or sign-up. You can play Blocks and gems against orion-compass on POST /v1/systemone, or pick orion-compass-flash or d3 as the rival. It also has four business cases:

  • support inbox triage on POST /v1/decisions;
  • expenses against a policy on POST /v1/decisions, where orion-compass-flash reads the image of each receipt;
  • a personal data hunt on POST /v1/redact;
  • exact clause search on POST /v1/embeddings and POST /v1/rerank.

Every demo shows the exact request and response, a copy as cURL against the public API, and what its calls cost at published prices.

Release 2026.11.05

API changes​

Up to 8 images per request​

Chat models now read up to 8 images per request, counted over the whole conversation, on POST /v1/chat/completions and POST /v1/responses. The limit depends on the model: 8 on orion-pro, 8 on orion-plus, 8 on qwen3.8-27b, 8 on qwen3.6-35b-a3b and 1 on paddleocr-vl-1.6. GET /v1/models publishes each model's limit as supported_inputs.references.max of its image input modality. See Image input.

An error code for too many images​

A request with more images than the model reads is still refused with HTTP 400 and the same message, but its code is now too_many_images instead of invalid_request_error, on POST /v1/chat/completions and POST /v1/responses. Images are counted over the whole conversation, earlier turns included.

In a long conversation, send only the most recent images, up to the model's limit, and replace the older ones with a short text. See Errors and rate limits.

Models​

No quantization or tokenizer on the Orion ids​

In GET /v1/models, the orion-pro and orion-plus entries no longer carry quantization or tokenizer. Both fields are optional in the provider schema. qwen3.8-27b, qwen3.6-35b-a3b and paddleocr-vl-1.6 keep them. See List models.

Documentation​

OpenCode​

The new Coding agents guide configures OpenCode with orion-pro and orion-plus on chat completions. OpenCode does not ask for reasoning by default, so the guide sets reasoningEffort on each model; any value other than none turns reasoning on. Codex CLI keeps its configuration in the Responses API guide.

Release 2026.10.30

API changes​

Embeddings usage counts each input's own tokens​

usage.prompt_tokens on POST /v1/embeddings is now the sum of each input's own tokens. Before, the inputs of one request were counted as if each were as long as the longest of them, so a request with inputs of different lengths reported, and was billed for, more tokens than the model read. A batch now costs the same as sending its inputs one by one; a request with a single input is unchanged, and so are the vectors. See Usage and billing.

Embeddings take text only​

POST /v1/embeddings takes text only: a string, or an array of strings. Token ids were listed as an input, but they never reached the model, and requests with them got a generic 400. They now get a 400 that says to send the text. If you use LangChain's OpenAIEmbeddings, set check_embedding_ctx_length=False: by default it sends token ids from OpenAI's tokenizer, which this model does not use. See Errors.

Serenity Star account keys on chat completions​

Keys from a Serenity Star account now work on POST /v1/chat/completions and POST /v1/responses with orion-pro, orion-plus and qwen3.6-35b-a3b; before, these requests failed with HTTP 404. The other models answer HTTP 404 with code: "model_not_found" to these keys. Serenity Star bills this usage at the prices of your Serenity Star account.

Codex CLI on the Responses API​

Codex CLI now works with POST /v1/responses. The route accepts Codex's client_metadata, which is dropped, and its namespace tools: the function tools of its plugins and MCP servers, grouped. A call to one of them comes back as a function_call with its name and namespace. Hosted tools are still refused, so set web_search = "disabled" in Codex's config.toml. See Codex CLI for the whole configuration.

Conversations on the Decisions API​

POST /v1/decisions takes a whole conversation in input, as OpenAI's Decisions API does: system, developer and assistant messages, function and custom tool calls with their outputs, and input_json parts, besides user messages. The model reads the conversation as a transcript, each item under a label, so you can ask whether an agent followed its instructions or used its tools well. Every item counts as input tokens. An input of user messages only is read as before. See Conversations.

Cached input is reported and billed​

The chat models now report the part of a prompt served from the prompt cache in usage.prompt_tokens_details.cached_tokens (usage.input_tokens_details.cached_tokens on the Responses API), and that part is billed at the cached input price, as Pricing and limits says. Until now no answer reported cached tokens, so prompts were billed entirely at the input price. Every request of a conversation now goes to the server that holds its prefix, so long conversations and agents that resend the same instructions, such as Codex CLI, are mostly billed at the cached price from their second request.

Embeddings and rerank read up to 8,192 tokens​

POST /v1/embeddings reads each input up to its first 8,192 tokens instead of 512, and POST /v1/rerank reads each document with the query up to 8,192 tokens; longer texts are still cut without an error, and what is cut is not billed. A request now takes at most about 300,000 tokens, estimated as a quarter of its characters (on rerank, the query counted once per document); a larger one gets HTTP 400 with param input or documents. See Limits.


Documentation​

  • The Embeddings, rerank and redaction guide, Pricing and limits and the API reference say that each embeddings input is read up to its first 8,192 tokens (the rest is ignored and not billed) and that a request takes at most about 300,000 tokens, and no longer list token ids as an input.
  • The Serenity Star account page lists the models these keys can use and says that Serenity Star bills them at your account's prices; Pricing and limits says its prices are those of Serenity Edge API keys.
  • The Responses API guide has a Codex CLI section.
  • The Decisions guide has a Conversations section, and the API reference lists the conversation items input takes.
  • Pricing and limits says that the prompt cache works in blocks, from which length a prefix is cached, and that a conversation stays on the server that holds its prefix.

Release 2026.10.29

API changes​

Images on d3​

d3 now reads images together with the text, like orion-compass-flash: input_image parts on POST /v1/decisions, and images on the Jev-compatible POST /v1/systemone. The limits are the same: base64 data URLs of PNG, JPEG or WebP, at most 4 per request, 8 MiB in total once decoded, 16 megapixels each, and a request body of up to 12 MiB. See Images.

The tokens the images expand to are input tokens, billed at the model's input price, and usage splits input_tokens into text_tokens and image_tokens. orion-compass still reads text only.


Documentation​

  • The Decisions guide and the API reference list d3 among the models that read images.

Release 2026.10.28

API changes​

Images on Orion Compass Flash​

orion-compass-flash now reads images together with the text. On POST /v1/decisions, send them as input_image parts. On the Jev-compatible POST /v1/systemone, send them as images.

Images go as base64 data URLs: PNG, JPEG or WebP, at most 4 per request, 8 MiB in total once decoded, and 16 megapixels each. The request body may be up to 12 MiB on this model. See Images.

The tokens the images expand to are input tokens, billed at the model's input price: usage.input_tokens counts them, and usage.input_tokens_details.image_tokens (usage.image_tokens on POST /v1/systemone) shows their part, next to text_tokens. orion-compass and d3 still read text only.


Documentation​

  • The Decisions guide and the API reference describe image input, its limits and how image tokens are billed.