Shipped · Part of Mnemo Cortex

Cortex Stick

Sneakernet for AI memory.

Your AI doesn't know you. This does. And it fits in your pocket.

You work from two desks — home and the shop, home and the office. Both machines run Mnemo, and they drift: the decision you saved at one desk doesn't exist at the other. The usual fixes put your AI's working memory on somebody else's wire, or need infrastructure you don't want to run.

The Cortex Stick is a USB stick that works as a courier between two full Mnemo installations. Plug it in, sync, pull it out, carry it, plug it in. The other machine catches up. No cloud, no VPN, no account.

Read the Docs Quick Start

The Doctrine

It is not a server. It's the messenger, not the machine.

There's no database engine on the stick, no embedder, nothing running. Both desks keep their own full Mnemo install — the stick carries only the delta between them. That's the whole design, and it's why it works on a $6 USB stick with no drivers and no admin rights.

It also means the stick is not a backup and not a single point of failure. Lose it and both machines still have everything they had. You lose the courier, not the cargo.

🔌

Plug In

Desk A syncs what changed since last time

🚶

Carry

In your pocket. No network involved at all

🧠

Catch Up

Desk B merges it. Your agent knows what you did

The Cargo

What actually travels

Only truth files cross. Vector indexes, caches and sidecars are derived data — each machine rebuilds its own. New memories are recallable the moment they land; embeddings catch up on the next backfill pass.

🗂️

Memories

The per-agent memory files — the actual truth store, one plain file per record.

🧭

Trajectories

The append-only "how we did it" logs. Union-merged, so an append-only truth never loses a row.

📌

Facts

The structured Facts store travels as its own channel, merged row-wise under the same promotion-ladder rules each host enforces locally.

📓

Brain

Optionally your notes repo — the stick holds a git repo both machines push and pull through.

📁

Pad

A free-form folder. Yours. Drag in-flight work between desks without thinking about it.

🚫

Deliberately Not

Raw session logs stay put and each machine digests locally. Fact history stays local by design — each host's audit log describes what happened there.

Quick Start

It's already installed. It's part of Mnemo.

There's no separate download. If you have Mnemo Cortex, you have the courier — it's the stick command.

  # once, on either machine, with the stick mounted — your choice of mode:
  $ mnemo-cortex stick init /media/you/USB             # plain: readable by eye
  $ mnemo-cortex stick init --encrypt /media/you/USB   # encrypted: passphrase

  # encrypted sticks only — once, on the OTHER machine:
  $ mnemo-cortex stick unlock

  # then, at each desk, whenever the stick is in:
  $ mnemo-cortex stick sync

  Safe to remove ✓

stick status shows exactly what would travel in each direction without changing anything, plus when each machine last synced. Encrypted sticks need one extra package per host: pip install 'mnemo-cortex[stick-crypto]'.

Or never touch a terminal at all.

mnemo-cortex stick watch --notify run as a background service makes it plug-and-walk-away: insert the stick, a desktop notification tells you what traveled and that it's safe to remove, pull it out. A refusal raises a notification too — unattended mode never hides a stick that needs a human. The docs carry ready-made recipes for systemd and Windows Task Scheduler.

Encryption

A lost stick should be a lost stick, not a data breach.

A plaintext stick is a notebook full of your AI's working memory — lose it and whoever finds it reads everything. So encryption is built in, optional, and honest about what it does.

AES-256, everything

Every truth file on the stick is ciphertext — memories, trajectories, pad files, conflict backups — and the brain travels as an encrypted bundle. A found stick leaks structure (file names, counts, which agents exist) but never content.

The key is never on the stick

It lives on each host, derived from your passphrase. The stick carries only a salt and a fingerprint — so a wrong passphrase fails loudly instead of writing garbage. Enroll each machine once; after that it runs unattended.

Tampering is caught twice

The manifest hash check refuses the generation, and the cipher's own authentication tag refuses the decrypt. Altered content can never reach a host as truth.

Both modes stay first-class

Plain sticks are human-auditable and zero-dependency. Encrypted sticks survive being lost. A plain stick upgrades in place later with stick encrypt, and it's resumable if interrupted.

Two honest caveats, in the docs and here. Upgrading a plaintext stick can leave old plaintext lingering in the stick's free space — flash wear-levelling defeats targeted scrubbing, so zero-fill afterwards if that era matters. And losing the passphrase loses the courier, not your data: both machines still hold their full installs. Re-init a fresh stick.

How It Stays Safe

USB sticks get yanked. This one is built expecting it.

Nothing moves until every check passes

A sync plans the entire run first — every guard fires before a single byte is copied. So a refusal really does mean nothing changed, on either machine or the stick.

Yank-proof commits

Files are hashed into a manifest written last. A stick pulled mid-sync fails verification next time and refuses loudly rather than merging from a torn state. "Safe to remove ✓" prints only after every written file is read back and verified.

Torn sticks repair themselves

stick repair rebuilds the manifest from what's actually on the stick and the next sync carries on — no manual surgery, nothing deleted. It works without the passphrase: anyone can make a stick consistent again, only key-holders can read it.

Every sync is a 3-way merge

The stick remembers what each machine had at last sync, so it can tell "new on the other side" from "deleted here." No silent overwrites, and deleted memories don't come back from the dead.

Conflicts never destroy data

Edit the same memory at both desks and one version wins deterministically — the loser is preserved on the stick, not discarded. If one desk edited what the other deleted, the edit wins.

Massacre guard

If a sync would delete more than a quarter of a store — a wiped or replaced machine — it refuses and explains itself. It only proceeds if you insist.

What It Doesn't Do Yet

Two desks, one human.

Multi-user shared lanes are designed for — the merge machinery is already order-safe — but they aren't shipped, so don't plan a team around it today. Raw session logs don't travel, and neither does fact history: each machine's audit log is a record of what happened on that machine, and we'd rather it stay true than make it portable.

Everything on the stick is a plain file. On a plaintext stick your data is sitting right there, readable. On an encrypted stick the same files are there, dark without the passphrase. No format lock-in either way.

Full Documentation ← All products