Start · Aitherium Foundation
Build with agents. Start on the machine in your pocket.
Eight steps, in order. Every one runs on hardware you already own, needs no account, and says three things: what you need, what you type, and what you will see. A step that does not say what you will see is a hope, not a lesson. Total: an afternoon. Step one is ten minutes.
A real model, on your phone, generating every reply on the device.
You need: an Android phone and a Linux shell on it: Termux from F-Droid, or the Linux Terminal built into Android 16 on a Pixel. About 2.2 GB of free RAM for the smallest brain, 7.4 GB for the biggest. No root. No account.
You will see: the script measure your RAM and pick a
Bonsai size (1.7B, 4B, 8B or 27B), install a prebuilt llama.cpp (no compiling; that was
version one and it took forty minutes), download the weights from our mirror, start a
server on 127.0.0.1:8080, and print a summary that begins
Bonsai-… is serving. Re-running is safe; every step skips when already done.
Then: open the phone's browser at elysium.aitherium.com or aitherium.com. Both probe your local server on their own; the model chip flips from "no node" to yours, and from then on every reply is generated on the phone. No sign-in, because there is nothing to sign in to.
What you just learned. A model is a file of numbers plus a program that runs them. Bonsai stores each number in about one bit, which is why a 27-billion-number brain fits in a phone's memory, and llama.cpp maps the file instead of copying it, which is why the phone does not kill it. The server speaks the same API the big labs charge for, on a port only your phone can see.
Two honest notes. Bonsai is a reasoning model: it thinks before it
answers, and on a phone the thinking is most of the wait. Cap it with
"reasoning_effort":"low" per request, or start the server with
--reasoning-budget 512. And a phone cannot run these weights inside the
browser tab itself; a tab's GPU budget is a fraction of what they need. That is why the
server and the browser live on the same device and talk over loopback.
iPhone: no path today. We say so rather than pretend.
The same brain on a laptop with no GPU.
You need: Python (from python.org; on Windows tick "Add python.exe to PATH"), about 6 GB of free disk, and a few minutes of download. No GPU, no API key.
You will see: Successfully installed awdk …
with a version number.
You will see: five numbered steps, [1/5] Detecting
hardware… through [5/5]: it detects your CPU and memory, picks a backend
(plain llama.cpp with no dependencies, or Ollama if you already have it), downloads a model
sized for you, asks it a question and checks an answer comes back, then registers it. It
ends with an address like http://localhost:8200/v1 and Config saved.
A failed check fails the command; quickstart means proven working.
No Python, or none you trust? One line sets up an isolated environment and runs the wizard:
What you just learned. "8B" is eight billion numbers. At sixteen bits each that is 16 GB, too big for most laptops; quantised to four bits it is about 4.5 GB and almost as good, and at one bit a 27B brain fits in 3.8 GB. The kit picks the trade that fits your machine so you do not have to. Unplug the network after this step. It still answers.
Stuck? adk doctor names the problem. If the download stops,
run the same command again; it resumes.
Ask it one question. Then open a chat.
You will see: Provider: …, one line of
Response: … from your brain, and Status: OK. If it says FAILED,
the brain from step 02 is not running; adk backend status shows what the kit
expects and adk quickstart-local restarts it.
You will see: a chat, zero config, against the brain you just started. Everything you type stays on the machine.
What you just learned. The kit does not care which brain is on the other end. The same commands work against the phone's server, the laptop's llama.cpp, a GPU, or a cloud key you add later. Swap the backend; the agents do not change. That is the whole point of the plug.
A brain, plus tools, plus a job. Three files. You will watch it use a tool.
A chatbot answers. An agent acts: it can run a command, read a file, send a message, and decide what to do next based on what happened. The difference is tools.
$ cd my-agent
$ python agent.py
You will see: Created AitherADK project at my-agent/,
three files named (agent.py, config.yaml, tools.py), and
then one greeting printed by your agent. It was asked to say hello to the world, and it
had a hello tool to do it with, so it called the tool.
Now open agent.py, change the question at the bottom, run it again. Then add
a second tool: any Python function with a docstring, decorated the same way.
from adk import AitherAgent, tool
agent = AitherAgent("my-agent")
@agent.tool
def hello(name: str) -> str:
"""Greet someone by name."""
return f"Hello, {name}!"
async def main():
response = await agent.chat("Say hello to the world")
print(response.content)
if __name__ == "__main__":
import asyncio
asyncio.run(main())
What you just learned. The docstring is the tool's description; the brain reads it to decide when to call the function. Memory, safety filtering and effort routing are already on; you did not configure them. This is the same loop the foundation's own fleet runs, pointed at a smaller brain.
Someone already built the agent you want. Install it.
$ adk install pack:<name>
You will see: a table of packs, each with a name and a
one-line purpose; then the pack applied to your agent. Names are case-sensitive; copy
them exactly. An empty table means the bundled catalogue is missing:
pip install --force-reinstall awdk restores it.
What you just learned. A pack is a whole agent in one file: its brain settings, its tools, its skills, its personality. Packs compose, and a pack that extends a self-hosted agent extends a hosted one identically. This is how the operator economy gets built: you install a pack for the print shop, not a SaaS subscription.
A GPU, a LAN, or a cloud key. Same agents, same code.
| You have | Type this | You get |
|---|---|---|
| A GPU with 6 GB or more | adk quickstart | vLLM or Ollama auto-detected, models pulled, ready to chat. TurboQuant 4-bit runs on cards as small as 6 GB. |
| A whole LAN of machines | adk deploy grid | One model spread across the boxes you own, routed by effort. We split a 27B across a gaming GPU and an ARM box over an ordinary LAN, and it answered. |
| Just an API key | adk quickstart --cloud | Anthropic, OpenAI or DeepSeek as the brain. Cloud as overflow: keep the key for the long tail and serve the rest locally. |
What you just learned. Effort routing: the kit sends small work to the small brain and only escalates when the job needs it. On a stack built this way, more than eighty percent of calls never leave an 8B model. chapter 6 ↗
On a desktop with a GPU, the page is the runtime.
Open aitherium.com on a desktop with a WebGPU-capable browser and a GPU. The on-device Bonsai brains load into the tab itself, four sizes from 236 MB to 3.6 GB, chosen by what your machine can hold. No install, no account, no terminal. A phone tab cannot hold the weights; that is what step 01 is for.
Make your machine a named piece of the infrastructure.
You will see: a device-code prompt in your browser (identity,
not an API key), then your node registered: persistent agent, a tunnel, autostart, visible
in the fleet within about a minute. On the phone, phone.sh offers the same
step at the end, and it is not needed for the phone's own browser.
What you just learned. A node is a computer that has joined the network. The more ordinary people run one, the more the network is owned by its users and the less any one company can switch it off. Contribution is attributable to an identity, and an API key is not an identity.
Then teach someone.
Walk into the print shop that spends four hours a week on invoices. Deploy their agent, configured for their workflow, on a box in their back room. Be there at seven on a Tuesday when it breaks. That is the work, there is more of it than any company can serve, and it does not centralise. The rooms are where the people doing it already are.