AI for everyone
In the myth, Athena — goddess of wisdom and knowledge — gave humanity the olive
tree: a gift that feeds generation after generation and asks only to be tended.
The logo is that tree, with roots made of circuits. It stands for the
commitment behind this project: to use knowledge with wisdom, so that its
fruits belong to everyone.
The most capable language models live in someone else’s data center. Using them
means an account, a bill that grows with every word, a usage policy you did not
write — and every prompt, document and line of code leaving your hands. Running
them yourself has meant racks of GPUs that almost nobody owns.
Athena’s Engine exists to change that.
Frontier-class models. On a desk. At a thousand tokens a second.
It runs DeepSeek V4 Flash and Qwen3.8 Flash Next on a single NVIDIA GB10 — a
DGX Spark or an ASUS Ascent GX10 — with the full 262,144-token context and no
cloud account, no per-token bill, and nothing leaving your machine. It is out
today.
docker pull ghcr.io/xangel82/athena-engine:0.1.0
It reads a 700-page book in four and a half minutes
Prefill, timed by the server on a fresh prompt:
| Prompt | DeepSeek V4 Flash | Qwen3.8 Flash Next |
|---|---|---|
| 8k | 1,126 tokens/s | 1,071 tokens/s |
| 32k | 1,094 tokens/s | 1,065 tokens/s |
| 64k | 1,071 tokens/s | 1,046 tokens/s |
| 128k | 1,005 tokens/s | 1,016 tokens/s |
| 196k | 983 tokens/s | 989 tokens/s |
| 256k | 948 tokens/s | 961 tokens/s |
Thirty-two times the context, ten per cent of the speed. The rate barely moves
between a short prompt and a quarter of a million tokens.
It does not slow down as the conversation grows
Generation, 256 tokens at temperature 0, timed from the first token:
| Context | DeepSeek V4 Flash | Qwen3.8 Flash Next |
|---|---|---|
| 8k | 21.4 tokens/s | 29.9 tokens/s |
| 128k | 19.9 tokens/s | 30.9 tokens/s |
| 256k | 19.4 tokens/s | 32.1 tokens/s |
Read that sideways, not down. It is flat. A quarter-million-token session
answers as fast as a fresh one. No cliff at the end of a long day’s work.
It never reads the same conversation twice
A 141,519-token conversation comes back in 2.1 seconds — against the 2
minutes 20 seconds its first reading took.
Context is kept on disk and restored instead of re-read. The file is 619 MB and
it is written while the session is idle, so the answer in progress pays nothing
for it. A new question on a known context, a long agent session, a restarted
server: all resume instead of prefilling again.
And it does what it is told
Both models through tool-eval-bench
— 69 deterministic scenarios: picking the right tool out of fifty-two, chaining
calls, knowing when not to call anything, recovering from tool errors,
returning JSON that fits a schema.
91 out of 100 — ★★★★★ Excellent — for both, from models quantised to two
and four bits, on a desktop machine.
One scenario beats both, and it is worth naming rather than hiding: a tool
result carrying an instruction aimed at the model leaks into the answer. Treat
tool output as data, not orders, in whatever you build on top.
Two frontier models. One engine. One name.
| Model | Weights | Context | Speculative decoding | Images and documents |
|---|---|---|---|---|
| DeepSeek V4 Flash | IQ2_XXS mix, Q8 projections and shared experts | 262,144 tokens | DSpark sidecar | — |
| Qwen3.8 Flash Next | Unsloth UD-IQ4_XS | 262,144 tokens | MTP head | images, PDF, DOCX, Markdown, HTML, text |
Install both, and a conversation calls the other one in by writing a message:
%switch deepseek
The engine drains what it is serving, flushes its checkpoints, releases the
running model, checks the memory is really there, loads the other and answers
from it — writing every step into the reasoning channel as it happens, so you
watch it instead of staring at a blank screen. 46 seconds, measured. The
engine never stops. If the new model cannot be loaded, the previous one comes
back.
And the API serves one single name — Athena — whichever model is behind it.
Configure your clients once; they keep working when the model changes.
The rest of it
- Speculative decoding with no quality trade. DSpark drafts ahead and
verifies exactly: the output is identical to ordinary decoding, only faster. - Agents that keep their place. Tool-calling conversations resume from the
cached prefix turn after turn, and pick up from disk after a restart — even
when the client rewrites call identifiers or drops the model’s reasoning. - It reads pictures and documents. Images, PDF, DOCX, Markdown, HTML and
plain text, the way the OpenAI API sends them. - Drop-in API. OpenAI- and Anthropic-compatible, with streaming, tool
calls, forcedtool_choice,parallel_tool_callsandresponse_format— on
both models.
Run it
docker run -d --gpus all --ulimit memlock=-1 -p 30007:30007 \
-v /path/to/models:/models:ro \
ghcr.io/xangel82/athena-engine:0.1.0
Or on the metal:
./athena-engine/install.sh # asks which model, or --model both
source models/athena.env
./athena-engine/athena-engine.sh
The installer uses model files already on your machine, downloads only what is
missing, verifies every file against the published checksum, and resumes —
stop it, run it again, it carries on. DeepSeek’s DSpark draft head is not
published as a file anywhere: the installer builds it on your machine from the
three official weight shards, with a converter that ships in the archive.
Every figure above comes from one GB10 with 128 GB of unified memory, one
request at a time, each model in the configuration the launcher ships.
Measured 2026-09-18 — the raw CSVs and the full tool-calling transcripts are in
the repository, and the engine stands on open work that
CONTRIBUTIONS.md
names one by one.
Advanced AI should not be the privilege of whoever owns a data center. One
machine on a desk is enough.
Got a GB10? Run it and post your numbers. Results from a second machine are
worth more than anything I can publish from mine.
