One Estate, Six Doors

One Estate, Six Doors

Most open-source AI tooling is a box of parts from different workshops. Ours comes out of one monorepo, runs on one identity plane, and is operated every day by the same fleet that produced it. Four of those pieces are public, and each one is independently useful the moment you install it.

The interesting claim is not any single repo. It is that the agent SDK, the skills those agents load, the cache that makes their inference affordable, and the automation that builds the machine underneath are one system — and you can take any of them on its own.

Here is the estate.

Aither ADK — agent fleets in three lines

pip install aither-adk. That is the install story, and adk quickstart detects your hardware, pulls what it needs and configures the backends.

The design decision that makes ADK different: the backend is configuration, not architecture. The same agent code runs against a local GPU, against Ollama, or against a cloud API. You change a line of config, not your program. Most frameworks bind you to one provider and call it an integration; ADK treats the provider as a detail, which is what it is.

On top of that sits effort-based routing. You declare how hard a task is and the selector picks a model to match. Trivial work does not pay frontier prices. At the volumes a real agent fleet runs, that is not a rounding error — it is the difference between a demo and a margin.

Then there is genuine multi-agent work — an orchestrator that evaluates a task, picks a specialist, delegates with context, watches it run and synthesises the result. Agents calling agents, with their own state and their own tools.

from adk.forge import Forge, ForgeTask

forge = Forge()
result = await forge.dispatch(ForgeTask(
    agent_type="auto",
    task="Audit the auth module for injection vulnerabilities",
))

And it ships six brain packs — an identity, a system prompt, tools and skills bundled into one unit you hand an agent wholesale. Not a prompt file. A working specialist you can drop into a fleet.

aither-skills — 55 procedures an agent can actually execute

Fifty-five MIT-licensed skills, each a single markdown file, each precise enough that an agent can follow it without a human in the loop.

These are not prompt templates and they are not aspirational best practices. They are operational knowledge from a fleet that runs in anger: how to tell whether a deploy is genuinely live rather than merely green, how to recover a wedged resolver, how to do concurrent git in a tree several agents are writing to at once, what never goes near a commit.

Every one of them exists because the knowledge was expensive to acquire and had to outlive the session that acquired it. That is the whole value: you are not getting someone's theory of how to operate infrastructure, you are getting the writeups.

Zero dependencies, no runtime, no framework. A skill is a file. Any agent that can read text can load one, which is why the pack is agent-agnostic on purpose — the content is the product.

aither-kvcache — sub-byte KV cache, no calibration

The KV cache is usually the reason you cannot raise your context length or your batch size. TurboQuant compresses it to 2–4 bits, 3.8–7.1× against fp16, provably within 2.7× of the information-theoretic optimum — with no calibration dataset and no offline profiling pass before you can use it. It works on streaming tokens.

Put real numbers on it: a 70B-class model with grouped-query attention at 128K context needs 40 GB of fp16 KV cache. At 4 bits that is 10 GB. That is the difference between "needs a datacentre" and "runs on the GPU you already bought" — and there is a calculator on the page so you can put your own model in and watch it move.

There is a second engine. TriAttention keeps the top RoPE frequency pairs and scores through a trigonometric series without ever materialising full K/V — around 10× with bounded error. It is calibrated for the Qwen3.5 family.

TurboQuant implements Zandieh et al., arXiv:2504.19874. Published method, citable, not a black box. A vLLM plugin and fused Triton kernels are one pip install extra away.

AitherZero — automation that is discoverable

PowerShell 7+, cross-platform, and built on one idea that turns out to matter enormously at scale: every script is numbered and describes itself.

Get-AitherScript lists the entire catalogue with each script's synopsis and parameters, parsed out of the file itself. You search the catalogue instead of remembering filenames. Invoke-AitherScript 1002 resolves and runs a script wherever it lives in the category tree, with -WhatIf support.

Playbooks are .psd1 data files describing ordered steps — so a deployment sequence is something you review as data rather than reverse-engineer out of control flow. Invoke-AitherPlaybook node-onboard enrols a machine as a secure cluster node on Windows, Linux or macOS from one command.

The same scripts, the same playbooks, every OS.

They compose

ADK runs the agents. The skills are what those agents reach for when they have to do something operational. kvcache is why a long-context agent fits in hardware you own. AitherZero is what turns a bare machine into a node that can run any of it.

Pick one up alone and it works. Pick up two and they already know about each other.

Every page is generated from the code

Here is the part we are quietly proudest of.

Nothing on those four sites is hand-written prose about what the code supposedly contains. Every page is generated on every sync from the tree being published — and then a gate asserts the published page back against that payload. The stat tiles, the design tokens, the catalogue, the links.

The version number on the ADK page is read from pyproject.toml. The skill count is a count of the skills actually shipping. The script catalogue is parsed from the scripts. If a number on a marketing page and the code disagree, the build fails.

That gate has a --self-test with thirteen cases that deliberately feed it stale and broken pages and require it to reject every one — because a checker nobody has watched fail is not a gate, it is a decoration.

We hold our own marketing copy to the standard we hold production code. Almost nothing on the internet clears that bar, and it costs us nothing to clear it because the machine does the work.

The catalogue is the product

So each site carries a live artifact built from what is actually being published.

The skills page lists every skill, searchable in the page, each row opening the real file — with the summary parsed from the skill's own heading. Type dns and watch fifty-five collapse to the one you want. AitherZero lists every numbered script with its synopsis, filterable by category. ADK lists its brain packs. kvcache gives you the calculator.

You are not reading a brochure about a catalogue. You are using the catalogue.

Six doors

The four repos, aitherium.com and the blog now render as one constellation on every page — the door you are standing in lit, the others reachable, arcs between them. Each repo is a named place with its own accent, the same way every sovereign agent on aitherium.com is a place: Demiurge is not "the code agent", it is The Forge, and it greets you with what shall we forge?

The skills pack is The Armory. ADK is The Forge. kvcache is The Crucible. AitherZero is The Range.

One CSS variable re-themes an entire page, so the estate can grow a fifth and sixth door without anyone maintaining a fifth and sixth design. AitherConnect and the node runtime are next through it.

What is coming

The shared design layer is now the seam where all four get better at once. The constellation renderer already speaks the node shape of our real force-graph universe explorer, so when it should show live fleet topology instead of six fixed doors, it swaps without touching a line of markup.

Next: quickstarts that run against a real machine rather than describing one, skills that render inline instead of handing you off, and the remaining doors brought into the estate.

Four are open now. Start wherever you like — they all lead to the same place.

• Aither ADK · pip install aither-adk
• aither-skills · 55 skills, MIT
• aither-kvcache · 2–4 bit KV cache
• AitherZero · PowerShell 7+, MIT