Ship a landing page
Design tokens, one accent, mobile-first — and live-verified with a headless screenshot before it’s called done.
fabius is the agent; the model is the engine. Claude, GPT, Gemini, Mistral, DeepSeek, Llama, Qwen, Kimi, Grok, and more can follow the same instructions, skills, memory, safety, and verification loop — through a direct provider, a model router, or a local Ollama runtime.
fabius instructs the selected model executes fabius verifies
Watch · the 25-second explainer
Watch one task become a fabius operating contract, move through the selected model, and return through verification and memory — end to end.
01The architecture
fabius sits above the model. It does not replace or retrain Claude, GPT, Gemini, Mistral, DeepSeek, Llama, Qwen, Kimi, Grok, or any other selected model. It gives that model the operating instructions: what to investigate, which skill owns the work, when to act, how to verify, and what to remember.
Scout wide in what you investigate. Strike narrow in what you ship. The selected model supplies capability; fabius supplies the discipline.
02The loop
You choose the engine; fabius supplies the behaviour. Every model receives the same five-beat loop — investigate broadly, plan deliberately, ship narrowly, prove the result, and keep what was learned.
Fan out to understand and verify. Cheap to look, expensive to be wrong.
Weigh the load. Pick the layers, the machinery, and the cheapest model tier that holds.
Ship the single smallest correct thing. Say it in the fewest words. Nothing speculative.
Run it. Show the evidence — a test, a screenshot, a check. Never “should work.”
File what was learned into memory, so the next run starts ahead — not from zero.
03The system
fabius owns the operating contract: one router, an always-on lean core, thirteen specialist layers, shared memory, and verification. Eight runtime paths connect it to direct providers, model routers, and local Ollama models. Swap the engine — DeepSeek, Claude, GPT, Llama, Qwen, Kimi, Grok, or another compatible model — and the instructions and standards stay.
The same run, seen by its rules: the stages the router moves through, each answering to one researched rule — so the behaviour is a documented decision, not a mood.
Each routing rule comes out of fabius’s own research — derived, pressure-tested, and proven to cohere. Below, the shape of the principle behind three of them.
Capability scales sub-linearly with machinery. Climb one rung — inline → tool → retrieval → plan → subagent → swarm — and stop at the knee.
A call must earn its place. Route to the tool, the reviewer or the subagent only once the expected loss it removes clears its cost.
Plan in placeholders; bind the calls last. Independent tool and sub-agent calls run in parallel, not down a chain — latency stays flat as the work fans out.
Add a tool? Spawn a reviewer? Branch wider? Retry once more? Under the hood fabius asks one question — does the expected loss removed beat the cost of the machinery? That single threshold governs the twenty-two proven routing rules — and the researched frontier layer beyond them. Scout wide, strike narrow — as arithmetic.
The gap on the left is the value of information. Below the threshold the machinery is pure overhead; fabius stays inline. (rules R3 · R7 · M1 · M4 — one object, different machinery.)
Worked example — should fabius add a reviewer?
18 points of loss removed — more than one agent costs. So fabius spawns the reviewer: two decorrelated passes beat one. (rule M1)
Process picks how, domain picks what — fabius-parcus, the lean core, runs beneath all of it. Twenty-two proven rules, each adversarially verified and shown to cohere.
04What you can hand it
Hand fabius the whole job. It reads the task, selects the skills, gives the operating plan to the chosen model, and holds the run to the same loop — scout, strike, prove, record.
Design tokens, one accent, mobile-first — and live-verified with a headless screenshot before it’s called done.
STRIDE per trust boundary. Each finding ships a severity, a fix, and a regression test that runs red → green.
Out-of-sample, costs modeled, risk sized first. Analysis, never advice — and no look-ahead leak.
Least privilege, a precise output contract, and the smallest orchestration that holds — up to a swarm.
One note, one index pointer, interlinked — recalled cold next session, so it never re-derives it.
Core loop first, deliberate juice, a jam-sized cut that actually ships — and is actually fun to play.
Discover from the live schema, build incrementally, verify the wiring before it runs live — no silent miswire.
N models answer blind → anonymized peer-review → a chairman synthesizes one better answer. For the costly calls.
Reproduce → root cause → the minimal fix, locked by a regression test. Not a symptom patch.
FABIUS · CENTRAL INTELLIGENCE UNIT
scout wide · strike narrow
One stance handed to the agent. It investigates the whole field, then commits — fully — to the single battle that decides the war.
05Grounded in research
fabius’s routing is our own research — a whole field of agent behaviour investigated, convened, and forged into a documented decision policy: twenty-two proven rules, each one derived and adversarially verified, coordinating fifteen skills without contradicting one another.
inline → tool → retrieval → plan → subagent → swarm), never jump to a swarm.The shape of a principle from fabius’s research: capability scales sub-linearly with machinery — climb to the knee, then stop.
06Talk to it
Speak naturally. fabius detects the language, turns the request into a clean task, and reads the answer back in the right voice.
“Audit this repository, fix the real issue, and show me the proof.”
$0.0005 per audio-minute in the console.07The model layer
Eight implemented runtime paths connect fabius to direct providers, model routers, and local inference. Name the model; fabius supplies the same scope, routing, skills, safety, memory, and verification contract, then keeps the run accountable from the first decision to the final proof.
Fable 5 · Opus 4.8 · Sonnet 5 · Haiku 4.5
GPT-5.6 Sol · Terra · Luna
Gemini 3.5 Flash · 3.6 Flash · 3.5 Flash-Lite
Large · Medium · Small
GPT-OSS 120B · GPT-OSS 20B · low-latency path
Custom repository IDs · routed open-model inference
Custom model IDs · hundreds of routed model choices
Qwen Coder · Llama · private local model IDs
Choose a custom model ID through OpenRouter or Hugging Face, or point Ollama at a local model. Catalog availability follows the route you select.
Provider, platform, and model-family marks identify compatible routes only. Availability depends on the selected catalog or local runtime; no affiliation or endorsement is implied.
08On your machine
Run fabius beside the repository: same router, rules, and memory — with filesystem access contained to the working directory and every irreversible action held for approval.
$ fabius run "write the README this repo is missing"$ fabius recon averya.co.il$ fabius listen --owner npub1…--act is explicit.ready when you are
Hand fabius the job. It writes the operating contract, routes the right skills, and gives it to the model you selected. The model executes; fabius verifies and remembers.
1 hand fabius the task — choose a model engine
2 fabius instructs — the model executes — fabius proves
Private, cryptographically sealed brain · eight runtime paths · custom router and local model IDs · every run logged and reviewable.
09Questions
fabius is an autonomous agent layer that sits above the model. It gives Claude, GPT, Gemini, Mistral, DeepSeek, Llama, Qwen, Kimi, Grok, Command, and other compatible models the same operating brain: instructions, routing, fifteen coordinated skills, memory, safety and verification. The selected model remains the execution engine; it follows the fabius contract from the task to the proof.
Open the synapse console, hand fabius a task, and choose the model engine. fabius scopes the job, routes the right skills, gives the operating contract to the selected model, verifies what it returns, and records what mattered. Every run is logged and reviewable.
Yes — and it is the same agent, not a cut-down one: same router, same rules, same contracts, read off disk and handed to the model. A console has no filesystem, so it cannot read the repository you are working in and the task leaves the building; running locally fixes both. It writes nothing and runs nothing until you allow it, the working directory is a boundary it cannot escape, secrets and key files are refused outright, and even in fully autonomous mode it still stops and asks before anything that cannot be undone — a push, a production deploy, a recursive delete. When it hands you code it runs that code first, and a failing exit overrules its own review. It also audits any domain you own without an API key, and can be reached by encrypted message with no server in between.
Yes — in any language. Speak to it in the console instead of typing: it detects the language itself, so you never pick one from a list, and the transcript comes back punctuated and clean. It then reads its answer back out loud — Hebrew in a Hebrew voice. Being straight about the boundary: the mic that covers ~99 languages runs on the console’s own speech service — not on a model key — and costs about $0.0005 per audio-minute, billed to whoever runs the console; outside a console it falls back to the browser’s own speech engine — free, but that is the browser’s language coverage, not ~99. Connect it to Telegram and you can send it a voice note there too.
fabius implements eight runtime paths: Anthropic, OpenAI, Google, Mistral, Groq, Hugging Face, OpenRouter and Ollama. Custom model IDs through the two routers, plus local IDs through Ollama, extend that field to DeepSeek, Llama, Qwen, Kimi, Grok, Cohere Command and many more models exposed by the selected catalog. Availability follows the provider or local runtime you choose; the same fabius brain remains in control.
No. fabius’s brain — the fifteen skills, the routing policy, the memory — is private and cryptographically sealed (SHA-256 + a Merkle root anchored to Bitcoin). The seal is proof of authorship if anyone ever copies it.
It does not retrain or alter the base model. It adds the operating brain around it: instructions, routing, specialist skills, memory, safety and verification. The selected model follows that contract, so the same model can work more consistently and with less waste. In the benchmark — blind, judged against both a bare baseline and a generic “be concise” control — every capable tier (Fable 5, Sonnet 5, Opus 4.8) beats both controls on the four Claude models measured (the roster current at the 2026-07-01 run). Under fabius the smallest model passes 93% of real tests and factual checks vs 75.6% bare, and parameterized SQL goes 67.5% → 100%, on 20–35% less output. The fast tier’s dip on trivial one-liners remains printed as-is.
Against its own written contract. The identity is fixed in the brain: fabius is an intelligence amplification layer, so the only fair question is whether the exact same model achieves better outcomes with less waste. The Fabius Benchmark Suite runs 100 neutral, production-shaped tasks in three modes — bare model, under the shipped fabius files, and with recalled memory added — scored by two blind judges and objective per-task checks. Latest run: the fast tier climbs 25.27 → 26.00 → 26.73 of 28 on 11–14% less output; the mid tier holds 93% quality on 10–12% less output. The misses are printed in the receipt, not hidden.
That is exactly the control it was tested against — and it wins. fabius is structure, not brevity: a scope-control system that knows when to compress and when to expand. Method and caveats are in the whitepaper.
Yes — on content you own. Before anything ships, fabius runs a deterministic hygiene pass: invisible Unicode — zero-width characters, bidirectional marks, tag characters, the same character classes Trojan-Source attacks hide in — is stripped from generated text and code, and file metadata (EXIF, XMP, C2PA, document properties) is cleaned from images and documents with standard tools. Two boundaries, stated straight: statistical text watermarks live in the wording itself, so removing them means rewording — which degrades the copy — and no tool can certify that a vendor’s detector will fail afterwards, so fabius never promises that. The other direction is the point: fabius adds verifiable provenance to your own work — a content-bound seal anchored to Bitcoin — rather than erasing anyone else’s.