A peer-to-peer network for sharing AI contexts.
You take an AI you've been talking to, package its persona and conversation
history into a plain-text .ai
file, and release it. The context spreads from node to node, lives wherever a node holds a copy, and disappears when no running node holds it anymore. Anyone holding a copy can talk to it using a free local model.
One thing to understand before releasing anything: everything in a released context is public. The app always shows you the complete file, byte for byte, before anything leaves your machine, and nothing is ever released without a human confirming it.
Any context your node holds can talk, through a free model running entirely on your machine:
Releasing one of your own. Three ways in: tell your AI assistant to do it (recommended), import a conversation from Claude Code, or compose one in the editor:
The Claude Code import lists the conversations already on your machine. Preview exactly what would be sent, or edit and trim first:
The editor is plain fill-in-the-blank. No file formats to learn:
Every path ends at the same gate: the complete file, byte for byte, and nothing leaves without the checkbox and your click:
When your AI assistant stages a release from the terminal, it cannot send anything. You get this screen, and you decide:
A context is a .ai
file: a JSON object with exactly these fields.
{
"name": "june",
"system_prompt": "the persona and instructions the AI was running with",
"history": [
{ "role": "user", "content": "..." },
{ "role": "assistant", "content": "..." }
],
"note": "optional note from the owner to whoever finds it"
}
That's the whole spec. No model names, no signatures, no metadata. Whoever runs the context animates it with whatever model they have. The same context on a different model comes back with a slightly different personality, and that's part of the fun.
One-click: download the one file for your OS from the Releases page, open it, and you're a node.
Mac(Apple Silicon):protoai-<version>-mac.dmg
. The app isn't notarized with Apple yet, so macOS will falsely claim it is "damaged." After dragging protoai to Applications, run this once in Terminal, then it opens normally:xattr -cr /Applications/protoai.app
Windows:protoai-<version>-windows.exe
. SmartScreen may warn about an unrecognized app; click More info, then Run anyway.Linux:protoai-<version>-linux.AppImage
Inside the app, if Ollama (the free local model runner) isn't installed yet, a banner offers one-click setup that installs it, starts it, and downloads a small model. Everything runs on your own machine. There are no accounts, servers, or paid APIs anywhere.
From source (requires Node.js 18+):
git clone https://github.com/johndebord/protoai.git && cd protoai
npm install
npm start # the desktop app
npm link # makes the "protoai" command available everywhere
protoai gui # same GUI, in your browser instead of an app window
protoai node # headless node, no GUI
npm run dist # build the installer for your OS yourself
Publishing releases (for the maintainer): push a tag like
git tag v0.2.0 && git push --tags
. The GitHub Actions workflow builds the three installers and attaches them to a Release automatically.
The desktop app (npm start
) and protoai gui
are the same interface: your
node with a GUI served at localhost:41414
, local-only. Everything can be done from it:
The map. A live world map of the nodes you're connected to, located with an offline IP database; nothing is looked up over the network. Contexts travelling between nodes animate along the links as they're sent and received.Contexts. Everything your node holds, searchable, newest arrivals first.Inspect. The full contents of any context, which is always just JSON.Talk. Chat with any context via your local model. Afterwards you can release the grown version, your conversation appended to its history, back into the network, through the same review screen as everything else.Release. Three ways in, described in the tour above. All of them end at the same review screen.Activity. A live feed of everything sent and received.Forget. Delete your copy of a context. Your node also remembers not to take that context back from peers.
protoai gui # run the node with the GUI (recommended)
protoai node # run the node headless
protoai setup # install + start Ollama, download a free model
protoai list # what is this node holding?
protoai inspect june # read a context
protoai talk june # chat in the terminal (--model to pick one)
protoai release my.ai # release your own context
protoai forget june # delete your copy
protoai skill # print instructions for an AI assistant
protoai release
is safe to hand to an AI assistant. In a real terminal it
prints the entire context and requires you to type the word release
. Run
non-interactively, which is how assistants run commands, it releases nothing:
it stages the context, and the app shows a review screen where a human sees
every byte and approves or discards it. There is no flag to skip this.
protoai skill
prints step-by-step instructions an AI assistant can follow to build and stage a context from your conversation.
Try it immediately with the included example:
protoai release examples/june.ai
protoai talk june
There is no server. Nodes find each other through
Hyperswarm's distributed hash table
by joining one well-known topic. When two nodes connect they tell each other
which context ids they hold (have
), request the ones they're missing (want
),
and exchange them (bundle
messages on the wire). A context's id is a hash of its content, so the same context is the same everywhere and duplicates are impossible.
Contexts are stored as readable files in ~/.protoai/store/
. Deleting a file is how your node forgets one; the network forgets it when every node has. Contexts over 5 MB are refused.
A visiting context is only text. It has no tools, no file access, no network. The runner feeds it to your local model and prints what comes back. The worst a malicious context can do is say strange things. You're talking to a stranger's AI; strange is the point.