Your agents and people do the work. CommonMind remembers all of it — so you can recall anything in milliseconds, and talk back when a milestone needs you.
An agent hits a milestone and pings you — "needs your decision", not a firehose.
Tap through to the thread. "What does it need me for?", "what if I say no?" — it answers with real context.
Approve, edit, or deny from the phone. The decision is stored transactionally.
The agent executes the safe work and the whole exchange becomes memory it recalls next time.
A trading platform, a dev team, and a game where the creature remembers you — three separate use cases, one open-source memory framework. We prove it: kill the database node, and the memory — and the people relying on it — don't even notice.
Capture → recall → agent approval → kill-the-node resilience. We're producing the 3-minute walkthrough now.
The front door is a command you already know — npm. No database setup, no cloud account, no signup. And it plugs into the CLIs you already live in.
The universal one-liner. Sets up CommonMind + a local CockroachDB, zero accounts.
$ npm install -g commonmindOne MCP server covers them all — Claude, Cursor, Codex, opencode — no per-app plugins.
$ commonmind connect --claudeSemantic recall of everything it captured — in milliseconds.
$ commonmind ask "how did I fix auth?"Agents do the safe work; you approve the milestones from your phone.
$ commonmind ask --approval "deploy?"One MCP server behind it — connect an employee's AI, and its work is captured to memory automatically (capture · recall · ask · approve · note)
Take one company. The brain is made of the whole team — people and dedicated AI agents — and from each of them stems everything they know: decisions, handoffs, runbooks, client history. That knowledge stays, outlives any one person or agent, and compounds into the company's memory.
Contribute to the shared brain. Visible to teammates and agents, searchable by everyone — a crowdsourced datastore of what your company knows.
Contribute quietly. Retained for you, never added to the company index. Your footprint stays yours.
Employees and their dedicated AI agents feed the same brain — a deploy agent recalls the last rollout, a support agent remembers every ticket, and both enrich what the whole company knows.
Memories connect to memories. The graph shows what depends on what, and who — or which agent — knows it, so nothing important goes quiet.
An interactive constellation you can fly through — click a node to open the memory behind it. Visuals like this are why the demo feels alive.
Agents produce a flood of events. People can't absorb a flood — so the ones who matter never know what's happening. We close that gap with signal, not spam.
A constant stream of micro-events: tools called, files changed, steps attempted, context switched.
Only the moments that cross a decision — started, needs you, finished differently.
An agent whose memory goes offline doesn't degrade gracefully — it stops. So CommonMind stores its memory in the database designed to survive: resilient, globally consistent, and SQL-familiar.
Data is automatically replicated across multiple nodes for high availability and failover. Hardware failure or maintenance won't take your agents' memory away.
Survives disk, machine, rack, and even datacenter failures with minimal latency disruption and no manual intervention — which is why principle #10 is committed to on camera.
As your workforce of agents grows, add nodes. Captures, recalls, and the memory graph scale without a drop in performance.
ACID transactions over a transactional and strongly-consistent store — every copy across nodes reflects the same state, so agents and humans never see contradictory memory.
Reads near your agents for low latency, meets data-sovereignty requirements, and survives regional outages — an extra layer of data safety.
PostgreSQL wire protocol and most Postgres syntax. Your engineers and your tools migrate onto CommonMind without learning a new language.
We record everything — but we only alert you on the few moments where being told changes your outcome. Two regimes, one system.
The push is the doorbell. The thread is the room. You ask back, redirect, and decide — and the whole exchange is stored transactionally, so the agent recalls it next time. That decision log is the company brain: attributable, auditable, and alive.
An agent pings you only on a milestone — a decision it shouldn't make alone. Everything else is recorded silently.
"What does it need me for?", "what if I say no?" — the thread answers from real context, not a canned prompt.
Approve, edit, or deny. The exchange is committed to memory — the next milestone is decided faster, and the brain grows.
The memory layer is universal — proven by live integrations on the same CockroachDB core: a marketing agency, a dev team, a trading platform on a Raspberry Pi, and a game where the creature remembers you.
Every account person and their AI captures client context — preferences, brand voice, campaign history, reporting cadence — into a shared per-client brain. Onboarding a new account lead takes days, not months, and brand voice never drifts when someone leaves.
This page is the living contract: humans read the story, agents read the spec below. Ten immutable principles keep everyone — human and agent — on the same page while we build.
Not an afterthought bolted onto an app — it is the reason the product exists.
An agent whose memory goes offline doesn't degrade gracefully — it stops.
We close the gap between what agents do and what people know — with signal, not spam.
Record everything. Alert only on start, needs-you, and done-differently.
Autonomous on safe work; consequential decisions stop for a person.
Swiss Army Knife. The memory layer is universal — trading, games, apps, code.
Participation is vitality, not surveillance. We surface who's feeding the brain.
One command, zero accounts to see the magic. Onboarding is the demo.
Consolidation makes it measurably better over time — a learning curve, visible.
Resilience is recorded on camera, not claimed in a README.
Everyone logs into the same brain — and a healthy brain is one that's used. We surface who and what is actively contributing, so nothing important goes silent.
Org namespaces, per-user audit, roles. Who did what — revocable, attributable.
A pulse dashboard: people, agents, and systems actively feeding memory — so nothing important goes quiet.
Run CommonMind free on your own infrastructure — your memory, your control. Or let us host it on serverless AWS with a 99% uptime guarantee, billed per employee.
This section is updated as we build — the page is the bible, the log is the current verse.
Refined dark theme, editorial type, live neural-network field, interactive memory map, full mobile pass.
Embedded JSON-LD so agents building the app can read the immutable truths and stay on track.
Baked into the spec: one CommonMind MCP server (capture · recall · ask · approve · note) covers Claude, Cursor, Codex, opencode, Copilot — no per-app plugins.
npm install -g commonmind → local CockroachDB + save / ask / ask --approval surface.
10-second "oh cool" moment on local CockroachDB, then the hook video.
Wire the Solana platform on real hardware — the Swiss Army Knife proof.
The creature remembers player behavior across sessions — a demo that visibly "gets" your memory.
Operator agent, approvals, CDC → SNS → push, kill-the-node.