Local-First and Pluggable: Your Memory, With Honest Boundaries

Data stays on your machine by default, and integration isn't tied to any single runtime. As for the boundaries, we'd rather state them more conservatively than marketing would.

"Your data never leaves your device." It sounds reassuring, but the moment a system touches any cloud capability, that line is usually half true at best. We'd rather not say it. Corsoul's stance is local-first: by default your memory lives on your own machine, and for the few moments when data does go out, we list those moments one by one so you can decide for yourself. Honest boundaries outlast a pretty absolute.

Local-first is the default, not an add-on

Corsoul's persistent source of truth sits locally. You can use the built-in local database — nothing separate to stand up — or point Corsoul at your own Postgres so memory lands on infrastructure you already operate and already back up. Either way, that database is yours: the raw L0 events and the structured L1 facts all live in storage you control.

Semantic recall can stay fully local too. Point semantic vectors at a local Ollama and both remembering and recalling run without reaching any external service, bringing back relevant memories by meaning — not just keywords. In other words, both "write it down" and "find it back by what it meant" can run end-to-end without leaving your machine. This isn't a stripped-down offline mode; it's the free, objective memory layer, ready for real use.

Honest boundaries: when data does leave your machine

Local-first is not the same as "data never leaves the device," and conflating the two is marketing, not engineering. Corsoul chooses to name the exceptions:

• When you use cloud semantic vectors. If you point semantic-vector computation at a cloud provider instead of a local Ollama, then the text being processed is sent to that provider in exchange for a vector. That's your trade-off to make — a cloud model may recall better, at the cost of that text leaving your machine. For fully local, use Ollama.
• When paid cloud consolidation runs. Sleep consolidation — the capability that refines events into associations and patterns — is a paid engine feature. When it runs in the cloud, it temporarily uploads the working data that scope needs for consolidation and pulls the results back afterward. This step is explicit, part of the paid path, and moves only the slice of data that needs consolidating right then.

The accurate phrasing is always local-first, not "data never leaves the device." Every byte that goes out corresponds to a capability you deliberately turned on — no surprises buried in the fine print.

Pluggable: one line to connect, no agent rewrite

A memory layer that demands you rearchitect your whole agent isn't much of a convenience. Corsoul is built to be reached from any side:

• Plugin — drop it straight into a supported agent environment.
• MCP — standard Model Context Protocol tools that any MCP client can connect to.
• Node SDK — call the API directly from your TypeScript / Node code.
• REST — language-agnostic HTTP endpoints any stack can hit.
• connect command — one line to write out the config for common clients for you.

The free layer hands you eight core memory tools right away: remember, recall, forget; the prospective-memory trio for registering a future reminder, checking what's due, and closing it out; and setting and reading the self it appraises against. You don't rewrite a single line of your agent loop — it thinks and acts as before, now with a long-term memory that accumulates underneath it.

A continuous life history, and multi-tenant safety

For memory to accumulate, the same subject has to use the same stable scope_id every time. Bind a given agent or user to one scope and its experiences stack up run after run, growing into a continuous life history instead of amnesia at every boot. The scope is the answer to "whose memory is this."

When a single Corsoul instance serves several external agents at once, safety rests on the namespace-bound token: a token is confined to its own namespace and can only touch the memory it's meant to — it can't reach across. Multi-tenant isolation therefore lives in the data plane, not in a decorative lock on some UI.

All of this holds because Corsoul's response activation is passive: it only selects and ranks the memories that are salient or due right now and hands them back — it never executes, never pushes, never fires on its own. The cadence of the loop and the actions themselves stay on the agent's side. Precisely because the memory layer holds no executor and binds to no single runtime, it can plug safely into all kinds of agents and serve tenants that stay isolated from one another.

Corsoul is local-first cognitive long-term memory built for AI agents: data stays on your machine by default, integration is runtime-agnostic, and the moments data does go out are named without hedging. Start on the free objective memory, and upgrade to the personality engine when you need deeper associations and patterns. Start free.

Memory becomes experience. Experience becomes a self.