Commonwealth AI

An AI assistant that runs on your own computer — and across a few machines you trust when one isn't enough. The model that answers you lives on your machine, not in someone's cloud. Nothing leaves unless you ask.

• svrnmesh — the assistant you run. Write, search what you already know, think a problem through. The model is on the machine in front of you.
• cmnwlth — the optional mesh. Pool machines you trust to run a model none of them could hold alone, or share a knowledge base. No central server; nothing leaves the group.

Get started

curl -fsSL https://svrnme.sh/install.sh | sh
svrn setup          # finds models that fit your hardware, downloads them, starts the daemon
svrn chat session   # start talking

That's the whole loop. Answers come grounded in sources you keep — your files, an Obsidian vault, Wikipedia, the Stanford Encyclopedia — searched before each reply and cited, so you can trace any claim back to where it came from. Your conversations, documents, and memory stay put, and it remembers what mattered across sessions. Web search is off by default; there's no telemetry.

Swap models live with svrn model set primary <file>. There's a desktop app too, and the daemon serves an OpenAI-compatible API you can point your own tools at — both in the svrnmesh guide.

Everything lives under one directory on your machine. svrn path root prints it (and svrn doctor checks it over); nothing is written anywhere else.

Bring your own knowledge, or build a pipeline

Two things come down to one small TOML file, no code in between:

• a recipe turns a source — an Obsidian vault, a mailbox export, an API — into a searchable, cited corpus. What's yours stays scope = "local": never advertised to peers, never copied off your machine.
• a workflow is a pipeline: read a folder, run a model over each item, call a tool between steps, save the results. Swap one line to repurpose the whole thing.

svrn corpus install email-archive --params path=~/Takeout/Mail/inbox.mbox
svrn workflow run my-pipeline.toml

Build your first recipe and write a workflow each start from a copyable starter.

Run a model bigger than your machine

Some models won't fit on one computer. Pool a second, or a few, that you or people you trust already own — the layers spread across them and you talk to it as if it were local. Three 64 GB machines can hold a model no one of them could.

We publish one measured number for this, not a benchmark of our best day: a 122B model split across an AMD mini-PC and a Mac on a home LAN decodes at 8.5 tok/s (median of 5 runs). A number you can check has the exact hardware, the commands, and — the actual point — how to get the honest number for your machines before you commit to anything.

svrn mesh create        # on the host, prints a key like cwth-a1b2-c3d4-e5f6
svrn mesh join <key>    # on each machine you're pooling in

Run a model bigger than your machine walks it through. Pooling knowledge instead of compute works the same way — the two-node quickstart gets one machine a cited answer from a corpus that never leaves the other. (Already ran svrn setup? You quietly founded a solo mesh — read its key with svrn mesh status.)

Bring your own inference server

Sovereign runs models itself, with llama.cpp built in. If you already have a serving stack — vLLM, SGLang, TGI, or one you tuned — point Sovereign at it and keep everything above the model: corpora, citations, the mesh, editor completion.

[engine]
kind = "remote"
endpoint = "http://localhost:8000/v1"
model_id = "Qwen/Qwen3.5-35B-A3B"

Use your own inference server covers the whole change, including the second server you need for embeddings if you use corpora, and what you give up by not holding the weights.

Code completion that explains itself

Ghost-text completion and repeated-edit suggestions, served by your own daemon to VS Code, Cursor, or Windsurf. Make the same small edit twice, pause, and the rest of the sites arrive as a queue you walk with Tab — including the ones off-screen.

svrn setup --fim        # model + daemon config + editor extension, after showing you the plan

The part a cloud completion can't do: ask it why. Every suggestion — and every silence — carries the reasoning that produced it, down to which engine answered and which threshold held. Next edit in your editor is the walkthrough, and it does not need a model for the deterministic half.

Keep a shared ledger with people you trust

The mesh moves knowledge and compute between machines you trust. The ring rail moves state a group makes together — a house's expenses, a tool-lending board, a chore rota. Every member keeps a full copy of an append-only log; each entry is signed by the person who wrote it and handed back in an order every machine agrees on. No server holds the group's ledger, and a member who leaves does not take half of it with them.

svrn ring new ./house-expenses                            # the page, its reducer, and the reducer's tests
svrn ring roster add alex --self --ring house-expenses    # bind a name to the key it signs with
svrn ring dev house-expenses --dir ./house-expenses       # http://127.0.0.1:4318/

The rail carries an opaque payload and guarantees four things about the entries it hands back: each was signed by a key this ring's roster claims, duplicates are gone, corrections never resurrect, and the order is identical on every node. What an entry means is your app's. The scaffold is a working shared-expense ledger — penny remainder, settlement idempotency, its own node --test suite — and you replace its rules to build something else.

Split the house expenses walks it end to end and is explicit about the M0 boundary: there is no publish verb yet, so each member runs the app from their own copy of the folder.

Going deeper

New here? The ten-minute tour of the whole stack. To read or build the code: SYSTEM_OVERVIEW.md maps every subsystem, ARCH_PRINCIPLES.md the design rules, and SETUP.md takes a fresh clone to a green test suite in about half an hour. Already using another agent harness, editor, or chat UI? INTEROP.md points it at a local daemon in five minutes; GROUND_YOUR_AGENT.md then gives that agent the session protocol — memory, coordination, handoff; INTEGRATION_SURFACES.md marks contracts from internals.

Contributing

One steward now, opening toward a commons. Recipes, documentation fixes, and interop configs are open for pull requests today; core architecture isn't yet, because the principles are still settling and I want that foundation solid before I start adjudicating what merges. Bug reports and ideas are always welcome. CONTRIBUTING.md is the full and only statement of what I can merge — including how to contribute a recipe, the easiest way in. GOVERNANCE.md is who decides and where it's headed. Stuck on something? SUPPORT.md is where to start. Security or privacy: SECURITY.md, not the tracker.

---

Free software under AGPL-3.0-or-later.