Celeris 1: A Diffusion Model for Short AI Tasks
Most current chat models generate text one token at a time. Each new token depends on what came before it. Celeris 1 instead uses a diffusion-based process that can refine multiple text positions in parallel.
The difference matters when an answer is one step in a larger workflow. A routing decision, classification, search-query rewrite, or short extraction may delay everything that follows it. Celeris reports model-server times measured in milliseconds; our small NanoGPT check later in this article measured the complete request in seconds.
Celeris 1 has an 8,192-token window shared by the prompt and answer. That makes it a candidate for short decisions and transformations rather than large document sets or long conversations.
Text diffusion in plain language
An autoregressive model commits to its output in sequence. Once it has generated the beginning of a sentence, every later token depends on that path.
A diffusion language model starts with incomplete text positions, similar to a line containing placeholders, then fills and revises several positions over a series of passes. The process is related to the denoising idea used by diffusion image models, but the model and output are text-specific. It can reconsider multiple parts of the answer instead of waiting for each earlier token to be finalized first.
Model size, the number of refinement steps, serving hardware, network distance, and application overhead still determine the final delay. Celeris attributes its reported server speed to both the model and the system running it; the published comparison cannot isolate how much comes from diffusion itself.
The published speed and accuracy results
Celeris assembled a six-model comparison on MMLU-Pro, a multiple-choice benchmark covering fourteen subjects. Five accuracy scores came from its July 2026 run; the Gemini 2.5 Flash score came from an earlier external result. Most models received five example questions with written reasoning and strict answer formatting. Separate API reasoning budgets were disabled to favor low-latency configurations.
| Model | Accuracy | Median duration | Measurement note |
|---|---|---|---|
| Celeris 1 | 75.9% | 158 ms | Celeris run; server processing time |
| Gemini 3.5 Flash Lite | 83.0% | 1,232 ms | Celeris run; end-to-end time |
| GPT-5 | 81.9% | 2,046 ms | Celeris run; server processing time |
| GPT-5 mini | 78.5% | 2,495 ms | Celeris run; server processing time |
| Gemini 2.5 Flash* | 73.0% | 2,600 ms | External accuracy; Celeris end-to-end timing |
| Mercury 2 | 63.7% | 257 ms | Celeris run; different prompt; server processing time |
In the provider's table, Celeris 1 scored 2.6 to 7.1 percentage points below the three higher-scoring models. Its listed duration was the lowest, but the timing basis differs for the Gemini entries, so the figures do not support a clean speed ranking across all six models.
* Celeris used a previously published external accuracy score for Gemini 2.5 Flash after the model failed its required answer format. The 2,600 ms timing came from Celeris's own run, so the two figures in that row were not measured together.
Celeris separately reports a median output rate of 1,664 tokens per second for requests whose answers were around 1,000 tokens. In the same provider test, Mercury 2 reached 324 tokens per second and Gemini 3.5 Flash Lite reached 224. Each model received 50 requests with output capped at 1,024 tokens. A high token rate helps a long answer finish quickly; the complete response time matters more for a single-label answer.
How to read Celeris's benchmark
These are Celeris's own results, not an independent comparison. The timing is also model-server time for most entries rather than the full delay a NanoGPT user will experience.
The methodology was not identical for every model:
- Reasoning budgets were disabled to favor each model's fastest configuration.
- Mercury 2 received no worked examples and was explicitly told to reason after performing poorly with the five-example format used for the other models.
- Gemini 2.5 Flash failed the required answer format in Celeris's run, so the table uses a previously published external accuracy score instead.
- The Gemini timings were measured end to end from a client placed near the model server because their endpoints did not expose server processing time.
These differences rule out treating the table as a controlled ranking. The useful claim is narrower: Celeris reports 75.9% accuracy and 158 ms of server processing time for its own model under this setup.
A small check through NanoGPT
We sent three short prompts to Celeris 1 through NanoGPT's Chat Completions API on July 28, 2026, waiting for each complete answer rather than streaming it. The prompts covered support-ticket classification, invoice-field extraction, and selecting the correct answer to a multiplication question. Each ran three times with randomness minimized and a 256-token output allowance.
All nine responses were correct. The classification and answer-selection results followed the requested one-token format. The extraction runs returned valid JSON with the expected invoice, currency, and amount. The spacing and number formatting differed from the compact example, which is harmless for a JSON parser but would fail an exact string comparison.
Median end-to-end time was 2.03 seconds, with individual requests ranging from 1.51 to 2.69 seconds. This is not a reproduction of Celeris's 158 ms figure. Our measurement included the network trip, NanoGPT authentication and billing, and the complete response. We did not run a comparison model through the same path, so this test does not isolate Celeris's speed from application overhead.
The nine calls used 414 prompt tokens and 129 completion tokens. At NanoGPT's listed rates, that works out to about $0.0016.
This was a nine-request API and format check from one client during one test window. Three easy prompts cannot establish latency, general capability, or repeatability on ambiguous classification, noisy documents, or domain-specific scoring.
What NanoGPT currently supports
Use the model name celeris-1 in the app or Chat Completions API. NanoGPT currently supports text requests and streaming. The prompt and answer share an 8,192-token window. A 7,000-token prompt leaves 1,192 tokens of headroom; the API's 256-token block rule reduces the usable output allowance to 1,024.
For API requests, max_tokens must be a positive multiple of 256. NanoGPT uses 2,048 when no value is supplied and reduces the allowance when the prompt leaves less space in the shared window.
Tool calling, image input, and reasoning controls are not available for this model. Celeris promotes structured tasks as a core use case, but NanoGPT does not currently enable API-enforced structured output through response_format; request JSON or another concise format in the prompt and validate the response in your application.
Price and suitable tasks
NanoGPT lists Celeris 1 at $2 per million input tokens and $6 per million output tokens. Its economic case depends on short answers and on whether lower latency improves the surrounding workflow.
Candidates to benchmark include:
- Assigning one of a fixed set of labels
- Extracting a few fields from short text
- Rewriting a user question into a search query
- Scoring or ranking a small set of options
- Checking whether an answer meets a compact rubric
- Producing a short summary that another step will consume
Tasks that exceed the shared context window or require native tools are a poor fit. A workflow can use Celeris 1 for a short decision or transformation, then pass the result to another model when it needs broader context or tools.
