Eirenaeus-Philalethes

Several layers, one model. A 421M-parameter decision model on the CPU decides, in about half a second, how much a 27B reasoning model on the GPU should think, stops its thinking when it starts going in circles, and gives it the few memories that matter. Same weights, same quality, measurably faster. One OpenAI-compatible endpoint, one model id, one consumer GPU with 12 GB.

What this is

The most interesting part of this project is not the model. It is the way of joining different layers (a fast decision model, a reasoning model, a supervisor, a verified memory) so that from the outside they behave as one single model.

This is the initial state. The benefits of building models this way are still to be discovered: the numbers below are what I measured on day one, with the open models available today. I will keep applying this architecture and refining it with new models as they come out.

Measured, paired, at temperature 0

Against Ternary-Bonsai-2-27B served alone on the same machine, same questions, same checkers (McNemar exact test on the problems where the two disagree). This package, exactly as you download it, installed with its own installer, at temperature 0; times count only problems that ran with nothing else on the GPU:

The full system described in the whitepaper (my own setup, with more context and more benchmarks):

No significant quality difference on any benchmark, in either setup.

Also measured, and reported as it came out: tool calling (BFCL v4, 400 calls) is a tie with no speed advantage, and on images (MMMU-Pro, 200 unseen questions) it is within noise of the base model (130 vs 137, p = 0.23). The full method and every table are in the whitepaper.

The benchmark client I used ships in bench/, with the frozen question splits. Build your own tests and draw your own conclusions.

How it works: a fast System 1 beside a reasoning model

When System 1 is unsure, System 2 answers instead; in my setup that answer is logged as a training label for System 1, so the fast model can learn from the slow one. Neither model's weights are changed.

Others have explored the same pattern (the vLLM Semantic Router decides per request whether a served model should reason; see the whitepaper's related work). This design was reached independently; what it adds is the pattern packaged as one local model on one consumer GPU, with a loop supervisor and a verified memory, measured pair by pair against the same model alone.

It tells you it understood, then works. A request that needs thinking gets, in about one or two seconds, one short sentence in your language saying what it understood and that it is starting ("Understood: I need to build a double pendulum in one HTML file. Starting right now, give me a moment."), while the reasoning runs. Never on benchmark requests; EIRENAEUS_FIRST_WORD=0 turns it off.

It talks first, and works on a yes. Small talk gets a quick reply with no thinking and no tools. When you describe something to do, it asks once whether to start; a short yes ("dale", "go ahead") starts the work with thinking and tools.

What's new (October 8)

• Better use of System 1's doubt. The decision layer is unsure on more than half of the requests. Instead of "unsure, think deeply", it now takes the cheapest effort that covers most of its own probability, talks first when a short message has nothing to work out, and keeps deep thinking for code it is unsure about. On a routing exam it had never seen: 99% right against 84% before, with 22% less thinking budget. HumanEval+ routes are unchanged; the 9 held-out problems that changed route solved the same, 1.49x faster.
• Talk mode, measured on 87 real requests: small talk answers in about 0.8 s; commands reach the client's tool in about 2.6 s.
• Safer with agent clients. A tool call repeated with the same failing result is stopped instead of looping.
• A long client prompt (Pi, Hermes) is read once, not twice, on the first message: about 22 s less with a 25K-token prompt.
• Memory comes with the model. The installer brings Engram and creates your memory store; Eirenaeus reads all of it by default (it is yours and never leaves the computer). Let your agents save to it with engram setup pi (or claude-code, opencode, codex, ...). An Engram you already have is left exactly as it is.

Already installed? Use Stop Eirenaeus, then run the installer again: it checks every file and downloads only what changed.

Install (Windows, NVIDIA GPU with 12 GB)

Download Install Eirenaeus.cmd and double-click it. It checks the computer (NVIDIA GPU with 12 GB, driver 580+, about 20 GB free), downloads everything from this one repository (about 9 GB, pinned versions, every file checked by sha256, resumable), installs its own private Python, and puts an Eirenaeus icon on the Desktop. The icon opens a local chat page; Stop Eirenaeus is in the Start menu. Nothing leaves the computer.

Other apps (Pi, Hermes or any other CLI or OpenAI-compatible client): base URL http://127.0.0.1:8090/v1, model Eirenaeus-Philalethes. Clients that bring their own tools (a browser automation, a file system) keep them: Eirenaeus decides when to call them.

Limitations

• One machine, one GPU class, one base model: the speedup belongs to this setup until measured elsewhere.
• Short requests carry about half a second of decision overhead; the gain is on problems the core would think long about.
• Memory starts empty: today it fills when your agents save to Engram (engram setup <agent>); a memory Eirenaeus writes for itself is next on the roadmap. Memories marked personal are never read. To narrow what it reads, list projects or private words in eirenaeus/data/memoria/engram_sources.json: {"projects": ["my-project"], "private": {"health": ["my doctor"]}} (private words keep a memory out entirely).
• Windows only for the installer today; the gateway itself is plain Python.

Credits and licenses

Apache-2.0, by Asastu. Built on Ternary-Bonsai-2-27B by Prism ML (Apache-2.0, derived from Qwen3.8-27B), Laya by ConvAI Innovations (Apache-2.0, ModernBERT-large backbone), the Prism fork of llama.cpp (MIT) and uv by Astral. Memory inspired by Engram by Gentleman Programming; validity rules after Dokimos. See NOTICE and VERSIONS.json.