Your agent forgets everythingwhen the context window closes.
CellState is persistent, hierarchical memory for AI agents — a ten-crate Rust core with a mutation pipeline that receipts every state change, event DAG forensics, and BUILD/LIVE/LAUNCH workspace flows. Open-source. Self-hostable. Every write goes through the circuit.
Memory is the hard part. Everything else is plumbing.
Your agent needs to remember what it learned, prove what it changed, and move from build to live to launch without three different systems duct-taped together.
Context windows are disposable
Your agent's working memory gets thrown away every session. Valuable observations, learned patterns, task context — gone. Turns are cheap. The insights trapped inside them aren't.
Nobody can tell you what changed
Without a causal event graph, there's no answer to "what happened, when, and why." You get logs. You need a DAG with receipts.
Build, test, and deploy are three different systems
Configuration in one tool, testing in another, deployment in a third. They drift apart fast. CellState runs BUILD, LIVE, and LAUNCH as a single lifecycle.
What's in the box
Open-source Rust runtime, mutation pipeline, event DAG, and workspace flows. Everything here maps to real code you can read.
Structured memory, not a junk drawer
State modeled as Tenant → Trajectory → Scope → Turn, with Artifacts and Notes as durable outputs. Turns are cheap and disposable. Artifacts and Notes survive.
- Ten Rust workspace crates + typed SDK managers
- Trajectories, scopes, turns, artifacts, notes
- Scope lifecycle with durable extraction surfaces
Every write goes through airport security
Four stages: Assemble → Gates → Commit → Receipt. Gate checks are pure functions — deterministic, no I/O. Every mutation returns a Blake3 receipt. Nothing bypasses the circuit.
- Pure gate stage with deterministic checks
- Atomic commit + receipt generation
- Tenant-scoped gate stats and rejection analytics
BUILD mode: compose your agent
The workspace shell combines Pack Editor, Equipment Bay, Agent Wizard, and Intent Engineering into one composition flow backed by the same SDK/API contracts.
- Config parsing + capability-based component install
- Preset loadouts and exportable agent configs
- Deploy modal with compile, diff, activate, confirm phases
LIVE and LAUNCH: verify then promote
BuilderJourney drives BUILD -> LIVE -> LAUNCH transitions. LIVE focuses on chat + sandbox verification; LAUNCH handles promotion and ops controls.
- ModeBar with journey sub-states
- LiveShell with chat + sandbox artifact panes
- Launchpad + ops dashboard with redeploy and rollback controls
Forensics built in, not bolted on
Event DAG with causal ordering, ancestor/descendant traversal, and Blake3 hash chains. The TypeScript SDK exports 34 managers. The workspace UI calls the same primitives.
- Event DAG ancestors, descendants, siblings, LCA
- A2A protocol: agent card, task lifecycle, SSE streaming
- SimpleMemory: one-call add/recall/context with Blake3 receipts
Ten Rust crates. One runtime surface.
Open-source core owns runtime + APIs + SDK contracts. Hosted CellState Cloud layers managed builder/deploy operations on top of the same primitives.
Memory Hierarchy Flow
How runtime state moves through Trajectory, Scope, Turn, and Artifact
Key Design Decisions
SQL-first, not ORM-first
The API routes compile mutations into explicit pipeline stages and commit through PostgreSQL-backed data services.
Events as DAG, not log
Event DAG traversal endpoints support ancestors, descendants, siblings, and common-ancestor forensics.
Effects, not exceptions
State transitions are explicit in BUILD/LIVE/LAUNCH journeys and in deployment lifecycles (activate, rollout, rollback).
Open-core delivery model
Self-host the Rust/API core, then opt into hosted builder/deployment workflows when you want managed operations.
Runtime + Workspace, not just storage
The same domain model powers Rust services and the workspace UI: Pack Editor and wizard feed
dsl.compile/deploy, LIVE mode consumes WebSocket events, and LAUNCH mode drives
deployments plus gate/intent telemetry.
Workspace flows mapped to real API surfaces
The Pack Editor Experience
Build configuration in one shell, verify in LIVE mode, and promote through LAUNCH controls.
SDK calls used by the app itself
The dashboard and workspace use the same TypeScript SDK managers shown below: DSL, event DAG traversal, deployments, gates, and intent drift.
import { BrowserCellStateClient } from '@cellstate-run/sdk';
const sdk = new BrowserCellStateClient({
baseUrl: 'https://api.cellstate.run',
tokenProvider: () => localStorage.getItem('auth_token'),
tenantId: () => localStorage.getItem('tenant_id'),
});
const compile = await sdk.dsl.compile(manifest);
if (!compile.success) {
throw new Error(compile.errors.map((e) => e.message).join('\n'));
}
const deployed = await sdk.dsl.deploy({
name: 'workspace-pack',
source: '',
pack: { manifest, markdowns },
activate: true,
notes: 'Deployed from BUILD mode',
});
console.log(deployed.config_id, deployed.version);One codebase, two operating paths
CellState is open-source at the core. The hosted service adds managed builder and deployment operations on top of the same runtime and SDK primitives.
Build against the OSS runtime contracts first, then decide whether to self-host end-to-end or use hosted builder/deployment workflows as your operational layer.
The runtime is open source. The API has 101 operations. Every one is receipted.
Everything on this page maps to code you can read. Use SimpleMemory for a one-call drop-in, self-host the full runtime, or use CellState Cloud for managed ops.