Celeris-1 Diffusion LLM for Faster Agentic AI Workflows

Benchmark results originally published by the Celeris team, 22 July 2026.

Sponsored by Celeris. The benchmark results in this article were produced and originally published by the Celeris team.

Celeris launched publicly this month with its first model, Celeris-1, a diffusion LLM available today through an OpenAI-compatible API. In its launch benchmarks, Celeris-1 generated a median of 1,626 tokens per second — 4.8× the next-fastest API measured — and returned complete responses to 1,000-token prompts in a median of 0.58 seconds. That next-fastest API was mercury-2, the only other production diffusion language model, which came in at 339 tokens per second. Celeris reports 75.9% on MMLU-Pro at no reasoning, which it says lands within a few points of the frontier on accuracy; full details are at celeris.ai.

The speed comes from the architecture. Nearly every production language model — GPT, Gemini, Claude — decodes autoregressively: one token per forward pass, each conditioned on everything before it, a serial dependency that puts a hard ceiling on output speed. A diffusion language model generates differently, refining an entire sequence over a small number of parallel denoising passes, so throughput is governed by how much of the sequence each pass resolves rather than how quickly single passes can be chained. The benchmarks below, published by Celeris at launch, put a number on what that is worth against the fastest autoregressive APIs on the market.

Celeris-1 speed benchmark: 1,626 tokens per second

Celeris benchmarked celeris-1 against six competing APIs on a long-form workload with reasoning disabled on every model, isolating decode speed. The workload mirrors a widely used independent API-speed test shape: long-form prompts of roughly 1,000 input tokens with a 1,024-token output cap. Because the reference prompts are not public, Celeris wrote original prompts to match the published shape of that workload — ten prompts, five samples each, non-streaming, against every API. Median end-to-end output rates:

For a separate cross-provider view, see the LLM speed comparison.

Median output speed with reasoning disabled, end-to-end tokens per second. 50 requests per model. Source: Celeris.

Decode speed translates directly into wall time. celeris-1's median response to a 1,000-token prompt arrived in 0.58 seconds; mercury-2 took 3.10 seconds, gemini-3.5-flash 7.59, and gpt-5 14.78. A response that arrives in half a second sits inside the latency of an ordinary page load.

Median wall time per completed request. Mean output length: celeris-1 863 tokens, mercury-2 997, all others ≥1,020. Source: Celeris.

What low-latency inference changes for AI agents

Single-response latency understates the difference, because agents pay it repeatedly. Every step in an agent loop — plan, act on a tool result, decide what comes next — blocks on the generation before it, so latency compounds linearly with chain depth.

Most agent steps are also short. A routing decision, a tool call, a plan update — these run to tens of tokens, not a thousand, and on short responses celeris-1's latency drops from 0.58 seconds to the order of 100 milliseconds: a median of 158 ms on Celeris's short-form measurements, with responses arriving in as little as 24 ms. The comparison models answered the same short prompts in 1.2 to 2.6 seconds in their fastest configurations. That is the difference between an agent step that costs about as much as a database query and one that costs a page load — over a ten-step loop, roughly a second and a half of generation with celeris-1 against twenty seconds with gpt-5. At that latency the model stops being the bottleneck in the loop; the tools are.

Speed is only usable if the model is right often enough to act on. On MMLU-Pro (5-shot, chain-of-thought), celeris-1 scores 75.9% — within a few points of gpt-5's 81.9%, ahead of gemini-2.5-flash's 73.0%, and twelve points clear of mercury-2's 63.7%, the other production diffusion model — while responding an order of magnitude faster than the autoregressive models on the same questions.

MMLU-Pro accuracy (5-shot, chain-of-thought) vs. response time, log scale — up and to the left is better. Reasoning budgets were set to 0 for Celeris, GPT-5, GPT-5 mini, and the Gemini models, and Mercury 2 ran in instant mode. Source: Celeris.

Speed also changes what an agent can afford to do per step. At these decode rates, patterns normally reserved for offline processing fit inside an interactive loop:

• Best-of-n sampling: generate several candidate responses and keep the best — five full resamples of a 1,000-token response complete in about 3 seconds.
• Regenerate instead of patch: rewrite a whole document or code file from scratch rather than applying fragile incremental edits.
• Verification and retry steps: add a checker call after each action, or retry a failed step, without blowing the latency budget.

Four agentic workflow tasks Celeris-1 is built for

Celeris's current documentation narrows the product claim to short, structured calls inside an agentic workflow. It recommends another model for long-form generation. That makes Celeris-1 easier to evaluate as a specialist at four recurring steps:

Table 1 Download CSV

Agent step	Expected output	Production check
Tool routing	One allowed tool or route	Reject unknown labels
Structured extraction	JSON matching a fixed schema	Validate types and required fields
Judging and scoring	A bounded score with a short reason	Calibrate against human-labeled cases
Query rewriting	A concise search or retrieval query	Preserve names, dates, and constraints

The useful architecture is not one model for every step. Keep the stronger long-form model where planning or synthesis earns the delay, and test a faster structured model at repeated call boundaries. Our separate guide explains how to set that boundary in an agentic AI workflow.

How Celeris measured LLM inference speed

For the response-time figures, timing bases differ by provider: gpt-5, gpt-5-mini, and mercury-2 use server-reported processing time from response headers, while celeris-1 and the Gemini models were measured end-to-end from cloud instances in-region. The asymmetry runs against celeris-1: its figures include real network overhead that the server-reported figures exclude (measured end-to-end exceeded celeris-1's own Server-Timing header by a median of just 3.9 ms).

Where the benchmark stops

• Token counts are provider-self-reported, and the 1,024-token cap truncated most responses.
• Five models were measured on 22 July and mercury-2 re-measured on 23 July; one celeris-1 request returned a rate-limit error and is excluded.

Celeris makes the raw per-request data, the dataset, and the measurement harness available on request. The full original write-up is at celeris.ai.

Using Celeris-1 with an OpenAI-compatible API

The speed carries over to existing stacks as a configuration change. The Celeris API is OpenAI-compatible: point your existing SDK at https://inference.celeris.ai/celeris-1/v1, change the model name, and keep the code you already wrote. Celeris describes it as three lines to swap.

client = OpenAI(
    base_url="https://inference.celeris.ai/celeris-1/v1",
    api_key=CELERIS_API_KEY,
)

stream = client.chat.completions.create(
    model="celeris-1",
    messages=[{"role": "user", "content": "..."}],
    stream=True,
)

Because the interface is the standard chat-completions API, celeris-1 slots into agent frameworks and orchestration tools that already speak it — LangChain, LlamaIndex, the OpenAI SDKs, or a hand-rolled tool-use loop — as a configuration change rather than a rewrite. Streaming is on by default, so existing streaming UIs keep working too.

Who should test Celeris-1?

Celeris-1 is worth testing when agent loops, routing calls, extraction, or interactive generation are blocked by model latency. The current evidence is provider-run, so teams choosing primarily on accuracy, reliability, or tool use should reproduce representative tasks before moving production traffic.

The model is available through the Celeris console. The Celeris-1 model page and Celeris provider page collect the current listing data.