Celeris-1 Delivers 1,664 Tokens Per Second

Celeris-1 is a diffusion‑architecture language model. It generates 1,664 tokens per second. Median latency sits at 158 ms. And it scores 75.9% on MMLU‑Pro. The same benchmark territory where GPT‑5 lives.

Honestly, those numbers kinda speak for themselves. But here's the practical takeaway: stuff that used to clog your pipeline. Classification, routing, extraction. Feels instant now. Not "fast enough." Instant. Multi-step agents that used to stall out waiting on each token can actually breathe.

Older autoregressive models train you to expect lag.

You learn to work around it.

Celeris-1 just... removes the wait.

How Diffusion Decoding Works

Normal LLMs do one thing. They predict the next token. Then the next. Then the next. Serial. Slow by design.

Celeris-1 throws that out.

Instead of token-by-token generation, it runs a diffusion process. Starts with a rough full-response draft and refines it over several passes. Each step can touch multiple parts of the response at once. Think of a blurry image sharpening into focus.

Tbh this is the part that took me a minute to wrap my head around.

The model isn't streaming tokens at you. It's producing the whole answer, then cleaning it up. In milliseconds.

The architectural shift here matters because it kills the serial dependency problem. Each token doesn't have to wait for its predecessor. Parallel compute finally gets stretched properly.

Celeris-1 Speed Numbers in Context

The headline claim is 1,664 tokens per second. Launch benchmarks report a median of 1,626 tokens per second.

Close enough that the variance doesn't change the story.

For a 1,000-token prompt, Celeris-1 finishes output in 0.58 seconds. That's not "fast for an LLM." That's fast for a database query. Most API round-trips take longer than the generation itself at that point.

Real talk — I've spent enough time watching agent pipelines hit timeouts on simple routing decisions to know this changes the math.

When your model returns in under a second, you stop building retry logic and start building actual product.

Celeris-1 vs GPT-5 on Benchmarks

GPT-5 is the obvious comparison point.

Both models land in the same neighborhood on MMLU‑Pro — Celeris-1 at 75.9%. That's a reasoning benchmark, not a speed test. So the fact that a diffusion model hangs with an autoregressive giant on quality is notable.

The difference shows up in latency.

GPT-5 streams tokens. Celeris-1 returns complete responses. Different architecture, separate UX implications. If you're building something where users wait for output, sub-second changes everything about how the interface feels.

Side note: benchmark numbers always need context.

MMLU‑Pro tests multi-domain reasoning.

It doesn't tell you about creative writing quality or code generation depth. Treat the comparison as directional, not definitive.

Use Cases for Sub-Second Responses

Classification and routing are the obvious wins.

You send text in, you get a label back before your finger leaves the enter key.

Extraction too. Pulling structured data from unstructured input without blocking your pipeline.

But the more interesting stuff is multi-agent orchestration. Agent loops that call other models break down when each hop adds 2-3 seconds of latency. Four hops and you're at 10+ seconds. Celeris-1 compresses that whole chain into something a user can actually sit through.

Real-time use cases that weren't practical before:

- Live conversation agents that need to reason before responding - Interactive tools where users iterate quickly on outputs - High-volume classification pipelines that couldn't afford per-query latency - Multi-step extraction where each stage depends on the prior output

Honestly the pricing and availability details aren't fully public yet. Worth checking the official sources for current access info. That picture is still moving.

Frequently Asked Questions

What is a diffusion language model?

A diffusion language model generates text using a refinement process borrowed from image generation.

Instead of predicting tokens one at a time, it starts with a rough draft of the entire response and sharpens it through multiple passes. Think blurry-to-clear, not left-to-right.

How fast is Celeris-1?

Celeris-1 generates 1,664 tokens per second with 158 ms median latency. For context, a 1,000-token output completes in 0.58 seconds.

How does Celeris-1 compare to GPT-5?

Both score in the same range on MMLU‑Pro (Celeris-1 at 75.9%). The core difference is architecture. Diffusion vs autoregressive. Which affects speed and how responses are delivered.

What makes diffusion decoding other from normal LLMs?

Standard LLMs predict tokens serially. Each token waits for the one before it. Diffusion decoding refines the full response in parallel passes, removing that serial bottleneck.

Sources

Celeris-1 diffusion decoding architecture documentation Multi-region response refinement technical overview MMLU-Pro benchmark results, Celeris-1 launch evaluation Launch benchmark speed measurements, median tokens per second Comparative benchmark data, GPT-5 vs Celeris-1 MMLU-Pro scoring methodology and model performance summary Visual analogy reference for diffusion-based text generation