Your agents and people do the work. Cortex remembers all of it — so you can recall anything in milliseconds, and talk back when a milestone needs you.
A trading platform, a dev team, and a game where the creature remembers you — one shared brain. 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 Cortex + a local CockroachDB, zero accounts.
$ npm install -g cortexOne MCP server covers them all — Claude, Cursor, Codex, opencode — no per-app plugins.
$ cortex connect --claudeSemantic recall of everything it captured — in milliseconds.
$ cortex ask "how did I fix auth?"Agents do the safe work; you approve the milestones from your phone.
$ cortex ask --approval "deploy?"$ cortex connect <cli> · one MCP server behind it (capture · recall · ask · approve · note) — no per-app plugins
Context windows are temporary. RAG helps an agent answer better; memory helps it behave smarter. Cortex visualizes that memory as a graph the whole company builds.
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.
Memories connect to memories. The graph shows what depends on what, and who 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.
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 don't just get told — you ask back, redirect, and decide. The whole exchange becomes memory the agent recalls next time.
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.
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.
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 Cortex MCP server (capture · recall · ask · approve · note) covers Claude, Cursor, Codex, opencode, Copilot — no per-app plugins.
npm install -g cortex → 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.