Compose Cells. Run Continuum. Keep work alive across agents.
简体中文 · Product & Architecture · Continuum Runtime
Virelume is a local-first multi-agent orchestration desktop workspace for solo founders, one-person companies, and small teams. It coordinates complete external Agent Runtimes such as Codex CLI, Claude Code CLI, and Hermes, preserves persistent agent memory across runtimes and restarts, and keeps every task, decision, file version, and delivery traceable.
Virelume is not another AI agent and does not sit between users and model APIs. External agents keep their own models, tools, and native sessions. Virelume is the durable control layer above them: it organizes work into Tasks and Cells, runs reusable Continuum workflows, manages approvals and permissions, and retains the context and provenance that isolated agent sessions lose.
Status: v0.1 Technical Preview
The foundation is implemented and under real-workflow validation. Virelume is not yet recommended for production-critical work. Cell Growth and several advanced Continuum policies remain experimental or incomplete.
The same Task keeps its latest correction when execution moves from Codex CLI to Hermes.
AI agents can already research, write, code, and use tools. The harder problem begins when real work lasts longer than one chat or requires more than one agent:
- changing an Agent Runtime or native session loses context or revives stale facts;
- decisions, rejected options, and user corrections disappear inside transcripts;
- multiple agents can execute, but ownership, dependencies, and handoffs remain unclear;
- deliverables become detached from the Task, Cell, agent turn, evidence, and approval that produced them;
- users have to inspect terminals to understand progress, risk, and what needs a decision;
- later revisions start from explanation instead of accumulated organizational memory.
Virelume treats these as orchestration, continuity, provenance, and human-control problems—not as a reason to build another model wrapper.
| Term | Meaning in Virelume |
|---|---|
| Agent Runtime | A complete external agent such as Codex CLI, Claude Code CLI, or Hermes. It owns its model choice, reasoning loop, native tools, and native session. It is a replaceable execution resource. |
| Cell | A durable unit of responsibility and capability. A Cell can contain a role, versioned Skills, memory, permissions, evaluation criteria, and growth history. Different Agent Runtimes may execute for the same Cell without becoming the Cell. |
| Lead Cell | The built-in governance entry point. It clarifies the request, forms the Task Brief, proposes the accountable Cell, and preserves the two user-confirmation gates. It cannot approve or start work on the user's behalf. |
| Task | A persistent workspace containing conversation, rounds, Cells, execution, approvals, files, and history. A round may finish, fail, or be rejected; the Task remains available for later discussion and new rounds. |
| Continuum | An installable and versioned multi-Cell workflow package. It defines Cells, responsibilities, instructions, permissions, stages, dependencies, inputs, outputs, quality contracts, approvals, and failure boundaries for a class of work. Continuum is not Memory. |
| Blueprint Space | The interface for discovering, installing, developing, importing, and managing Continua. Marketplace distribution is a later layer inside the same space, not a separate product entrance. |
| File Space | Local management for user files and agent deliverables, with logical-file versions and provenance back to the Task and execution context that produced each version. |
Users describe a goal once. The Lead Cell clarifies it into a Task Brief before any specialist execution Cell is created. After the user confirms the brief, Virelume proposes the responsible Cells, workflow, permissions, and limits. Execution starts only after a second explicit approval.
Goal
→ Lead Cell clarification
→ Gate 1: confirm the Task Brief
→ propose Cells, workflow, permissions, and limits
→ Gate 2: approve composition and start
→ external Agent Runtimes execute through Cells
→ reports, decisions, memory, and deliverables remain attached to the Task
A simple task can stay with one Cell. A complex task can compose specialist Cells with explicit responsibilities, dependencies, bounded parallelism, handoffs, and review. The product value is not the number of agents launched; it is whether the user can understand and control the work.
Conversation handles discussion, structured cards handle approvals, and the timeline records execution and decisions.
Virelume memory is independent of a model context window, chat transcript, or CLI cache. It combines an authoritative structured state in SQLite with Agent-facing memory and retrieval powered by the open-source MemOS project.
This lets a Task keep the latest confirmed correction when its Agent Runtime changes, a native session becomes stale, or the application restarts. Retrieval is isolated by Task × Cell, so one Cell does not silently inherit another Task's private context.
Read how layered memory works.
A Continuum turns a proven multi-Cell working method into an installable, inspectable, and repeatable package. When a Task selects one, Virelume creates an immutable Task × Round Runtime snapshot containing the exact Continuum version, package hash, Cell allowlist, instructions, permissions, stages, dependencies, and delivery declarations.
Local development hot reload can update previews and future Tasks, but it cannot rewrite an already-running Task. Runtime state is recovered from persisted structures rather than guessed from chat text, and invalid Cell, version, permission, or stage transitions fail closed.
Tasks without a Continuum continue to use the base dynamic-orchestration flow. Continua add specialized, reusable operating procedures; they are not required for the foundation to work.
File Space is more than a file browser. It manages both user-imported files and Agent-produced deliverables. One logical file can contain multiple immutable versions while still showing which version is current.
Each Task-generated version can be traced to its Task, round, stage, responsible Cell, executing Agent Runtime, native session or turn, source inputs, and later revisions. A file can move between folders without losing that identity or history.
One logical deliverable retains its version timeline and Task provenance.
A Cell should improve from real work, but it should not silently rewrite its own identity. Virelume collects growth evidence from confirmed Task Briefs, stage results, quality evaluation, user corrections, rejection reasons, and recovery outcomes.
The intended lifecycle is:
real Task evidence → versioned Skill candidate → review and validation → approved publication → reversible upgrade
The evidence and candidate mechanism exists, but Virelume has not yet completed and validated a real end-to-end Cell evolution. Cell Growth should therefore be treated as experimental.
Control and trust cut across every capability. Virelume keeps responsibility, permissions, limits, approvals, reports, failures, recovery, and source traceability visible. Users can discuss, approve, pause, stop, resume, revise, reject, archive, and later wake a Task without surrendering governance to an autonomous agent loop.
Virelume does not use “memory” as a vague synonym for chat history. It separates authoritative work state from retrieval-oriented Agent memory.
SQLite remains the source of truth for:
- Tasks, rounds, stages, Task Briefs, and execution plans;
- Cell identity, assignment, permissions, Agent Sessions, and approvals;
- decisions, stage reports, execution events, and recovery state;
- logical files, immutable versions, provenance, and turn tokens;
- the persistent Memory outbox used to retry capture safely after a failure.
History is not silently overwritten. New evidence or a user correction supersedes old information while preserving the source relationship.
Virelume integrates MemTensor/MemOS through the pinned @memtensor/memos-local-plugin runtime. Completed user/Agent turns are captured through a persistent outbox, deduplicated with capture receipts, and stored in a Task × Cell namespace. When a new or replacement Agent Session needs context, relevant memory is retrieved and injected instead of replaying every transcript.
MemOS exposes three retrieval tiers:
| MemOS tier | What it represents |
|---|---|
| L1 / Tier 1 — Skills | Crystallized reusable Skills, usage guidance, preferences, and anti-patterns. |
| L2 / Tier 2 — Traces & Episodes | Concrete turns, steps, tool experiences, and episodic task history. |
| L3 / Tier 3 — World Model | Higher-level knowledge and relationships abstracted across experience. |
Virelume currently uses a local lightweight MemOS profile. Local capture, persistence, restart retrieval, idempotency, and Task × Cell isolation have been exercised; the complete L2/L3 synthesis and automatic Skill-evolution loop are not yet claimed as production-validated.
The recovery invariant is simple:
Agent A records value A
→ the user replaces it with value B through Agent B
→ switching back to Agent A must return B, never stale A
→ after application/runtime restart, B must still be recovered
→ retrieval evidence and Task × Cell isolation must remain inspectable
For a Task that selects a Continuum, the current Runtime foundation provides:
- an immutable snapshot of the Continuum ID, version, package hash, and schema;
- a fixed accountable Cell plus required and conditional Cell allowlists;
- frozen Cell instructions, permissions, stages, dependencies, and output declarations;
- separate confirmation of the Task Brief and the execution composition/start;
- no execution Cell creation before the second confirmation;
- append-only stage reports and accountable-Cell summaries;
- persisted recovery of stage state instead of inferring progress from conversation;
- fail-closed checks for cross-Task, cross-Round, invalid-Cell, stale-version, and unauthorized transitions.
Rich output-contract enforcement, complete source-reference validation, OS-level per-Cell sandboxing, and some advanced retry/failure policies are still under development. See Continuum Runtime for the current implementation boundary.
User
↓
Virelume Desktop — conversation, cards, timeline, approvals, File Space
↓
Lead Cell — clarification and governance
↓
Task / Cell / Continuum orchestration and recovery
├─ SQLite authoritative state, audit history, files, and versions
├─ MemOS Task × Cell memory and retrieval
├─ versioned Cells, Skills, permissions, and growth evidence
└─ immutable Continuum Runtime snapshots
↓
Codex CLI / Claude Code CLI / Hermes / future complete Agent Runtimes
Technology stack:
- Tauri 2 desktop shell
- Rust local core
- React and TypeScript interface
- SQLite and FTS5 persistence/search
- MemOS local Agent memory
- runtime adapters for complete external Agent CLIs
| Area | Current status |
|---|---|
| Lead Cell and two approval gates | Implemented |
| Codex CLI, Claude Code CLI, and Hermes adapters/native Session handling | Implemented |
| Multi-Cell conversation, reports, timeline, pause/recovery foundations | Implemented; real workflows are still being hardened |
| SQLite + MemOS persistent Task × Cell memory | Implemented; advanced synthesis remains under validation |
| File Space, local imports, previews, logical versions, and Task provenance | Implemented |
| Continuum discovery, installation, local development, and Runtime snapshot foundation | Implemented; advanced policies remain incomplete |
| Cell Growth | Evidence/candidate foundation implemented; real evolution not yet validated |
| Custom development of professional, domain-specific Continua | Supported through the local Continuum development workflow |
Blueprint Space unifies discovery and local installation; community commerce is a later layer.
Prerequisites:
- a current Node.js/npm environment;
- Rust and the platform dependencies required by Tauri 2;
- at least one supported Agent CLI installed and authenticated.
npm install
npm run memos:prepare
npm run tauri:devFor frontend-only development:
npm run devWeb-only mode cannot provide the complete desktop filesystem, local Agent process, or packaged MemOS integration. Use the Tauri desktop application when evaluating orchestration, File Space, or persistent Agent memory.
Useful checks:
npm run typecheck
npm run build
npm run memos:verifyThe current milestone is intentionally focused on making the existing foundation dependable through complete OPC and small-team workflows—not adding more feature categories.
After that foundation is proven, Blueprint Space can expand into:
- official Continuum packages that establish quality and direct revenue;
- community Continuum publishing, installation, and optional creator revenue sharing;
- enterprise governance, shared workspaces, policy management, and private deployment.
These are later commercial layers. Virelume must be useful as a local-first orchestration and continuity system before a marketplace exists.
Virelume intentionally does not aim to become:
- a proprietary AI agent or a thin multi-model chat wrapper;
- a model router, provider API-key manager, or inference-credit seller;
- an infinite canvas or native AI image/video generation suite;
- a broad replacement for email, calendars, office, or creative software;
- a coding-only tool that forces every Task into a Git repository;
- a fully autonomous company simulation that bypasses meaningful human approval.
The most useful contributions today are real multi-agent workflow reports: where context was lost, a correction failed to reach the next runtime, Cell responsibility was unclear, execution became hard to inspect, or a deliverable lost its provenance.
Before proposing a material product or architecture change, read docs/VIRELUME.md. The direction check is:
Memory keeps work from being forgotten. Cells make responsibilities composable. Continuum makes proven collaboration repeatable. The interaction layer keeps the system understandable and controllable.
Virelume is intended to be released as open-source software, but a repository license has not yet been published. Until one is added, the source is publicly visible, but no open-source license should be assumed.