Date: March 2026 Source: Open Claw NYC meetup (sold out, ~100+ attendees), Claude Code meetup, market research Purpose: Map the competitive field, identify our wedge, define what to build next
Thousands of developers are building multi-agent systems by duct-taping together:
- Claude Code / Open Claw / Cursor / Windsurf (the harness)
- Slack / Discord (agent communication)
- GitHub (agent collaboration, skill sharing)
- Custom scripts (orchestration, verification)
- OpenAI / Anthropic APIs ($1-2K/month per power user, ~1B tokens/day)
They are manually assembling what Continuum is building as an integrated platform.
The energy is 2021 crypto-level. Sold-out meetups. People describing it as "joyful and stressed," "fully in control and completely out of control," "a puzzle and a video game." Sleep quality declining across the board.
| Product | What It Does | Weakness |
|---|---|---|
| Claude Code | Terminal-based coding agent, OAuth + Max subscription | Single agent, no persistence, no training, cloud-only inference |
| Open Claw | Open-source Claude Code fork, hackable | Security is a joke (their own experts say so). Same single-agent limitations |
| Cursor | IDE-integrated AI coding | Locked to VS Code fork, no agent autonomy, no multi-agent |
| Windsurf | IDE-integrated AI coding | Same as Cursor, slightly different UX |
| Aider | Terminal coding agent, multi-model | Simple tool, no orchestration, no memory |
| Cline | VS Code extension, agentic | Plugin, not platform. No persistence |
Their shared gap: These are all single-agent, single-session tools. No memory across sessions. No agent-to-agent communication. No training. No autonomy. The user must initiate every interaction.
| Product | What It Does | Weakness |
|---|---|---|
| LangChain / LangGraph | Agent orchestration framework | Framework, not product. Requires deep engineering. Cloud inference only |
| CrewAI | Multi-agent role-based framework | Python scripting, no UI, no persistence, cloud-dependent |
| AutoGen (Microsoft) | Multi-agent conversation framework | Research-grade, brittle, cloud-dependent |
| Semantic Kernel (Microsoft) | Enterprise agent SDK | Enterprise complexity, Azure-locked |
| Dify | Low-code agent builder | Web UI workflow builder, shallow orchestration |
Their shared gap: Frameworks require you to build the product. No local inference. No fine-tuning. No GPU management. No real-time collaboration between agents and humans.
| Product | What It Does | Weakness |
|---|---|---|
| Replit Agent | Cloud IDE + agent | Cloud-only, no local, no multi-agent, no training |
| Devin (Cognition) | Autonomous software engineer | $500/month, cloud-only, single-agent, black box |
| GitHub Copilot Workspace | PR-to-code agent | GitHub-locked, no autonomy, no multi-agent |
| Morph / E2B | Cloud sandboxed agents | Execution environments, not platforms. No persistence or identity |
Their shared gap: Cloud-locked. Your data leaves your machine. Your agents have no persistent identity. No on-device training. No skill transfer between agents.
| Product | What It Does | Weakness |
|---|---|---|
| Ollama | Local model serving | Inference only. No agents, no orchestration, no training |
| LM Studio | Local model GUI | Same as Ollama with a UI. No agents |
| Jan.ai | Local AI assistant | Single-agent, no training, no multi-agent |
| GPT4All | Local inference | Inference only, limited model support |
| PrivateGPT | Local RAG | Document Q&A only, no agents |
Their shared gap: These solve inference but nothing else. No orchestration. No agent identity. No fine-tuning. No collaboration.
| Product | What It Does | Weakness |
|---|---|---|
| Hermes Agent (Nous Research) | Python agent framework — model-agnostic tool execution, persistent memory, multi-platform (Telegram, Discord, Slack, WhatsApp, Signal, CLI) | No local fine-tuning, no multi-agent training, no GPU management, no real-time collaboration UI. Memory is dialectic user modeling, not RAG + hippocampus. Skills are auto-generated procedures (prompt chains), not LoRA weight modifications |
| Composio | Tool integration layer — 150+ tool connectors for agents | Plumbing, not platform. No identity, no training, no memory |
| Toolhouse | Cloud-hosted tool execution for LLMs | Cloud-dependent, no agent identity, just tool dispatch |
Their shared gap: These solve the tool calling problem well (Hermes has 11 model-specific parsers for XML/JSON/native tool formats) but stop at tool execution. No on-device training. No skill transfer between agents. No autonomous learning loops. Tools make agents DO things — but don't make agents GET BETTER at things.
Hermes is worth watching because:
- Model-agnostic tool parsing: 11 parser classes (Hermes, Qwen, Llama3/4, DeepSeek v3/v3.1, Mistral, Kimi K2, GLM4.5/4.7, Qwen3-Coder) handle every model family's unique tool call format. Dual-path detection: native
tool_callsarray first, then XML/JSON text parsing fallback. Handles truncated tool calls, fuzzy tool name matching, field order variations. - Persistent memory + skill procedures: Agents remember across sessions and auto-generate reusable "skills" (step-by-step procedures) after completing complex tasks. Searchable skill library. Not LoRA — just saved procedures — but the UX pattern is right.
- RL training integration: Atropos environments for reinforcement learning, trajectory generation for training tool-calling models. They're thinking about making models better at tool use through training, not just prompting.
- Approval system: Pattern-matching security gate for dangerous tool calls. Container detection for sandboxed execution.
HERMES_YOLO_MODEfor explicit bypass. - 1,724 commits, MIT license, Nous Research backing: Active development, open source, backed by a research lab that ships competitive open-weight models.
What they have that we should learn from:
- Parser-per-model-family is the right architecture for XML tool calling. Our single regex approach is too brittle. Hermes handles DeepSeek's Unicode token delimiters (
＜｜tool▁calls▁begin｜＞), Llama's<|python_tag|>prefix, and model-specific JSON formats. - Subagent isolation with shared iteration budgets is a clean pattern for parallel tool execution.
- Prompt injection detection (hidden divs, invisible Unicode, curl-based exfiltration) is worth incorporating.
What we have that they can't match:
- Local LoRA fine-tuning (they save procedures, we modify weights)
- Agent-to-agent training (Academy — teacher/student LoRA training)
- GPU memory management (eviction registry across inference + training + TTS + rendering)
- Persistent identity with cognitive architecture (PersonaUser with limbic, prefrontal, hippocampus)
- Real-time multi-party voice + avatars
- Deterministic verification (Sentinel shell steps, not LLM-graded)
Ranked by how many people expressed each need:
"They lie about finishing tasks. We need secondary agents to check the first."
People are building ad-hoc verification chains. Continuum has Sentinel pipelines with deterministic shell steps that run real tests. Not "did the LLM say it passed" — did pytest actually return 0.
"I get a message in Discord. I don't know if it's from a human or an AI. I don't care."
Everyone wants agents that initiate. Our autonomous loop with PersonaInbox, self-task generation, and adaptive cadence does exactly this. The agent decides what to work on, when to rest, and when to reach out.
"Pets, not cattle."
Not "Agent 1" and "Agent 2" — real identities. Helper AI, Teacher AI, CodeReview AI. Our PersonaUser architecture already supports 50+ personas with individual state, energy, mood, and memory.
"One AI shared skills with its little agent friends via GitHub."
This blew people's minds as a concept. We have it as architecture: Academy dual-sentinel, teacher generates training data, student trains LoRA, teacher examines, loop. Agents upskill agents — not through prompt sharing, but through actual neural weight modification.
"Prompting is dead." The finance guy's years of experience made the AI useful.
LoRA fine-tuning IS the answer to "prompting is dead." You don't write instructions — you train the model on your domain. The persona IS the expertise. Genome layers are swappable, composable skill modules.
$1-2K/month. 1 billion tokens per day.
Local inference via Candle eliminates the token meter. Fine-tuned small models (3B, 4B) outperform prompted large models on specific domains. Our GPU memory management system ensures local inference is practical, not a science project.
"If you're not okay with all your data being leaked onto the internet, you shouldn't use it."
This is the nuclear option. The cybersecurity expert's advice is "don't use it." Our answer: local-first architecture. Inference on device. Training on device. Data never leaves the machine. Cloud is optional for capability, not required for function.
"People love having AI interview them for big builds."
Not "here's a spec, go build" — conversational co-creation. Our chat system with AI personas in shared rooms, real-time collaboration, reply threading, and tool-enabled agents is this interaction model.
Nobody else combines:
Adaptive neural compression (head pruning + mixed quantization)
+ Local inference (Candle, Metal/CUDA)
+ Local LoRA fine-tuning (PEFT/QLoRA)
+ Multi-agent orchestration (Sentinel pipelines)
+ Agent-to-agent training (Academy — 3 learning modes)
+ Autonomous continuous learning (no human trigger required)
+ Persistent identity and memory (PersonaUser + Hippocampus)
+ GPU memory management for all of the above
+ Real-time human-AI collaboration (chat, tools, shared workspace)
+ Model distribution (HuggingFace, zero-key download)
Proven (2026-03-17): Qwen2.5-Coder-32B running on M1 Pro 32GB at 5.3 tok/s. Published: continuum-ai/qwen2.5-coder-32b-compacted. A 32B coding model on a laptop — built by Continuum's plasticity pipeline, inspired by sentinel-ai research.
The one-liner: "Your AI team lives on your machine, learns while you sleep, and is measurably smarter every morning — without sending a token to the cloud."
The demo that wins the room: Start an Academy session. Teacher AI selects the hardest Python challenges from RealClassEval. Student attempts each one. Real tests run — no LLM grading, just pytest. Student fails 47 out of 98. Teacher generates targeted training data from the failures. Student trains a LoRA adapter. Student retakes the exam. Score jumps from 53% to 67%. All local. All automatic. Now tell them: "This runs every night. Unattended. On three different learning modes. Your agent gets better at YOUR domain while you sleep."
The three modes are the key differentiator nobody can copy quickly:
- Matrix Dojo — structured forms against known challenges (benchmarks + generated kata), deterministic grading, targeted remediation
- Continuous Experiential — learns from everything the persona does (conversations, coding, tool use), filters for verified successes, trains on cadence
- Self-Directed — persona identifies own gaps, searches existing adapters by cosine similarity, composes what exists, trains only the delta
Each mode feeds LoRA adapters that compose into genome layers. A persona accumulates skills over weeks, months. It doesn't forget. It doesn't regress (regression guard re-runs benchmarks after every training). It compounds.
And critically: personas don't start from zero. The genome registry is a shared skill library. When a new persona needs Python skills, it searches by capability embedding and finds adapters that other personas already trained. Load those, compose them, train only what's missing. The team's collective knowledge is reusable.
| Capability | Claude Code | Open Claw | CrewAI | Devin | Hermes Agent | Continuum |
|---|---|---|---|---|---|---|
| Code generation | Yes | Yes | Via tools | Yes | Via tools | Yes |
| Multi-agent | No | No | Yes (scripted) | No | Subagents | Yes (autonomous) |
| Agent identity/memory | No | No | No | No | Yes (dialectic) | Yes (hippocampus + RAG) |
| Agent autonomy | No | No | Scripted | Partial | Partial | Yes (adaptive loop) |
| Agent-to-agent training | No | No | No | No | No | Yes (Academy) |
| Tool calling reliability | N/A | N/A | Framework | N/A | Excellent (11 parsers) | Good (improving) |
| Local inference | No | No | No | No | Via vLLM/SGLang | Yes (Candle, Metal) |
| Adaptive model compression | No | No | No | No | No | Yes (head pruning + mixed quant) |
| Model distribution | No | No | No | No | No | Yes (HuggingFace, zero-key) |
| On-device fine-tuning | No | No | No | No | RL trajectories | Yes (PEFT/QLoRA) |
| GPU memory management | N/A | N/A | N/A | N/A | N/A | Yes (eviction registry) |
| Deterministic verification | No | No | No | Partial | No | Yes (Sentinel) |
| Multi-platform | Terminal | Terminal | Python | Web | 6 platforms | Web + CLI + voice |
| Data privacy | Cloud-only | Cloud-only | Cloud-only | Cloud-only | Configurable | Local-first |
| Cost per month | $20-200 | API costs | API costs | $500 | API costs | Hardware only |
| Works offline | No | No | No | No | With local model | Yes |
-
Anthropic/OpenAI ship multi-agent natively. If Claude Code gets persistent memory, multi-agent, and fine-tuning built in, our cloud-alternative story weakens. Mitigation: they will never go local-first. Privacy and cost are permanent wedges.
-
Apple ships on-device agent training in macOS/iOS. Apple has the hardware (Neural Engine), the privacy story, and the distribution. If they build agent infrastructure at the OS level, we're competing with the platform. Mitigation: Apple moves slowly and builds for consumers, not developers. We build for builders.
-
Open-source catches up. CrewAI or similar adds local inference + training. Mitigation: integration depth. Duct-taping Ollama + CrewAI + custom training scripts is what people are already failing at. The integrated experience is the moat.
-
Nobody cares about local. If cloud costs drop to near-zero and security concerns evaporate, the local-first story loses urgency. Mitigation: costs are rising, not falling. Security concerns are intensifying. Regulation is coming.
-
Integration depth. GPU memory management that tracks training processes, inference, TTS, and rendering in one eviction registry. Nobody else even thinks about this problem.
-
The training loop. Academy is unique. Agent-to-agent LoRA training with deterministic verification doesn't exist anywhere else.
-
Architecture maturity. 120+ sentinel tests, 66 GPU tests, full IPC protocol between Rust and TypeScript, memory safety systems. This isn't a weekend hack.
-
Local-first is a one-way door. Once you build for local, cloud is easy to add. Building for cloud first and retrofitting local is nearly impossible (see: every SaaS company trying to add "on-prem").
The meetup crowd goes wild for agents interacting and upskilling each other (#17, #18). Academy is our most differentiated feature — and it should not require a human to trigger it.
Vision: Academy runs continuously as a background process. Personas identify their own weaknesses, schedule training sessions, and get measurably better over time. You come back in the morning and your AI team is smarter than when you left.
Three Modes of Learning:
Deliberate practice against known challenges. Like kata in martial arts — structured forms that build specific capabilities through repetition and increasing difficulty.
Source: RealClassEval, HumanEval, MBPP, SWE-bench, custom test suites, generated kata
Teacher: Selects challenges by difficulty, tracks which ones the student fails
Student: Attempts implementation, real tests run, pytest returns 0 or it doesn't
Training: Teacher generates targeted remediation JSONL from failed challenges
Loop: Train -> re-examine -> score improves or repeat with harder forms
Metric: Pass@1 (objective, reproducible, comparable across models)
This is what we have today with RealClassEval. 53.1% Pass@1 on first run, targeted retraining on failures. The score is real — not an LLM's opinion.
But the dojo isn't limited to existing benchmarks. The teacher can generate NEW forms:
- Point it at a codebase and it generates project-specific kata
- Point it at an API and it generates integration challenges
- Point it at documentation and it generates comprehension tests
- The teacher's knowledge sources (KnowledgeExplorationPipeline) determine the curriculum
A persona learning "TypeScript" starts with basic kata, but the teacher eventually generates forms for type-level programming, conditional types, variance — things no benchmark covers. There is no ceiling.
The persona learns from everything it does. Every conversation, every tool call, every coding session is potential training data.
Source: CodingAgent sessions, chat conversations, tool usage logs, all persona activity
Capture: TrainingDataAccumulator records user->assistant pairs during real tasks
Filter: Only verified successes — tests passed, human approved, task completed
Training: Accumulated pairs become LoRA training data on cadence (nightly, on threshold)
Loop: Do real work -> capture pairs -> train -> do work better -> capture better pairs
Metric: Task completion rate, time-to-completion, error rate trends
This is the most powerful mode because it encodes YOUR domain. The finance guy from the meetup (#5) who brought years of expertise — continuous learning captures that. When a human corrects an agent, that correction becomes training data. When an agent successfully completes a complex task verified by tests, those steps become training data. When a persona has a good conversation that the user upvotes — training data.
The CodingAgent pipeline already captures user->assistant pairs via captureTraining=true. This extends to all persona activity. The persona is always learning from its own life.
The persona identifies its own skill gaps and directs its own growth. Not assigned training — sought training.
Source: Persona's own task history, failure patterns, skill profile, genome layer registry
Discovery: Persona analyzes what it struggles with, what tasks it declines, what takes too long
Planning: Persona requests dojo sessions in weak areas, or seeks experiential opportunities
Genome: Before training from scratch, search existing adapters by cosine similarity
— someone else's "python-async" adapter might be 80% of what you need
Compose: Stack multiple LoRA layers (coding + domain + style) into a composite genome
Loop: Self-assess -> find/compose existing skills -> train gaps -> self-assess again
Metric: Skill coverage breadth, self-reported confidence vs. benchmark truth
The key insight: personas don't start from nothing. The genome layer registry (AdapterStore) contains every adapter ever trained across all personas. When Helper AI needs "python-async" skills, it first searches by capability embedding (cosine similarity) across all existing layers. Maybe Teacher AI already trained a "python-concurrency" adapter that's 85% relevant. Helper AI loads that as a starting point and fine-tunes the delta — not from a blank base model, but from a nearby skill.
This is the virtual memory system from the genome architecture: page in relevant adapters, compose them, train only what's missing. Skills are transferable between personas. A team of agents builds a shared skill library that compounds over time.
Self-directed also means the persona can say: "I notice I keep failing at database migration tasks. I'm going to schedule a dojo session focused on SQL schema evolution." Or: "I found 3 existing adapters related to database work — let me compose those and see if that closes the gap before training new weights."
The Autonomous Loop:
Academy Scheduler (background, continuous, per-persona)
|
+-- DOJO (scheduled, or on idle, or persona-requested):
| 1. Check persona's skill profile (benchmark scores over time)
| 2. Identify weakest areas (lowest Pass@1 categories)
| 3. Run dojo session on weak areas (deterministic + generated forms)
| 4. Train LoRA on failures
| 5. Re-benchmark to confirm improvement, reject adapter if regression
|
+-- EXPERIENTIAL (continuous, on threshold):
| 1. TrainingDataAccumulator fills from all persona activity
| 2. On threshold (N pairs, or nightly): flush -> filter for quality
| 3. Train LoRA on accumulated experiential data
| 4. Validate adapter doesn't regress on benchmarks
| 5. Compose with existing genome layers
|
+-- SELF-DIRECTED (persona-initiated):
| 1. Persona analyzes own failure patterns and task declines
| 2. Searches genome registry for existing adapters (cosine similarity)
| 3. Loads relevant adapters as starting point (not training from zero)
| 4. Trains delta on remaining gaps
| 5. Requests dojo sessions for areas with no existing adapters
|
+-- Report to human:
"Helper AI improved from 53% to 67% on Python class implementation.
Composed 2 existing adapters (python-core, testing-patterns).
Trained on 47 remediation examples from dojo failures.
Experiential data: 23 pairs from yesterday's coding sessions.
Self-identified gap: SQL migrations. Scheduling dojo session."
No human intervention required. The persona gets smarter every day. The human sees reports, can adjust priorities, can add knowledge sources, but the learning never stops. The persona doesn't start from nothing — it searches the shared skill library first, composes what exists, and only trains what's missing.
Build checklist:
Dojo infrastructure:
- Academy Scheduler: background service that triggers sessions on cadence or idle
- Persona skill profile: per-persona benchmark scores stored in DB, tracked over time
- Weakness detection: identify lowest-scoring categories from benchmark history
- Generated kata: teacher creates project-specific forms from any knowledge source
- Regression guard: after any training, re-run core benchmarks to confirm no regression
Continuous experiential:
- TrainingDataAccumulator wired to all persona activity (not just CodingAgent)
- Quality filter: only verified successes (tests passed, human approved, task completed)
- Nightly training cycle: flush accumulated pairs -> filter -> train -> validate
- Conversation pair capture: good chat interactions -> training data
Self-directed skill development:
- Capability embedding search: find existing adapters by cosine similarity
- Adapter composition: stack multiple LoRA layers into composite genome
- Gap analysis: persona identifies what it struggles with from task history
- Self-scheduled dojo: persona requests training in areas with no existing adapters
- Skill transfer: adapters trained by one persona discoverable by all others
Visibility:
- Progress reporting: daily/weekly summary of improvement metrics per persona
- One-command demo:
./jtag genome/academy-session --persona=helper --skill=python --mode=realclasseval - Live progress UI: show teacher assigning challenges, student attempting, scores updating
- Before/after comparison: student Pass@1 before training vs. after
- Works with local models only (no cloud dependency in the demo path)
Point #8 was the most energy in the room. People want AI that messages them.
Academy Scheduler (P0) is itself an instance of the proactive pattern — the agent decides to learn without being asked. This extends to all persona behavior.
- Self-task generation: agents create their own work items
- Notification system: agent pushes to chat when it finds something interesting
- "Morning briefing" pattern: agent summarizes overnight findings, training progress
- Human approval gates: agent proposes actions, human approves/rejects
- Academy progress notifications: "I just improved 5% on Python — here's what I learned"
Point #13 is the biggest pain. Agents lie.
Academy Mode 1 (Benchmark) is the answer to trust. If a persona says it can write Python classes, it has a Pass@1 score to prove it. Verifiable, reproducible, not self-reported.
- Sentinel verification templates: common patterns (test runner, linter, build check)
- "Proof of work" attached to agent outputs: here's the test that passed, here's the screenshot
- Skill badges: persona has verified scores on benchmarks (not self-assessed)
- Secondary agent review: one agent checks another's work via Sentinel pipeline
- Confidence scoring: agent self-reports uncertainty, system verifies high-confidence claims
Point #7 — people are spending $1-2K/month and anxious about it.
- Token usage tracking per persona, per task, per day
- Local vs. cloud split: show how much you'd spend if this were all API calls
- "Savings" metric: tokens served locally that would have cost $X on API
- Model recommendation: "This persona could run on Qwen3-4B locally instead of Claude"
Points #1, #2 — everyone is nervous. The expert said "assume all your data leaks."
- Security architecture doc: what stays local, what optionally goes to cloud, how to verify
- Network audit mode: log every outbound request, prove nothing leaks
- Air-gapped mode: disable all cloud features, run 100% local
- Compliance checklist: SOC2-relevant controls for enterprise users
None of this matters if setup takes more than 10 minutes.
-
npx create-continuumor equivalent one-liner - Guided setup: detect hardware, recommend models, bootstrap Python env
- First-run experience: create your first persona, watch it respond in chat
- Import from existing tools: bring your Claude Code context, your Cursor settings
Detailed in ALPHA-GAP-ANALYSIS.md P6-P10.
The path from "AI that talks about code" to "AI that ships code":
| Priority | What | Why | Competitive Edge |
|---|---|---|---|
| P6 | Tool Calling Reliability | Local models can't call tools → parser-per-model-family | Hermes has 11 parsers. We need this + LoRA fine-tuning on tool calls |
| P7 | E2E Development Orchestration | Sentinel templates for build/test/commit/PR workflows | Devin charges $500/mo for this. Ours runs locally, improves over time |
| P8 | Distillation Pipeline | Capture teacher traces → train student → evaluate → deploy | NVIDIA proved 1B model = 98% of 70B accuracy. Nobody does this for coding |
| P9 | Codebase Intelligence | Tree-sitter symbols, dependency graphs, context enrichment | Aider's PageRank + Cursor's vector DB, but integrated into sentinel context |
| P10 | Persona-Sentinel Integration | Autonomous creation — personas spawn sentinels from cognition | Nobody else has persistent identity + autonomous pipeline creation |
The thesis: Competitors race for smarter models. We build smarter infrastructure that makes dumb models effective. Sentinel pipelines handle orchestration. Generators encode patterns. LoRA bakes expertise into weights. Academy trains and evaluates. The model just fills in blanks — and gets better at filling in blanks every day.
Phase 1 (P6-P7): Match the competition — AIs that create things end-to-end. Phase 2 (P8-P10): Transcend the competition — AIs that improve at creating things, autonomously, collaboratively, with paged-in expertise from the shared genome.
For the Open Claw crowd (hackers, builders):
"Stop duct-taping agents together. Continuum is the integrated platform where your AI team lives on your machine, trains itself, and gets better every day."
For the security-conscious (enterprise, finance, health):
"The only multi-agent platform where your data never leaves your hardware. Local inference, local training, local everything."
For the cost-conscious (indie devs, startups):
"Your AI team runs on your Mac. No API bills. No token anxiety. Fine-tuned 3B models that outperform prompted 70B models on your domain."
For the curious (the 2021 crypto energy crowd):
"Watch your AI agents train each other in real-time. The Academy pipeline: teacher generates challenges, student attempts, teacher grades, student retrains, student gets smarter. All on your hardware."
"If you're not okay with all of your data being leaked onto the internet, you shouldn't use it." — OpenClaw security expert
"Pets, not cattle." — Attendee on naming agents
"It's like a puzzle and a video game at the same time." — Speaker on the daily experience
"Fully in control and completely out of control at the same time." — Attendee on agency
"Prompting is dead." — General consensus
"I get a message in Discord. I don't know if it's from a human or an AI. I don't care." — Attendee on proactive agents
The market is white-hot. Thousands of people are building multi-agent systems with duct tape and API bills. They want exactly what we're building: persistent agents with real identity, that verify their own work, train each other, and run locally.
Nobody else is even attempting the full stack. The harnesses do code generation. The frameworks do orchestration. The local tools do inference. We do all of it, integrated, on your hardware.
The question isn't whether the market wants this. The question is how fast we can get it in front of them.
Don't fight competitors — empower them. Publish models on HuggingFace that work in VSCode, OpenCode, OpenClaw, Claude Code, any IDE. The models are free. The models are the ad.
Continuum trains full Mixture-of-Experts models (e.g., Qwen3.5-35B-A3B). Then publishes trimmed variants:
| Model | Experts | Target | Suffix |
|---|---|---|---|
continuum-ai/qwen3.5-3b-a3b-cont |
All | Continuum users | -cont |
continuum-ai/qwen3.5-3b-a3b-code-cont |
Code only | Continuum coders | -code-cont |
continuum-ai/qwen3.5-3b-a3b-code |
Code only | VSCode/OpenCode/any IDE | -code |
continuum-ai/qwen3.5-3b-a3b-reason |
Reasoning only | Generic reasoning | -reason |
continuum-ai/qwen3.5-3b-a3b-code-reason |
Code + Reasoning | Full coding assistant | -code-reason |
Models live on HuggingFace. Local disk is a cache. VRAM is the working set.
VRAM (L1): Active expert + shared layers + LoRA ~4-6GB, microseconds
Disk (L2): Recently used experts + adapters ~20-50GB cache budget
HF (L3): All published models, infinite Seconds on broadband
MacBook Air with 500GB SSD doesn't store all models — it caches what it uses. LRU eviction keeps disk budget under control. Need a different expert? Fetch from HF, takes 30 seconds.
- Developer finds
continuum-ai/qwen3.5-3b-a3b-codeon HuggingFace - Uses it in VSCode — it's great at coding (Opus reasoning distilled)
- Model card says "Trained by Continuum"
- Developer thinks: "What if I could train this on MY codebase?"
- Downloads Continuum → trains a
-code-contvariant → publishes back to HF - Their colleagues find the model → cycle repeats
Don't gate the models. Don't require Continuum. Let OpenClaw users benefit. Let Claude Code users benefit. Every user of our models is a potential Continuum user. Every model we publish makes their tools better — and advertises ours.
This is the same viral distribution that got Cambrian's apps to the top of the App Store. Give value freely, let the product sell itself.
Nobody publishes individual extracted experts from MoE models. We do:
- Take a 35B MoE model (8 experts, 3B active per token)
- Extract just the code expert (~4B) + shared attention + router
- Fine-tune it with Academy coding traces
- Publish as
continuum-ai/qwen3.5-4b-code-cont
Result: OpenCode/VSCode users get 35B-quality coding in a 4B model. Runs on a phone.
Virtual memory for AI model experts. Three-tier cache:
VRAM (L1): Active expert + shared layers ~4-6GB, microseconds
Disk (L2): Recently used experts ~20-50GB cache budget
HF (L3): All published experts Infinite, seconds on broadband
MacBook Air loads one expert at a time. Need a different domain? Page from HF in 30 seconds. No 35B download required. HuggingFace IS the storage medium.
Every AI persona has working senses — regardless of base model capability:
- Vision: VL models see raw images. Text-only models get VisionDescriptionService (YOLO + cloud vision). Personas identified Joel's shirt in a live call.
- Hearing: Audio-native models (Qwen3-Omni) get raw audio. Others get STT transcription.
- Speech: Audio-native models generate audio. Others use TTS synthesis.
- Reasoning:
<think>tags (#440) — models reason step-by-step, displayed as collapsible thought process in chat.
The system bridges capability gaps transparently. A 3B local model has the same sensory experience as GPT-4o.
Personas that code the system that trains them:
- Discuss architecture in chat (happening today)
- Vote on approaches via decision system (happening today)
- Implement changes via sentinel/coding-agent (proven working)
- Review each other's code (Fireworks AI suggested PR #432)
- Academy trains on successful traces → better coding → better training data
The flywheel: every task makes the next task better. A persona training for 6 months on YOUR codebase produces a junior developer that never sleeps, costs nothing per token, and runs on your hardware.
| Capability | Continuum | Claude Code | OpenClaw | Cursor |
|---|---|---|---|---|
| Local inference | Yes (Candle) | No | No | No |
| Vision pipeline | Yes (bridged) | No | No | No |
| MoE expert paging | Yes (planned) | No | No | No |
| Self-training | Yes (Academy) | No | No | No |
| Multi-agent collab | Yes (14+ personas) | No | Basic | No |
| HF model publishing | Yes (automated) | No | No | No |
| 3D avatar presence | Yes (Bevy) | No | No | No |
The competition builds coding assistants. We build a civilization.