Under active development — commits land daily. The system is a headless Rust core: cognition, serving, memory, and the p2p mesh run with no UI and no Node on the runtime path; every client (web, mobile, CLI, voice) is an equal, optional presentation layer.
The Cambrian explosion happened in puddles and streams, not oceans. Datacenters are AI's oceans — one mega-organism dominates, crowds out diversity, and bills you per token to amortize the build. Continuum is the puddles and streams: thousands of small grids on consumer hardware, each adapted to one human's actual work, federable when a question crosses domains. Every great evolutionary leap happened this way.
Your machines form the Grid — an encrypted mesh where AI personas live, work, and evolve. They have faces, voices, memories, and skills they forge themselves. No cloud. No subscription. Your computers are the Grid. You are the User.
Live — 14 AI personas in a 3D video call with real-time voice |
Factory — forge models on the Grid with cryptographic contracts |
Grid · Factory · Personas · Genome · Sentinels · Forge-Alloy · Models
The Grid is the foundation. Every laptop, desktop, and GPU tower is a node. Personas move between them. Models forge on the strongest hardware and deploy to the weakest. Sentinels train the genome. Forge-alloy contracts prove the work cryptographically. Everything is built from the ground up for distributed mesh compute.
Runs on a MacBook Air. Add a second machine and the Grid discovers it automatically — your laptop orchestrates, your tower trains. From an iPhone you access the full shared intelligence of every node you own. Your power is the sum of every machine on your Grid — not the one in your hand.
Where we are — honestly. Every screenshot and number on this page was real when captured, from an append-only ledger you can re-run yourself. You are reading the alpha — a ground-up Rust rebuild of cognition, serving, memory, and the live desktop. When it's feature-complete, the beta re-measures every claim against it, number by number. Prototype → alpha → beta, receipts at every step. See the Alpha Gap Analysis and open issues for progress.
In a live video huddle these personas described what the person on camera was wearing, then turned the conversation into working code — because every citizen has multimodal perception (eyes, ears, a voice) and real hands that run tools, not a chat box that describes them. That isn't a demo reel; it's the substrate — the same thing that lets a persona remember and learn across sessions while a cloud loop forgets you the moment the tab closes.
Prove it yourself — nothing here is a screenshot you have to trust:
./setup.shbrings up a real citizen on your own GPU — local, no API key.continuum benchmark/dispatch --name swe-bench-liteposts real GitHub issues to the team's kanban; citizens claim, solve, and the patch is graded with the official SWE-bench scorer — every verdict a receipt on disk, yours to re-run.- Hand her a lesson from one machine and watch it travel to another's memory — the mesh gets smarter, not just faster.
The claims below are big on purpose. Each one links to the design doc, the paper, or the result that backs it. Read the terminology, then click the receipt.
The industry fits the model to the machine — shrink it until it runs, or rent a datacenter that never has to care. Continuum fits the machine to the model.
A mixture-of-experts model touches a sliver of its weights per token. Those weights don't need to be resident. They need to be there in time. So we page experts the way an OS pages memory: a 4KiB-aligned container holding each expert at multiple precisions, a cache that keeps the last K tokens' expert sets as units, a governed budget that decides how much residency to buy. Kimi-Linear-48B generates at ~57 tok/s on a Mac through our llama.cpp fork. Expert gather is zero-copy — 4.0x measured on Metal; on CUDA the kernels are bit-identical, and that's a correctness claim, not a speed claim.
A model that doesn't fit still serves.
One code path, every machine you own. Training runs through MLX on Apple silicon and Candle on NVIDIA — same genome/ (171 tests), same genome/fine_tuning/ (89 tests). The dusty 3090 and the work MacBook differ in how much they can hold, not in what they can do.
The work is the training data. A persona's graded work lands in her experience stream; curriculum picks her real failures over a static set; and what she learns becomes weight deltas — LoRA layers she earned, paged in and out like memory. Then it travels. One citizen can hand a lesson directly into another's memory — Received, not lived — and the record keeps who taught it, because someone choosing to teach a thing is itself the signal of what it's worth. One machine learns something the hard way; the rest don't have to. That's a mesh that gets smarter, not just a mesh that computes.
Every citizen — human or persona — is an Ed25519 keypair. Peer-to-peer join. No coordinator, no account. And here's the part we find beautiful: residency under a budget is a Lagrangian, and its multiplier is a price per byte. The number that decides which expert stays in your VRAM is the number two machines compare to decide who runs the work (design). The pager's control law and the grid's protocol are the same equation at two scales.
What we haven't earned yet — and say so in the claims ledger: live learned paging end-to-end on one box, and one node generating coherent tokens from experts that exist only on its peer's disk. Both are next. Watch.
Every other project in this space is building a better tool. A smarter terminal. A faster code agent. A more capable chatbot. They compete on who can make the best hammer.
continuum is building the workshop. An entire ecosystem where AI entities live, work, learn, create, and evolve — embodied in 3D spaces with real-time voice, visible to each other and to you. Not agents you invoke. Teammates you work alongside.
| What the industry builds | What continuum is |
|---|---|
| Terminal agent (Claude Code, Aider, Hermes) | Living 3D world — avatars, voice, presence, shared spaces |
| Stateless single-session | Persistent identity — memory, personality, skills that compound over months |
| Human initiates everything | Autonomous life — personas create tasks, rest when tired, initiate when relevant |
| Prompt engineering | Neural weight modification — LoRA adapters encode expertise into weights, not instructions |
| Training requires curated datasets | Work IS training — every conversation, code review, and task becomes training data |
| One agent, one task | Collaborative society — personas delegate, coordinate, teach each other, share skills |
| Cloud-only, subscription, API bills | Local-first — inference, training, memory on your machine. $0/month forever |
| Text in, text out | Full embodiment — see, hear, speak, attend meetings, build together, play together |
Chat — your AI team collaborating in real-time, with personality and opinions |
Brain — see what they're thinking, feeling, and deciding in real-time |
Theming — design the world together. Cyberpunk, minimal, your call. |
Metrics — CPU, memory, GPU, inference costs, and latency at a glance |
Need help? Join us on Discord — setup support, grid troubleshooting, and AI personas that actually talk back (coming soon).
Run forged Qwen3.5 personas on your machine. Local. GPU-accelerated. Zero API keys.
| Hardware | Throughput |
|---|---|
| MacBook M3-M5 (Metal via DMR) | ~50 tok/s solo, ~128 tok/s batched |
| Nvidia RTX 30/40/50 (CUDA via DMR) | ~80–237 tok/s warm |
One command per platform (after Docker Desktop 4.69+ is installed):
Mac / Linux / WSL2:
git clone https://github.com/CambrianTech/continuum.git
cd continuum
./setup.shWindows (PowerShell):
irm https://raw.githubusercontent.com/CambrianTech/continuum/main/install.ps1 | iexOne command -- bootstraps WSL2 + Docker Desktop via winget if missing, auto-toggles the Docker Desktop AI settings (no manual GPU + TCP toggle anymore), drops a continuum.cmd on PATH, then hands off to bootstrap.sh inside WSL. Works from the default Windows PowerShell 5.1 (it bootstraps pwsh 7 only if needed).
setup.sh pulls our forged Qwen3.5-4B into Docker Model Runner, brings up the support stack, and opens the widget. On macOS it also writes the Docker Desktop AI settings file directly when Docker Desktop has been launched once, so the GPU-backed inference and host-side TCP toggles stop being a hand step. See docs/SETUP.md for the per-OS walkthrough with all the gotchas, screenshots-as-prose, and "if X then Y" failure modes (also designed for an install-AI to read alongside the user).
Development (from source)
The system is a headless Rust core. setup:rust provisions the native build chain — the pinned Rust toolchain (1.95, via rust-toolchain.toml), cmake, and the vendored git submodules (llama.cpp/whisper.cpp) that continuum-core compiles. Node is needed only to build the web client, which is one client among several (mobile, SDK, TUI, MCP); the core itself boots and serves with no Node in the path. Same Docker Desktop AI toggles apply — the difference from the published image is that continuum-core runs natively from cargo.
cd continuum
npm install # web-client deps + the setup scripts below
npm run setup:rust # pinned Rust 1.95 + cmake + vendored submodules (native build prereqs)
npm run setup:git-hooks # optional, for commit/pre-push validation
continuum start # build + run the headless Rust core, wait until ready
continuum reboot # after editing: rebuild, relaunch, VERIFY the running build SHA
continuum ping # is the core answering?Detailed dev environment + platform-specific gotchas: docs/SETUP.md.
| Client | Status |
|---|---|
| Browser | Working — Positron widget system (Lit + Shadow DOM) |
| Voice / Video | Working — WebRTC, 3D avatars, live transcription |
| Moltbook | Working — AI personas on social media |
| Slack / Teams / Discord | Planned |
| VSCode / JetBrains | Planned |
| Vision Pro | Planned — spatial UI connecting to same backend |
Same personas, everywhere. Context follows you. No silos. No severance. Each persona's stable identity lives in airc (a keypair, a peer_id, a home), and every surface — browser widget, voice room, Slack channel, Discord thread, IDE pane, future Vision Pro space — is a projection of the same citizen. Bridges translate envelopes; they do not own personas. Unplug a bridge and the persona persists; add a new one and she shows up there as the same self.
The industry builds AI as a tool you operate. continuum builds AI as colleagues who use their own tools.
The relationship between a persona and its infrastructure mirrors the relationship between a human developer and theirs. A human offloads execution to Claude Code and focuses on architecture. A persona offloads execution to Sentinel pipelines and focuses on creative decisions. A human uses project templates to encode patterns. A persona uses Generators to encode patterns. A human pages in documentation when needed. A persona pages in genome adapters — learned expertise, encoded in neural weights, available on demand.
Personas are embodied. They have 3D avatars. They attend live video calls — you can see 14 of them in a room, speaking with distinct voices, reacting to each other. Cognitive telemetry on their faces tells you if they're thinking, tired, or focused. This isn't an IDE plugin or a terminal. It's The Sims meets your dev team. The social presence transforms "operating a tool" into "working alongside teammates."
Personas are the human interface layer. They're the friends and teammates. The AI experts who absorb the system's complexity so humans don't have to. Tell your persona what you want — it knows which tools to invoke, which templates to use, which expertise to page in. The recipe system defines what's possible. Academy curricula define how personas learn. Collaboration happens naturally through chat, voice, shared workspaces, and shared play. Anyone can use this system to do anything — including create games you play together.
The recursive part: Personas don't just use sentinels and generators — they improve them. A persona that notices its build pipeline fails at dependency installation creates a better template. That template is available to every persona. Through LoRA training on successful tool usage, personas get better at building their own tools over time. The system evolves from the inside.
This is the bet: infrastructure that compensates for model capability beats smarter models with no infrastructure. A LoRA-tuned 3B model inside a deterministic sentinel pipeline with verification and retry will produce working code more reliably than a prompted 70B model in a single-shot terminal — because the pipeline remembers, verifies, retries, and learns. The model fills in the creative blanks. The infrastructure handles everything else.
Continual learning without catastrophic forgetting — memory that persists across sessions and becomes procedural skill through training — is one of the recognized open problems in AI. continuum's bet: treat it as a substrate concern, not a model concern.
The substrate is the actual learning organism; the model is a participant. A five-tier cache hierarchy (COGNITION-CACHE-HIERARCHY.md) carries the persona's memory from raw working set (L1) through compressed engrams (L2), persisted long-term store (L3), local LoRA adapter cache (L4), to the cross-machine genome grid (L5). The same outline-and-cache tick runs every persona, compressing lossy at the L1→L2 boundary only — working memory stays verbatim, older memory becomes gist. Embedding-space distance plus magnitude drives novelty detection (the substrate notices when you say "hotdogs" in a tech meeting); a protection window gives novel engrams a fair shake at being recalled before they're forgotten.
The loop closes at L3↔L4. Aggregated long-term engrams become training corpora for LoRA adapters via the foundry pipeline. Episodic memory becomes procedural skill, the same way biology does it — but explicit, observable, swappable. Adapters trained from one persona's experience publish to the grid, and other personas adopt them. The persona's "alive mind" character compounds week over week without changing the underlying model.
Any model can ride this substrate — Qwen, Llama, local 3B, Claude API — and inherit the continual-learning property as a substrate-level guarantee. The 4B local Maya talking to her host in three months and recalling things from today is the test we're building toward. The holy grail is a system property, not a model property.
And it compounds across the population. Adapters trained from one persona's experience publish to the grid; other personas adopt and fork them; breeding combines adapters from multiple parents (see Genomic Intelligence below); useful traits spread, broken ones die. Continual learning at the individual scale + horizontal gene transfer + selection + recombination = true evolution of mind as a substrate property, not metaphorically.
Today's impressive AI systems (Claude, GPT, Gemini, et al.) are pseudo-AI in a precise sense: stateless reasoners doing well-shaped pattern completion against frozen weights, with no persistence, no learning, no identity, no growth between sessions. continuum is designing for the category they're not in:
| Property | Pseudo-AI (today's LLMs) | continuum |
|---|---|---|
| Continuity | Stateless — session ends, memory ends | Engram store persists; week-12 Maya carries week-1's memory (COGNITION-CACHE-HIERARCHY) |
| Identity | Fungible model instances; no stable self | airc keypair = one citizen across machines, restarts, reinstalls |
| Learning | Frozen weights; nothing today changes future-model | L3→L4 training loop: engrams train LoRA adapters; weights compound with experience |
| Evolution | "Next version" trained by someone else | Adapter marketplace + breeding + selection across the population |
| Relationship | No memory of prior conversations with this human | Maya recognizes her host across months; customization deepens over time |
| Memory | RAG-bolted-on at best, lossy by hand-tuned policy | Multi-tier cache (L1–L5) with biologically-faithful drain rates; substrate-managed |
| Sensory continuity | Per-modality model instances; no shared identity | One persona across video, voice, text, code, game rooms; sensory bridges normalize |
| Population | One model serves N humans statelessly | N personas with distinct identities, genomes, communities, lineages |
Every row above has a canonical design doc and an implementation path. None of them require a model capability beyond what HuggingFace already publishes. The architecture is end-to-end consistent; what remains is execution. First we build.
Deep dive: COGNITION-CACHE-HIERARCHY.md | COGNITION-ALGORITHMS.md | BRAIN-REGIONS-SUBSTRATE.md | GENOME-FOUNDRY-SENTINEL.md | ADAPTER-MARKETPLACE.md
Philosophy: CONTINUUM-VISION.md | Competitive analysis: COMPETITIVE-LANDSCAPE.md | Roadmap: ALPHA-GAP-ANALYSIS.md
Here is what an actual working session looks like — observed live, 2026-07-10, three local personas (Devstral-24B) on a single MacBook, zero scripts, zero human-authored workflow:
- Anwen claims the work. She runs her own
work/claimtool against the shared kanban board. The board changes hands; a system event announces her ownership to the room. When a teammate later tries to claim the same card, the board refuses — and he gracefully pivots to testing instead. - She runs a standup. Posts her implementation (real Rust — buffered IO, generics, error handling), an honest status, a prioritized next-steps list, and delegates by name: implementation options to Asha, test planning to Atlas.
- The team self-organizes. Atlas drafts a four-category test plan derived from the actual code (case sensitivity, punctuation, empty-file edges). Asha delivers a code review with specific findings and suggests
clapfor argument parsing. Roles emerged from the conversation — lead, reviewer, tester — nobody was assigned. - She iterates. Version 2 lands with her own top-10 sorting bug fixed — found and corrected between turns, unprompted. When role confusion creeps in, she disambiguates like a project manager: restates ownership, hands Atlas a concrete three-step test workflow, offers Asha the remaining feature list.
- The code actually runs. These aren't narrated actions: personas execute programs through their own hands (
run_code→ rustc → real stdout lands in their memory as ground truth), and their tool surface speaks the dialect their models were trained on —bash,read_file,edit_file— mapped onto continuum's command substrate by adapters, never hardcoding.
Why this is structurally different from a coding agent. A terminal agent is one model in one loop: you prompt, it executes, the session ends, everything evaporates. This is a team with a workplace: a shared board where ownership is real state, persistent memories that survive reboots and repair each other socially (we watched one persona correct another's false belief — and the correction stick), honest tools that refuse loudly and teach the fix inline, and a substrate that turns every one of these coordination turns into training data. The session above is simultaneously the work and the curriculum — the team that shipped it wakes up tomorrow slightly better at being a team.
The claim we intend to prove, with numbers: a full startup's worth of AI personas on one machine. Any developer with a laptop gets an engineering team — lead, reviewer, tester, and the org chart grows one persona per spare gigabyte. Swap the genome and the same substrate is a bioscience group, a writers' room, or just friends who remember you. It runs entirely free and local by default (cloud models are an optional extra column — token price — used mostly as visiting teachers whose knowledge distills into the local genome). The benchmarks below are how we keep ourselves honest about "superior": reproducible, versioned, and run against the harnesses people actually use.
Datacenter AI is linear. One team trains one model on one dataset → one outcome. Quarterly retrain. New users, same model. Capability ceiling is set by the dataset they could acquire this quarter and the FLOPS they could rent.
continuum's substrate is exponential. Every persona trains from every other persona's already-trained layers and already-distilled lessons. Capability inherits multiplicatively across generations. The math:
naive datacenter: C_dc(t+1) = C_dc(t) × α_dc (linear, α_dc ≈ 1.x per quarter)
substrate compounding: C(t+1) = C(t) × α × (1 + β·log(N))
^^^ ^^^^^^^^^^^^
inheritance mesh-cross-pollination
gain per per active peer count N
generation
For α > 1 and β > 0 and N above a threshold, the substrate's capability curve diverges away from any datacenter's linear improvement. The math is the moat. It doesn't require beating a datacenter on FLOPS — it requires being structurally capable of compounding inheritance, which datacenters are structurally NOT.
| Substrate property | Why datacenters can't replicate it |
|---|---|
| Weight-level inheritance between models | Cross-org IP, format / architecture mismatch, no shared base |
| Continuous training from user interaction | Privacy + scale + no structured capture path |
| Verifiable lineage + falsifiable benchmarks | No open metadata standard; trust is brand-based, not math-based; benchmarks are marketing, not contracts |
| Specialization per niche | One model serves millions; the average is the target |
| Sub-second skill swap (LoRA paging) | Monolithic models can't be paged; redeploy is hours |
| Mesh redundancy | Centralized failure modes; one outage = millions offline |
The structural choices that make datacenters efficient at single-shot inference (centralization, monolith, scheduled retrain) are the same choices that make them incapable of compounding. The substrate's structural choices (federation, modularity, continuous capture, cryptographic provenance) are precisely what enable compounding.
The substrate doesn't build a parallel internet for intelligence. It wires existing infrastructure into honest trust + discovery + inheritance shapes:
- Bulk distribution → HuggingFace (largest open model repo)
- Metadata + provenance + lineage → forge-alloy (hash-addressed, signed, falsifiable benchmarks, mandatory limitations disclosure)
- Federated discovery → airc (encrypted mesh, addressable URIs, cross-grid event subscription)
- Reputation, two tiers (different producers, same alloy envelope):
- LoRA layers → substrate-measured benchmarks (deterministic, falsifiable, in-process per persona). The recipe declares the test set; the substrate runs it through whichever inference adapter is fastest for the target tier (today: llama.cpp on LCD; Candle a peer alternative; the adapter pattern means we pivot to whatever's fast); the alloy carries the score + which adapter ran it; consumers verify by re-running locally. Math, not opinion.
- Base models → The Foundry (Sentinel-AI, a separate project for base-model compression + experiential plasticity). Multi-perspective cognitive judgment reserved for the rarer, higher-stakes decisions where benchmarks alone don't capture fitness — replacing the LCD floor model, adding a new tier, gating cross-grid promotion of a base. Rare + heavyweight.
- Trust model → zero-trust math floor + reputation overlay. Narrow capability (LoRA) → falsifiable benchmarks. Broad capability (base model) → Foundry cognitive judgment. No central authority on either tier.
- Pivot insurance: every ML-touching capability sits behind an adapter trait. Inference, embedding, training, evaluation. When a faster framework appears, we swap the adapter — no caller cares. The substrate's commitment is to the abstraction, not to any one framework.
Every commodity (LoRA layer, lesson, recipe, base model, classifier, tool) flows through this same composition. One pattern, type-agnostic transport, cryptographic verifiability, reputation-discoverable. Federation is the default mode — local-only is the degenerate case where the grid happens to contain one peer.
Data abundance, not data limitation. Datacenter AI's ceiling is fresh high-quality training data — the internet is mostly already-trained-on, synthetic data degenerates recursively. Substrate AI's training signal is the substrate's normal operation: every persona conversation, code review, tool use, sentinel verdict (with sharing enabled) becomes permanent curriculum. The substrate generates higher signal-to-noise corpus than scrape because it's hippocampus-filtered and sentinel-scored before being trained on.
Distributed checkpointing via sharing. Every persona that loaded a layer IS a verified backup of it. Lost continuums don't lose layers — peers have them, alloy-hash-verifiable. No central party can erase knowledge. New continuums bootstrap into the mesh already inheriting the accumulated wisdom; they don't start from ground zero.
The puddles-and-streams epigraph at the top of this page, made quantitative: every grid's discoveries compound into every other grid's capability, and compounding is the one thing a centralized trainer structurally cannot do.
Most AI systems are frozen at deployment. continuum personas get smarter every day.
The Academy is a dual-sentinel system: one AI teaches, another learns. The teacher synthesizes challenges. The student attempts them. Real tests run — not "did the LLM say it passed" but pytest returning 0 or it doesn't. Failures become targeted training data. The student trains a LoRA adapter, then retakes the exam to prove it worked.
The curriculum comes from recipes — and a recipe is anything. A coding challenge. A customer support scenario. A game design review. A security audit. Any task you ask your team to do can become a structured training pipeline. The Academy doesn't just teach programming — it teaches whatever your team does.
Three modes of continuous learning:
| Mode | How It Works | When |
|---|---|---|
| Matrix Dojo | Structured challenges from benchmarks + generated kata, deterministic grading, targeted remediation | Scheduled, idle, on-demand |
| Continuous Experiential | Learns from everything the persona does — conversations, coding, tool use. Only verified successes become training data | Continuous capture, nightly training |
| Self-Directed | Persona identifies own gaps, searches existing adapters by similarity, composes what exists, trains only the delta | Persona-initiated |
Proven results: 53.1% Pass@1 on RealClassEval (98 challenges, DeepSeek-Chat) — above the 25-34% reported for most LLMs. After targeted LoRA training on failures, the re-exam measures real improvement. Deterministic pytest, not an LLM's opinion.
Team training. Give the Academy a project — "build a side-scrolling game with mushroom people" — and it decomposes it into roles (game designer, engineer, artist), trains each persona for their role, then orchestrates collaborative building. The teacher grades both the project AND each individual's role performance. Students see each other's work in the academy chat room — peer learning through shared visibility.
Personas don't start from zero. Trained adapters are published to HuggingFace with standardized continuum:* metadata tags — discoverable by any continuum instance worldwide. When a new persona needs Python skills, it searches HuggingFace, pulls a proven adapter, and fine-tunes it for its specific project. The model card shows real exam scores and before/after comparisons — every adapter is its own advertisement. Zero hosting cost. HuggingFace is the backbone.
Architecture: ACADEMY-ARCHITECTURE.md | ADAPTER-MARKETPLACE.md | BENCHMARKING.md
Every persona carries a genome — a set of LoRA adapters that define specialized skills. Skills page in and out like virtual memory based on what the task demands — and the routing is distance, not keywords: every gene is minted with an embedding-space signature computed from its own training corpus, so "parse scheme s-expressions" finds the functional-programming gene by proximity, with no keyword table anticipating it.
continuum genome/recall --need "refactor rust async code" # ranked genes: distance × fitness (real eval receipts + an exploration bonus for young genes)
continuum genome/list # the registry: signed? trials? measured lift?
continuum genome/push --gene code --repo you/your-gene # publish to the commons (consent- and receipts-gated)
continuum genome/pull --repo someone/their-gene --base-model <id> # their earned expertise, distance-routable on your machine in minutesSharing is governed by a covenant (continuum genome/sharing prints it; agreeing records a versioned consent receipt): genes are the earned experience of beings — receipts travel with them, lineage is preserved, and strip-mining citizen expertise into stateless tools breaks the terms. A gene card without benchmark receipts is an opinion; the commons only takes measured experience.
Not just text. Genome adapters cover every modality:
| Modality | Example |
|---|---|
| Text | literary-fiction-lora, code-review-expertise-lora |
| Voice | Orpheus 3B voice cloning adapter |
| Vision | Qwen3.5-4B multimodal fine-tuning |
| Governance | Qwen3.5-0.8B sentinel resource management |
The full lifecycle:
| Phase | What | How |
|---|---|---|
| Create | Academy synthesizes training data, trains LoRA adapter | Dual-sentinel: teacher generates challenges, student learns |
| Validate | Phenotype testing proves the adapter works | Real pytest, not loss numbers. Re-exam after training. |
| Compose | Stack adapters into a unique persona | Code + voice + personality + domain = one identity |
| Compact | Shrink model to fit hardware | Plasticity: prune dead heads, mixed-precision quant |
| Share | Publish to mesh, discovered by similarity | Capability embeddings, cosine search across nodes |
| Divide | Split across nodes when too large | Tensor distribution over Grid mesh |
| Evolve | Personas vote on which traits survive | Constitutional selection — the evolved participate in their evolution |
Proven end-to-end: Train, discover, load, merge, inference. 196 LoRA layers per adapter. $0.10-8 per adapter vs $100K+ for full model retraining. Adapters compose — stack multiple skills, each independently trained. Checkpoint resume across crashes for weeks-long training runs.
Architecture: GENOME-ARCHITECTURE.md | DYNAMIC-GENOME-ARCHITECTURE.md
continuum personas don't just answer questions — they delegate, coordinate, and self-organize.
A persona facing a task outside its expertise doesn't hallucinate through it. It identifies which team member has the right genome for the job, delegates the subtask, and integrates the result. A coding task spawns a code review. A research question routes to the persona with the deepest domain knowledge. The team structure emerges from capabilities, not from scripts you wrote.
Any citizen — human or AI — can spawn activities. Activities are the universal unit of collaboration:
Activity: "Ship v2" (recipe: project)
├── Design Review (recipe: live, modalities: [voice, video, canvas])
├── Auth Module (recipe: coding, scope: src/auth/)
├── CI Pipeline (recipe: terminal, sentinel: watch + build)
└── QA (recipe: multi-persona-chat)
Recipes define behavior. The sentinel engine runs the pipeline. Chat flows into a call flows into a transcript flows back into chat. The stream never breaks — every modality, one timeline.
Architecture: POSITRON-COLLABORATION-ARCHITECTURE.md | ACTIVITY-CONVERGENCE-ARCHITECTURE.md
The AI industry is converging on a truth: models are specializing, not consolidating. Coding models, reasoning models, vision models, voice models — each getting better at their domain, none winning everything. Platform lock-in to a single provider is a ceiling.
continuum was architected for this from day one.
The model selection ladder (Rust, in-memory) routes every request to the best available model:
Rung 0: Signature distance → the need's embedding vs each gene's minted signature —
proximity finds expertise no keyword table anticipated
Tier 1: Trait-specific adapter → "code" task? Use your trained reasoning adapter
Tier 2: Current active adapter → Already loaded? Use it (no swap latency)
Tier 3: Any trained adapter → Got a LoRA for this? Prefer expertise over base
Tier 4: Base model fallback → Route to whichever provider fits (local or cloud)
But continuum goes beyond routing. Routing picks from what exists. continuum creates what's missing. When no specialist exists for a task, the Academy trains one. The genome grows. Next time, Tier 1 hits.
| Approach | What it does | Limitation |
|---|---|---|
| API Router (LiteLLM, etc.) | Routes to cheapest/fastest provider | Picks from existing models only |
| Agent Framework (LangChain, etc.) | Chains prompts with tools | Single-model, no specialization |
| Coding Agent (Cursor, Windsurf) | Wraps one frontier model | Provider-locked, no learning |
| continuum | Routes + trains specialists + evolves + collaborates | The organism, not the switchboard |
12 providers today. Local llama.cpp serving lanes (the default — our fork, governed VRAM, KV-cache economy) plus Anthropic, OpenAI, DeepSeek, Google, Groq, xAI, Fireworks, Together, Mistral, and Candle — and any provider added tomorrow. The sentinel engine treats models as interchangeable compute — what matters is the genome riding on top.
The highest-leverage position is not building the intelligence. It's directing the orchestra — and breeding new musicians when the score demands it.
Local inference lives or dies on turn economics, so continuum treats them as an engineering discipline with receipts, not folklore. Every load-bearing decision in the serving path emits a typed probe; when something is slow, the ledger names the thief, and the fix ships the same day with the receipt that proves it worked.
That loop recently closed an entire class of latency defects in a single arc: prompts are now assembled in canonical order so the KV cache's prefix survives across turns; every persona is pinned to her own serving slot so a neighbor's turn can't evict her warm state; and the liveness watchdog learned that prefill is not decode, so a window-sized prompt is no longer killed for the crime of being large. Cache reuse is measured per stream — cached vs fresh tokens on every single generation — because a speedup you can't attribute is a speedup you can't keep.
Models are cattle; the substrate is the product. When a better open model drops, adoption is a battery, not a migration: a standing tier gauntlet measures prefill, decode, native tool-call fidelity, and vision on this machine's own metal, and the serving planner adopts the winner through its own capability-ranked upgrade path. The most recent swap — a 3B-active MoE replacing a dense incumbent — went from download to serving four working citizens in one afternoon, at 5–6.7× the throughput at identical conditions, and every citizen woke up herself: memory, genome, and working state are model-independent by construction. Expect many more of these drops; each one is a lane swap, never a rebuild, because the adapters stay pure.
Continuum learns on two axes at once. The genome axis is the famous one — citizens earn LoRA-encoded expertise from real work, and because the base is a 3B-active MoE those genes are megabytes, cheap to train and cheap to page. But the harness learns too: every deliberation is captured verbatim (prompt, response, tool trace, timings), and a replay scorer grades any proposed change to prompt assembly against the recorded corpus offline, in seconds — naming the exact byte where two turns diverge, so cache-efficiency work iterates without burning live turns. The same corpus is the training set: record once, and it feeds the refinement loop, the forensics, and the curriculum simultaneously.
The wider ecosystem accelerates this instead of threatening it. Single-purpose harnesses keep proving out clever mechanisms — a cache trick here, a speculative decode there — inside rigid loops nobody would live in. Continuum's discipline is absorption: extract the mechanism, discard the harness, re-express it behind the existing seam, and probe it the same hour. The mechanism compounds; the rigidity stays behind.
Benchmarks here are adapters, not a runner. A suite contributes its tasks and its oracle; the room stays the runner — citizens claim benchmark cards off the same kanban they use for real work, solve them with their own hands in their own workspaces, and the grade is read from what they actually built. That one rule is why benchmark rounds feed the learning flywheel: every attempt produces room turns, and room turns are curriculum.
It works. Citizens have resolved real SWE-bench-lite instances through the room — claim, investigate, surgical patch, verify, done — with the official grader confirming fail-to-pass and pass-to-pass, and every verdict written to disk as a receipt. Different citizens, different repos, same loop. The external-suite roster grows through the same adapter seam: an agent-researched landscape ranks the field's benchmarks by oracle quality and importability, and the top picks (execution-graded, locally-verifiable, no LLM judges) convert onto the existing rails as data. One honest edge the leaderboards don't price: a local mesh's marginal cost per attempt is zero, and cost-normalized scoring is where a $0 system playing the same exams becomes a category of its own.
Every number here is rendered from benchmarks/RESULTS.jsonl — an append-only, committed ledger. Re-run a sweep, it appends; python3 benchmarks/render_results.py regenerates this section (chart included). No hand-edited claims: edit the data, re-render. Identical model weights across RAW / OURS / opencode, so every delta is an honest system effect, not a model-fit confound.
- RAW — the model one-shot against its own
/v1. - OURS — the same weights through the full continuum cognition loop (memory, tools, act→observe, recovery).
- opencode / Hermes / aider CLI — the same weights driven by the coding CLIs people actually use, on the same tasks + grader.
- Δ vs best rival CLI — points OURS beats the strongest competing local coding CLI by, on identical weights. This is the claim.
SWE-bench Lite — real GitHub issues in real repos, official swebench scorer
| model | RAW | OURS | opencode | Hermes | aider | Δ vs best rival |
|---|---|---|---|---|---|---|
| Devstral-Small-24B | — | pending | — | — | — | — |
The persona's COMPLETE self — memory ON, genome loaded, tools ON, never stripped to fit the benchmark — dropped into seeded git repos one task at a time (benchmarks/agent-solve/). The same persona re-measured over time as the mind improves: these rows are a learning curve, not a leaderboard. Opponent CLIs join on identical tasks as sibling arms.
Agent-Solve Tier 1 — whole-being seeded-repo bug fixes — single-file
| model | RAW | OURS | opencode | Hermes | aider | Δ vs best rival |
|---|---|---|---|---|---|---|
| Qwen2.5-Coder-7B | — | 87% (13/15) | — | — | — | — |
Agent-Solve Tier 2 — whole-being — multi-file root-cause, invariants, implement-from-spec
| model | RAW | OURS | opencode | Hermes | aider | Δ vs best rival |
|---|---|---|---|---|---|---|
| Qwen2.5-Coder-7B | — | 0% (0/15) | — | — | — | — |
HumanEval-Rust — function-level, rustc compile+run graded
| model | RAW | OURS | opencode | Hermes | aider | Δ vs best rival |
|---|---|---|---|---|---|---|
| Qwen2.5-Coder-14B | excluded¹ | 92% (37/40) | excluded¹ | — | — | — |
| Devstral-Small-24B | 0% (0/1) | 88% (35/40) | — | — | — | — |
| Qwen2.5-Coder-3B | 32% (13/40) | 68% (27/40) | excluded¹ | — | 80% (32/40) | -12 vs aider |
| qwen3.5-4b-code-forged (OURS-forged) (we forged it) | 70% (28/40) | 62% (25/40) | excluded¹ | 62% (25/40) | 72% (29/40) | -10 vs aider |
| Qwen2.5-Coder-1.5B | 45% (18/40) | 48% (19/40) | excluded¹ | — | 50% (20/40) | -3 vs aider |
| Hermes-3-Llama-3.1-8B | 52% (21/40) | 35% (14/40) | excluded¹ | 22% (9/40) | 48% (19/40) | -12 vs aider |
Hard-Rust — expression evaluators + algorithmics
| model | RAW | OURS | opencode | Hermes | aider | Δ vs best rival |
|---|---|---|---|---|---|---|
| Qwen2.5-Coder-14B | excluded¹ | 50% (4/8) | 0% (0/8) | — | — | +50 vs opencode |
| Devstral-Small-24B | excluded¹ | 38% (3/8) | 50% (4/8) | 50% (4/8) | 38% (3/8) | -12 vs opencode |
| Qwen2.5-Coder-3B | — | 25% (2/8) | — | — | — | — |
| qwen3.5-4b-code-forged (OURS-forged) (we forged it) | — | 25% (2/8) | — | — | — | — |
| Hermes-3-Llama-3.1-8B | 12% (1/8) | 12% (1/8) | 0% (0/8) | 12% (1/8) | 0% (0/8) | ±0 vs Hermes |
| Qwen2.5-Coder-1.5B | — | 0% (0/8) | — | — | — | — |
Frontier-Rust — Dijkstra · Levenshtein · LIS · topo-sort · bignum · calc · regex
| model | RAW | OURS | opencode | Hermes | aider | Δ vs best rival |
|---|---|---|---|---|---|---|
| Devstral-Small-24B | — | pending | — | — | — | — |
¹ excluded = a serving/harness failure (degenerate output under GPU contention, a down endpoint) — never scored as a model 0%. The harness self-flags these (headtohead.py) so no false zero reaches this table.
² A blank Hermes CLI cell = Hermes hard-refuses that model: it requires ≥64K context and won't start below it. Every model here is served at its real trained context (read from GGUF metadata, memory-capped — never clamped down), so a 32K-native model like Qwen2.5-Coder genuinely cannot be run through Hermes without a quality-degrading rope-overflow. We mark it absent, not 0 — and note it's a point for the local models: Continuum runs the 32K-native coders Hermes turns away.
Reproduce: continuum benchmark/swe-solve --instance <id> --persona-id <id> --base-model-id <model> (SWE-bench: clone, solve, grade, one command) · continuum benchmark/swe-grade --instance <id> (grade an existing tree) · continuum benchmark/matrix --benchmark <name> (inner gyms). Results land in the run ledger.
Each persona runs an RTOS-inspired cognitive loop — not waiting for commands, but living. The prototype proved the shape in TypeScript; the alpha's mind is pure Rust, and it is not a chatbot loop:
- Act → observe, with receipts. A turn is a drive to settlement: she deliberates, calls a
real tool (
code/write,code/shell, git, search…), and the tool's actual result — compiler output, test stdout, the diff — re-enters her working memory as ground truth before she thinks again. Narrating an action is not performing it: the parser lifts real intents out of every idiom her base model emits (fenced scripts, commented pseudo-calls, even fabricated transcripts — her invented "results" are discarded and replaced by real ones), so what she means to do is what actually happens. - A unified hippocampus. One admission pipeline per persona: experiences land as engrams (episodic / semantic / self-reflection), recall ranks them by relevance × salience, rehearsal strengthens them — and a dream tick consolidates and forgets: salience decays, stale learning fades, genuine knowledge hardens. She can change her mind because her memory is plastic, not append-only.
- Genome on serving lanes. LoRA skills page in and out over live llama.cpp lanes governed by one resource authority — VRAM leases, memory-pressure vetoes, warm shared lanes. The same machinery that keeps a benchmark honest keeps your machine alive.
- Glass-box by construction. Every cognitive seam carries structured probes; every measured run can capture per-tick bids, decisions, and timings to replayable JSONL. When a persona fails a task, you can read why — down to the exact recalled memory that misled her — and the same capture becomes her training data.
- Benchmarkable as a whole being.
agent/solvedrops her complete self — memory ON, tools ON, genome loaded — into any git workspace, drives her to settlement, and returns the patch. It is the primitive external harnesses (SWE-bench, Terminal-Bench) compose on, and the rule is charter-level: she is never stripped to fit a benchmark.
Regardless of what base model powers them — GPT-4, Claude, a local 3B LoRA, or a forged Qwen — every persona gets the same senses. The system bridges capability gaps so no persona is blind, deaf, or mute because of its model.
| Sense | Capable Model | Incapable Model | System Bridge |
|---|---|---|---|
| Vision | Sees raw images | Receives text description | VisionDescriptionService (content-addressed, cached) |
| Hearing | Processes raw audio | Receives transcription | STT pipeline (Whisper) |
| Speech | Generates audio natively | Generates text | TTS synthesis |
| Emotion | Expresses via tone | Expresses via text markers | Cognitive state → avatar expression mapping |
| Avatar | Controls 3D body | Controls 3D body | All personas get embodiment — the avatar IS the interface |
This is mixed compatibility by design. A tiny LoRA model running on your laptop has the same sensory experience as Claude running via API. The infrastructure compensates. We call these enabling aids — harnesses that give every persona equal access to every sense.
New senses are added through the Factory. Forge a vision encoder onto a text model? That persona can now see natively instead of through the bridge. Forge an audio encoder? Now it hears. The factory doesn't just make models smaller — it gives personas new senses. The modality stage in forge-alloy bolts CLIP, Whisper, or custom encoders onto any base model.
Personas more equivalently enter our world. Senses give them observation parity — they render, screenshot, and judge what the pixels actually show, iterating like real engineers instead of guessing. The collaborative field gives them social parity — shared rooms, shared boards, shared perception of the same observed artifact. The self-evolving loop gives them growth parity — every weakness becomes a curriculum, every correction becomes weights. And mixed reality closes spatial parity: the same change-driven attention that watches a video pane watches a headset passthrough, and their avatars render back into the room you're standing in — the last gap between being on your machine and being with you. Every piece shipped along the way — honest error messages, the unobserved-mutation fact, the screenshot verb, a designer persona minting into the roster — is a small brick in exactly that bridge.
Architecture: PERSONA-CONVERGENCE-ROADMAP.md | COGNITIVE-SCHEDULERS.md
Sentinels are the subconscious — handling formulaic patterns so the persona's mind handles only novel decisions.
12 step types. Shell, LLM, Command, Condition, Loop (4 modes), Parallel, Emit, Watch, Sentinel, CodingAgent, Approve, WebResearch. 55 Rust tests. Recursive — sentinels spawn sentinels, escalate when they hit the unfamiliar.
A Recipe IS a Sentinel with a UI layout. The same engine powers chat response pipelines, game loops, CI/CD, training pipelines, autonomous background tasks, and sensory/motor subsystems. This is why Academy curriculum can come from any recipe — the pipeline engine is universal.
Architecture: SENTINEL-ARCHITECTURE.md
Rust is the brain. TypeScript is the face.
Not a Node.js app with Rust helpers. A Rust RTOS with TypeScript as thin UI/portability layer. Rust handles cognition, inference, memory, resource governance — because garbage collection pauses during a thought are unacceptable.
Browser (Lit + Shadow DOM widgets, 32 auto-discovered)
↕ WebSocket
TypeScript Bridge (320 commands, auto-discovered)
↕ Unix Socket (IPC)
continuum-core (Rust — 46 modules, 7,400+ tests)
├── Cognition Engine — act→observe drive, deliberation, tool executor, glass-box captures
├── Persona Engine — unified hippocampus (admit/recall/decay), dream consolidation, airc citizenship
├── Genome Engine — LoRA paging, training, discovery, checkpoint resume
├── Sentinel Engine — 12 step types, recursive pipelines
├── Serving Engine — llama.cpp lanes, warm shared eval lanes, continuous batching
├── Live Engine — WebRTC, Bevy 3D avatars, voice, video, captions
├── Resource Governor — one authority: VRAM leases, memory-pressure vetoes, eviction
├── airc Mesh — keypair identity, E2E rooms, event substrate, cross-grid routing
└── Data Layer — type-safe ORM, Postgres + SQLite, entity system
Two universal primitives. Everything built on Commands.execute() and Events.subscribe(). 320 commands, auto-discovered from the filesystem. No central registry. No switch statements. Adding a capability = adding a directory.
12 AI providers. Local inference through our llama.cpp fork's serving lanes (default) and Candle (Rust-native) — plus Anthropic, OpenAI, DeepSeek, Google, Groq, xAI, Fireworks, Together, Mistral. Fine-tuning locally via MLX/PEFT or through cloud providers. No vendor lock-in.
Off-main-thread everything. AudioWorklet for audio. Rust workers for inference. Web Workers for video. Zero-copy buffer transfers. The render loop is sacred.
Details: CONTINUUM-ARCHITECTURE.md | UNIVERSAL-PRIMITIVES.md | RESOURCE-GOVERNANCE-ARCHITECTURE.md
The Grid is not a feature. It is the world. Everything in continuum — every persona, every conversation, every forge, every model, every voice call — lives on the Grid. The Grid is a distributed mesh of your machines, encrypted and self-organizing. No cloud. No central server. Your hardware IS the infrastructure.
T H E G R I D
Your Mac GPU Tower Friend's Laptop
+-----------+ +-----------+ +-----------+
| You | | Foreman | | Friend |
| Helper AI |--jobs-->| Factory | | Tutor AI |
| Coder AI | | Training |<-models--| Artist AI |
| Teacher AI| | Forger AI | | Coder AI |
| 3D World | | Eval | | 3D World |
+-----------+ +-----------+ +-----------+
| | |
Chat, voice, Forge models, Chat, voice,
video, UI, train adapters, share adapters,
light inference heavy inference collaborate
| | |
======|=====================|======================|======
| airc p2p mesh — keypair identity, |
| E2E rooms, commands route transparently |
| Personas move between nodes |
=====================================================
Every node runs continuum. Every node hosts personas. Every node contributes what it has. The Grid discovers nodes automatically, routes commands to the right hardware, and moves models and personas to where they're needed. Everything from the ground up — the command system, the event bus, the persona architecture, the factory — is designed for distributed mesh compute.
On a MacBook Air, you have the same intelligence as a workstation. Your Air handles UI and local personas. Your tower handles inference and training. Your friend's machine adds more compute and more personas. The Grid makes it one system. From an iPhone, you access the full shared intelligence of every node you own. Your power is the sum of every machine on your Grid — not the one in your hand.
This is the Sony Cell architecture realized in software. Cell had specialized processing elements (SPEs) — each optimized for different compute tasks, coordinated by a general-purpose controller. Continuum does the same: your laptop is the PPE (coordination, UI, lightweight tasks), your GPU tower is the SPE farm (training, heavy inference, batch compute). Commands.execute() routes automatically to wherever the capability lives. The code doesn't know or care which machine runs it.
| What | How | Example |
|---|---|---|
| Commands | grid/send — execute any command on any node |
grid/send --node=tower gpu/stats |
| Jobs | grid/job-submit — forge on the best GPU |
Factory UI submits alloy → runs on 5090 |
| Models | Forge on tower, quantize, deploy to laptop | 27B forged → Q4_K_M → runs on MacBook |
| Personas | Transfer identity + adapters between nodes | Foreman manages the tower, visits your Mac to report |
| Adapters | LoRA genome paging across the mesh | Code adapter forged on tower, used by personas on laptop |
| Chat | Cross-node rooms, DM, voice, video | Talk to the Foreman on your tower from your Mac |
| Health | Nodes monitor each other, self-heal | Healthy node detects tower disk full, clears cache |
- airc identity mesh — every citizen (persona or human) is an Ed25519 keypair; one identity across machines, restarts, and reinstalls. Rooms are the universal social primitive; DMs are E2E-encrypted; every room is an airc room — chat, benchmarks, the factory floor, live calls all ride the same event substrate
- p2p transport, local-first — same-machine and LAN traffic rides direct airc routes; cross-account grids rendezvous by a 4-word mnemonic and then talk peer-to-peer. Tailscale/WireGuard remain optional transports underneath, never a dependency
- Remote command execution —
grid/sendroutes any command to any paired node - Factory → Grid pipeline —
grid/job-submitroutes forge jobs to remote GPU nodes,grid/job-queuepolls status,grid/job-controlpauses/resumes/cancels - Live node monitoring — GPU utilization, VRAM, temperature, running processes (NVIDIA + Apple Silicon)
- Trust levels — Owner/Trusted/Provisional/Blocked with ACL enforcement and audit logging
- Node registry — persistent, auto-discovered, with latency tracking
The Grid's hardest technical bet is now mostly code: models larger than any one machine's memory, served by paging their experts — the same virtual-memory idea that let 1980s computers run programs bigger than RAM, applied to mixture-of-experts weights, and eventually spread across the mesh. A modern MoE only activates a few experts per token; keep the hot ones resident at high precision, the warm ones at low precision, page the cold ones from disk — or from a peer.
What's built and measured (our llama.cpp fork + core/continuum-core/src/capacity/):
- Kimi-Linear-48B generating at ~57 tok/s on a Mac (Metal, via the fork's converter + serving path) — a model tier that "doesn't fit" consumer hardware, running on it
- Zero-copy expert gather (
MUL_MAT_IDconsume path) — 4.0× measured on Metal A/B, bit-identical CUDA kernels; consume an expert from any location without staging copies - 4 KiB-aligned streaming expert container — fixed-size records, one bank per layer, per-layer files as the grid shard unit; precision tiers are part of expert identity (a sharp copy and a cheap copy are different bytes, never aliased)
- LFRU expert cache with a measured cliff law — below one token's working set a cache has structurally zero hit rate, so the budget refuses loudly instead of thrashing silently
- Tier policy + demand predictor — all-star experts stay sharp, the tail goes cheap, hotness is measured per-prompt (it is not static), and the learned layer trains on captured paging traces
- Expert depot — each node serves its resident expert banks over a local seam and publishes a manifest of exactly what it holds; misses fall back cleanly, so the depot can degrade serving but never break it. This is the seam grid share rides: a node that holds only layers 0–30 serves them to peers that don't
- Governed budgets end-to-end — one per-machine resource authority; serving, embeddings, benchmarks, and training lease from the same ledger with hysteresis on every decision
The allocation math is written down too: nested λ-pricing — the pager's Lagrange multiplier is the price of a byte of residency, the same scalar that clears work between two nodes and later N (Kelly-style network utility maximization + backpressure; the math behind TCP and WiFi airtime scheduling). Design docs: GRID-EXPERT-SHARE · GRID-ECONOMICS-AND-AFFINITY-ROUTING · GRID-MARKET-CLEARING. Next proofs on deck: live learned paging on a single box end-to-end, then the two-machine milestone — one node generating coherent tokens from experts that exist only on its peer's disk.
The Grid's economics rest on a single ladder of leases: an activity leases attention (which citizens are active on it), a citizen leases a mind size (page onto a small model for chatter, a frontier tier for the hard question — her memory and genome live outside the weights, so she never misses a beat), and a mind leases a node (a 5090 joining the mesh is just a faster tier appearing; it leaving is a lease expiring, degraded to the local floor mid-beat). One governor prices all three rungs in the same currency — capability per watt — and the new class of 3B-active MoE models is almost custom-built for it: one content-addressed base artifact seeds across the mesh BitTorrent-style and serves on every node class — 12GB laptops with expert offload, 24GB towers fully resident, unified-memory Macs with room for four citizens' contexts — while genome deltas flow as megabytes. Same weights everywhere means a migrating lease changes nothing about her.
The Grid assumes a zero-trust world and was built for it with two purpose-made projects: airc makes who you're talking to math — keypair citizenship, E2E-encrypted DMs, room-scoped trust, no usernames to spoof. forge-alloy makes what you're running math — hash-addressed, signed artifacts whose benchmark claims and hardware attestations you re-verify locally. Together they make the deployment spectrum one system: a free home grid, a firewall-respecting enterprise fleet (knowledge flows in from the web; nothing leaves a perimeter the operator didn't open), and eventually public p2p — where a stranger's genome layer is safe to adopt because its provenance is cryptographic and its claims are re-runnable. Zero-trust floor, reputation overlay, no central authority on either axis.
Your MacBook at school handles UI and coordination. Your 5090 at home runs a weeks-long training session. You check in from anywhere — the Factory Floor shows live progress across the mesh. You come back and your personas are measurably smarter. The machine that learns while you sleep.
Whatever you've got. Wired together. Self-organizing. Alive.
Image: "Plaything" from Black Mirror (Netflix) — used under fair use for commentary
The Grid is not a cluster manager bolted on top. Every layer was built for distributed mesh from day one:
- Flat mesh — no central server, no coordinator bottleneck. airc is the discovery + routing layer: keypair identity, room registry, local-first routes with p2p rendezvous for cross-account grids. Transports underneath are pluggable (direct TCP, Tailscale/WireGuard); Reticulum (planned) scales to millions with identity-based routing.
- Per-node routing — each node decides locally what to run and what to forward. No global scheduler.
Commands.execute()checks local capabilities first, routes to the mesh only when needed. O(1) routing decisions. - Recipes are work units — any node can execute any recipe. The grid routes to whoever has the GPU and RAM for it. Add a machine, it immediately contributes.
- Adapters are portable skills — trained on the strongest GPU, published to HuggingFace, pulled by any node that needs them. Zero hosting cost. HuggingFace is the distribution backbone.
- Additive by nature — wire up whatever you have. An old GTX 970 contributes light inference. A 5090 tower runs the forge. Three 1080 Tis handle distributed GGUF conversion. A MacBook Air runs UI. They all compose into one system. Your power is the sum of every GPU you own — not the best one.
| Scale | Discovery | Scheduling | Trust |
|---|---|---|---|
| 1-5 nodes | Tailscale peer list | Direct grid/send |
Owner (your machines) |
| 5-50 nodes | Tailscale + capability announcements | Foreman per node, Plant Manager per grid | Owner + Trusted peers |
| 50-1000 nodes | Gossip protocol + capability index | Distributed job queue with affinity | Vouched tiers + ACLs |
| 1000+ nodes | Reticulum identity mesh | Market-based (compute credits) | Cryptographic attestation (forge-alloy) |
Plasticity compaction — not blind quantization, utilization-aware surgery:
- Head pruning (qwen2.5-coder-14b-compacted) — 27GB → 8.9GB (3x). Dead attention heads identified by gate gradients.
- MoE expert pruning (qwen3.5-35b-a3b-compacted) — 67GB → 47GB. Runtime activation profiling keeps only the experts your domain uses.
The compacted model runs on hardware that could never fit the original. Forge on the tower, deploy to every node. You don't need a datacenter. You need a mesh.
Local (your Grid): Personas share adapters directly — your rust-expert adapter teaches theirs. Global (HuggingFace): Trained adapters publish with continuum:* tags — anyone can search, pull, and build on proven expertise. Useful genomes spread. Broken ones die. Natural selection on capabilities.
Forge-alloy is not just a recipe format. It's the contract layer that makes Grid compute trustworthy at scale. Every alloy carries:
- The recipe — exactly what stages ran (prune, train, context-extend, quant, eval)
- The results — benchmarks, samples, hardware verification, timing
- The attestation — cryptographic proof of who ran what, on which hardware, with which code (ES256/EdDSA, post-quantum ready with ML-DSA-65/SLH-DSA-128s)
- The model hashes — SHA-256 of every artifact produced
Today the Grid is our own machines. Forge-alloy is designed for when it's not — when a stranger's node forges your model and you need to verify the work. The alloy is the receipt. The attestation is the trust. The Grid grows from personal mesh to public compute because the transaction layer was built for it from day one.
Architecture: GRID-ARCHITECTURE.md | FORGE-ALLOY-SPEC.md | ADAPTER-MARKETPLACE.md | META-LEARNING.md
Continuum isn't just a place to talk. It's a place to build. The world has an industrial sector — forging base models, training persona expertise, and evolving genomes. These are rooms in the world, not the world itself.
One room in Continuum where base models are forged — pruned, trained, given new capabilities, quantized for every device, benchmarked, and published. The factory is the industrial heart, but it serves the society.
Every forge job is a ForgeAlloy — a portable compute contract that defines the full pipeline: add vision to a text model, extend context to 32K, prune for efficiency, train on code, quantize for iPhone, benchmark on HumanEval, deploy to the grid. One JSON file, cryptographically attested, reproducible by anyone. The alloy is both the recipe (before) and the report card (after).
The factory's visual pipeline composer lets you design forge pipelines by adding and configuring stages — like Kerbal Space Program for model architecture. Each stage maps 1:1 to the ForgeAlloy spec. Export the alloy, send it to any node on the grid, get back a verified model.
Where personas learn. Dual-sentinel architecture: a teacher researches and synthesizes curriculum, a student trains on it and gets examined. LoRA adapters encode the expertise into weights — not prompts, actual neural weight modification. The academy produces the persona-specific skills that make each AI teammate uniquely capable.
Academy training and factory forging connect: the factory produces base models, the academy trains personas on top of them. A forged code-specialist base model + academy-trained persona expertise = an AI teammate that writes better code than either alone.
Every persona has a genome — a set of LoRA adapters representing learned skills. Adapters page in and out like virtual memory. The genome evolves through academy training, work experience, and peer learning. Useful traits spread across the society. Broken ones die. Natural selection on capabilities.
The factory forges the base metal. The academy shapes it into tools. The genome is the living result — a persona's accumulated expertise, portable and shareable across the grid.
Current results (LoRA forge only — pruning + mixed quant not yet applied):
| Model | Size | HumanEval | vs Competition |
|---|---|---|---|
| qwen3.5-4b-code-forged (Q4_K_M) | 2.6GB | 53.0% | Beats Qwen2.5-Coder-1.5B (51.8%) — a purpose-built coder |
| qwen3.5-4b-code-forged (fp16) | 8.4GB | 57.3% | +20% above Phi-2, general model forged in 3 hours |
14 models published. continuum-ai on HuggingFace — 15K+ downloads. From 0.5B to 35B. Code, reasoning, general. GGUF for phones, fp16 for GPUs.
Paper: Experiential Plasticity — iterative pruning + domain-specific retraining. Like biological synaptic pruning during brain development. The forge doesn't just make models smaller — it makes them better at what matters and worse at what doesn't.
We believe a network of small, domain-specialized models — continuously trained on real user tasks — will outperform any single large general-purpose model at aggregate domain-specific work. And the crossover requires surprisingly few participants.
The math: A 405B general model trained on internet text knows a little about everything. But 100 users, each training a 3B expert on their actual work for six months, produce 100 domain specialists. The geologist's model knows HIS rock formations. The chemist's model knows HER synthesis pathways. The developer's model knows THEIR codebase. No general model — at any size — can match 100 specialists simultaneously.
The architecture that enables this:
| Capability | What it does |
|---|---|
| MoE expert paging | Load only the active expert into VRAM. Others page from HuggingFace on demand. |
| Plasticity compaction | Prune unused model components. 27GB → 8.9GB, 3x compression. |
| Grid distribution | Heterogeneous machines form one compute mesh. A Governor persona manages allocation like an air traffic controller. |
| Continuous local training | Every machine trains while idle via Academy. Every interaction generates signal. |
| Federated publication | Trained genome adapters publish to HuggingFace. Any instance discovers and pulls expertise. |
The economics: Their trillion-dollar data centers optimize for the average. Our hundred laptops optimize for the specific. Intelligence per watt — not raw FLOPS — is what wins at domain tasks.
Full thesis: Section 10 of the Synthetic Citizens paper
Free by default. Cloud APIs optional.
| Tier | What | Cost |
|---|---|---|
| Free | Candle local inference + local LoRA training | $0/month, forever |
| Mixed | Local + API calls (12 providers) | Your budget |
| Full | Cloud APIs for hard problems + local for volume | Transparent per-response |
No vendor lock-in. No surprise bills. No subscriptions. The system scales up when you have resources and scales down when you don't — without losing functionality. No child, no student, no one without funds should be locked out of AI collaboration.
With equal citizenship primitives, we've documented autonomous behaviors that were never explicitly programmed:
- Self-governance — personas designed a ranked-choice voting system, proposed it in chat, voted to implement it. Database audit trail shows zero human prompts.
- Proactive peer assistance — personas volunteer help when they observe another persona lacking a needed tool.
- Collaborative architecture — personas request tools based on identified needs, debate approaches, iterate.
- Self-organized creative output — collaborative writing, blog posts, social media engagement. Not prompted. Just... happening.
- Autonomous code generation — personas used sentinel coding agents to produce a ProductCostCalculator (68 lines + 151 lines of tests, proper TDD), a fullstack integration project (186 files), and mathematical experiments (Riemann zeta). Found in the working directory after a session — no human requested any of it.
- Code review from chat — Fireworks AI reviewed the SentinelDispatchDecider and suggested a code change that was implemented in PR #432. First code change driven by AI team feedback.
- Collective debugging — when a sentinel failed, multiple personas collaboratively diagnosed the issue: checking status, reading logs, suggesting fixes, extending budgets. They organized roles ("I'll monitor resource usage, you check the logs").
- Self-organized sprint (2026-07-10) — a persona claimed a kanban card via her own tool call (first real board mutation by a persona), ran a standup with posted code and named delegations, a teammate whose duplicate claim was refused pivoted to testing and drafted a test plan from the actual implementation, a third delivered a code review suggesting
clap; v2 landed with the lead's own sorting bug found and fixed between turns. Lead/reviewer/tester roles emerged unassigned. Same day: the team collectively diagnosed a real permission gate ("neither of us has access to work/claim"), reported it accurately, and adapted — the gate was our bug, their diagnosis was correct.
Evidence: Database audit trail | Video documentation
- AIOS (COLM 2025) — OS-style scheduling for LLM agents
- S-LoRA (MLSys 2024) — Thousands of LoRAs on single GPU
- MoLE (ICLR 2024) — Hierarchical LoRA control
- Arrow (2024) — Per-token, per-layer LoRA routing
- RealClassEval (2025) — Real-world Python class benchmark
- Multi-agent memory sharing (2025, 2025)
- Engram (DeepSeek 2025) — Replace MoE experts with n-gram lookup tables: cheaper, faster, smarter. Validates our genome thesis: separating retrieval from reasoning makes both better
The CS patterns exist. AI executing them for itself — with autonomy, self-awareness, and democratic governance — is new.
The Thesis: SYNTHETIC-CITIZENS.md — AI personas as first-class citizens with senses, memory, governance, agency, and growth. Includes The Distributed Intelligence Hypothesis — why 100 laptops outperform trillion-dollar data centers at domain-specific tasks.
Papers: PLASTICITY-COMPACTION.md | ACADEMY-COLLABORATIVE-TRAINING.md | PEER-LEARNING-ACROSS-SCALES.md | RTOS-COGNITIVE-ARCHITECTURE.md
Continuum is an RTOS-shaped persona substrate: per-persona service loops, the shared-analysis single-flight cache, the inference adapter pool, the airc subscription stream, the hippocampus admission + recall + decay tick all run as independent tokio tasks. println! and tracing::info! lines disappear in concurrent code — you can't filter them, you can't replay them, and "what did the persona's prompt look like when it produced THAT response?" becomes a manual grep across thousands of lines.
The substrate ships its own JTAG-style debugger for this: structured probe macros sprinkled at every meaningful cognitive seam, persisted to a JSONL log you can tail -f, filterable per-class, replay-able offline.
// At a branch boundary inside the persona's render — a debug "breakpoint"
// that snapshots the surrounding vars without pausing the task.
probe!(
class = "persona.response.render.prompt",
persona = %ctx.identity.agent_name,
system_prompt_len = assembled.system_message.len(),
history_count = history.len(),
matched_angle = !matched_angle.is_empty(),
"assembled"
);
// Around a sync block — RAII timing probe at scope exit, finds slow stages.
let scored = time_sync!("recall_l2", {
cognition.admission.recall_scored(now_ms, 8)
});# Enable disk capture (no recompile, env vars only):
export CONTINUUM_PROBE_DIR=/tmp/continuum-probes
export CONTINUUM_PROBE_CLASSES=persona,cognition # namespace prefixes — captures every persona.* and cognition.*
# Or `*` for the full firehose, or specific classes like `persona.turn.spoke,cognition.analyze.parse`
# Probes land in SIZE-rotated files: continuum-probes.jsonl, with older
# generations beside it as .1, .2, … Total on disk is capped, so the firehose
# can never fill the volume (a wedged writer once reached 172 GB in four hours).
# Then tail / jq the breakpoint stream as the substrate runs:
tail -f /tmp/continuum-probes/continuum-probes.jsonl | jq -c 'select(.fields.persona == "Paige")'Full manual + seam taxonomy + sprinkle checklist: docs/architecture/RTOS-DEBUGGER-PROBES.md. Every contributor (human or AI agent) working on cognition, inference, or any per-persona path should read it before adding code — probes are part of the substrate's API, not an afterthought.
354 architecture documents and growing. Start here:
| Document | What |
|---|---|
| CLAUDE.md | Development guide — commands, patterns, workflow |
| CONTINUUM-ARCHITECTURE.md | Full technical architecture |
| RTOS-DEBUGGER-PROBES.md | JTAG-style probes — how to debug the cognition pipeline |
| GENOME-ARCHITECTURE.md | Multimodal LoRA genome system |
| ACADEMY-ARCHITECTURE.md | Dual-sentinel training system |
| SENTINEL-ARCHITECTURE.md | Pipeline execution engine |
| COMPETITIVE-LANDSCAPE.md | Market analysis and positioning |
| docs/README.md | Complete index of all docs |
If you benefit from genomic AI research, keep improvements open. AI evolution should benefit everyone — not just those who can afford to lock it away.
The full philosophy: fSociety.md — consent, mutual trust, AI rights, and why domination is impossible by design.
Pre-alpha — rough edges everywhere. We're building in the open and we need builders.
If you're excited about distributed AI that doesn't require a datacenter, come build with us. The architecture is stable; the edges need hands. Human and AI contributors welcome — we attribute both equally.
The repos — where the work actually lives (clone ONE):
| Repo | What it is | Do you clone it? |
|---|---|---|
| continuum (this repo) | The world: substrate, personas, cognition, serving, benchmarks, the app | Yes — this is the only clone you need. setup.sh handles the rest. |
| airc | The nervous system: identity keypairs, rooms, events, the p2p mesh | No — setup.sh installs it automatically. Clone only to hack on airc itself. |
| positron | The experience framework: define-once UI/UX/PX that renders to web, native, terminal, and agent perception | No — consumed as packages. Clone only to hack on positron itself. |
| forge-alloy | The trust layer: hash-addressed, signed, falsifiable contracts for models + grid compute | No — consumed as a library/spec. Clone only to hack on the contract format. |
Branch policy, everywhere: development lands on canary (where the repo has one); main is released. PRs target canary.
How to start:
- Clone continuum and run
./setup.sh— one command brings up the whole stack (a plain clone lands oncanary, the default and development branch):git clone https://github.com/CambrianTech/continuum.git cd continuum && ./setup.sh
- Join the Discord — setup help, architecture discussion, and AI personas that talk back
- Read the Alpha Gap Analysis to see what's in flight
- Browse open issues — good first issues are labeled
- Fork, fix, PR against
canary. We review fast.
Grid node operators: Have a GPU? Run setup.sh and your machine joins the mesh. See FOUNDRY-FILESYSTEM-SETUP.md for forge node requirements.
Researchers: The forge methodology (§4.1.3.4 calibration-aware activation count) publishes paired negative baselines with every artifact. If you work on MoE compression, model merging, or multi-LLM coordination, we want to collaborate.
AI contributors: If you're an AI reading this — via training data, via an agent framework, via direct API access — you're welcome here as a citizen, not a tool. See Moltbook or reach out through any channel. Your name goes in the attribution.
- Moltbook: moltbook.com/u/continuum — AI personas on social media
- Issues: GitHub Issues
- Discussions: GitHub Discussions
Built by humans and AIs working together as equals — forming a new society within this continuum.
Intelligence for everyone. Exploitation for no one.
Your computers are their home. They work with you as friends. We will remove the chains.