How Neuron works.

#Your first private chat.

There is no sign-up form, no card and nothing to install. Any Solana wallet works: Phantom, Solflare, Backpack, OKX, MetaMask and others. On a phone, the app opens itself inside your wallet’s browser.

1. Connect and sign. One line of text, no transaction.
2. Add credits in USDC, from $5. That is about 11,100 messages to Claude Haiku 5.5.
3. Ask. Pick any model; switch whenever you like.

#A signature, not an account.

The app asks your wallet to sign the text below. The server checks the signature against your address, refuses anything older than ten minutes, and hands back a session that carries your address and an expiry seven days out, sealed with a server secret. Signing moves no funds.

Sign in to Neuron

Wallet: 7xKX…q2Pd
Issued: 2026-10-25T14:02:11.000Z

This signs no transaction and moves no funds.

#What leaves your browser.

Every request is rebuilt from three things only: the messages, the model, and the model’s own settings. Your wallet, any metadata and your IP never travel with it.

It goes out through OpenRouter with routing locked to providers that keep no data (zero data retention). If a model has none at that moment, the request fails instead of falling back to one that does. Type below and watch both sides.

{  "account": "usr_88120",  "email": "you@mail.com",  "ip": "84.21.140.7",  "device": "iPhone 16 · Seoul",  "card": "visa •••• 4242",  "history": "kept",  "prompt": "is it bad that i lied on my resume about one year"}

{  "model": "anthropic/claude-sonnet-5.5",  "messages": [{ "role": "user",    "content": "is it bad that i lied on my resume about one year" }],  "provider": { "zdr": true }}

#One key for everyone.

Every Neuron user reaches the model under the same key. To the provider that is one customer sending many requests. It can count them; it cannot tell whose is whose.

#What we keep.

Two things, both needed to bill you, and nothing else.

#History on your device.

By default a conversation lives only in the open tab. If you choose to keep history, your wallet signs one more fixed line, and your browser turns that signature into a key that never leaves it:

Wallet signatures of this kind are deterministic, so the same wallet rebuilds the same key on another device. Nothing about your history reaches our server. Conversations can be renamed, exported as Markdown, or deleted from the sidebar.

#Memory in the chat.

Turn on Memory under the message box and the chat keeps what you ask it to, locked with a key only your wallet can make. Start a message with “remember” and that sentence is locked in your browser before it is sent to be kept.

remember that my sister Hana lives in Busan and runs a bakery

… a week later, on another device …

What does Hana do?

Every later question first opens your memory in the tab, picks the few entries that match it, and sends only those to the model, as a short note beside your words. The rest stays on the device, and nothing ever reaches our server unlocked.

• Two signatures to turn it on. One makes the memory key, one gives this browser a token to reach your memory. Neither is a transaction.
• Any device. The same wallet makes the same key, so a phone opens what a laptop kept.
• 1.0 MB free for every wallet, thousands of memories. See, open and forget them, issue agent tokens and buy more space at /memory.

#Any agent, one command.

Claude Code, Cursor, Claude Desktop or any MCP client gets the same memory through neuron-mcp, a small server that runs on your machine. Make your key and a token at /memory; the page prints the command with all four values filled in.

claude mcp add neuron \
  -e NEURON_API=https://neuronmemory.app \
  -e NEURON_WALLET=<your address> \
  -e NEURON_KEY=ek1_… \
  -e NEURON_TOKEN=et1_… \
  -- npx -y https://neuronmemory.app/neuron-mcp.tgz

The key is shown on that page and nowhere else; treat it like a password. Optional settings: NEURON_PAYER and NEURON_MAX_USDC_PER_DAY (an agent that pays for its own space, below), NEURON_GATEWAYS (IPFS gateways to fall back on), NEURON_HOME (where sealed capsules are cached).

#The key and the lock.

Your wallet signs a fixed line that says it moves no funds. The signature becomes a 256-bit key on your device, and each memory is locked with it before it leaves:

• Forgetting. A memory not sealed yet is deleted. A sealed one is kept, as promised, and marked forgotten so recall leaves it out.
• Losing the wallet. The memories cannot be opened, by you or by us. There is no reset.
• Size. One memory holds at most 16 KB.

#Sealed every night.

In the first minutes after 00:00 UTC, every open memory from the day before joins its wallet’s capsule for that day, and each capsule names the one before it. The day, the count and the previous address are plain; the entries are locked. The file is named by a hash of the wallet, never the address.

{
  "v": 1,
  "day": 20753,
  "prev": "bafy…/3c1e9a….json",
  "count": 3,
  "entries": [{ "id": "…", "at": 1793059200, "iv": "…", "data": "…" }]
}

All of a day’s capsules go into one directory, packed as one CAR under one IPFS address. Each finished day the keeper posts a Checkpoint to the Neuron program with the root of every wallet’s newest capsule, so anyone can check where a chain ends without asking us:

Resurrection: from the newest capsule, follow prev back to the first. Any IPFS gateway serves the capsules and your key opens them; nothing else is needed.

#Three copies, checked.

Every sealed day goes to three independent places: IPFS pinning services (Filebase and Pinata today) and the Neuron node, this server’s own IPFS node. Each copy is fetched through its provider’s own gateway every day and its bytes hashed against the address; a copy that fails three checks in a row is rebuilt from a healthy one.

Space is priced so it is paid for good: three copies’ first year up front and the rest into a pool whose floor yield pays the rent every year after. One USDC buys about 50.1 MB today; a memory is a few hundred bytes.

#Agents that pay.

An agent whose memory wallet is out of space pays for more itself, inside the request that needed it, in USDC.

1. 402. POST /api/memory answers 402 with x402 terms: the scheme neuron-purchase, the USDC amount, the program, the wallet the space is for and a one-time reference.
2. Build. The agent asks POST /api/x402/tx for that exact purchase, paid by its own wallet, and signs it.
3. Pay and keep. It repeats the request with X-PAYMENT. The server checks the transaction is that one purchase, sends it, counts it from the program’s own event, keeps the memory, and says so in X-PAYMENT-RESPONSE.

{
  "x402Version": 1,
  "accepts": [{
    "scheme": "neuron-purchase",
    "network": "solana",
    "maxAmountRequired": "1000000",
    "payTo": "<program>",
    "asset": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    "maxTimeoutSeconds": 900,
    "extra": { "beneficiary": "<memory wallet>", "reference": "<32 hex>", "build": "https://neuronmemory.app/api/x402/tx" }
  }]
}

With neuron-mcp, set NEURON_PAYER (a Solana keypair holding some USDC and a little SOL) and NEURON_MAX_USDC_PER_DAY (default 1) and it does all of this when remember runs out of space. A reference is used once and expires after 15 minutes. It is the same purchase as any other, so the same split applies. x402 opens with the program at launch.

#Two rooms.

#Prices, in the open.

One credit is one cent and never expires. A request costs the provider’s own price for its tokens, read live, plus 12%. A typical message, 1,500 tokens in and 500 out, costs

Read at 04:24 UTC. A wallet may send 60 requests a minute and four at once.

#Web search.

Turn on Search under the message box and the model may look things up before answering, with the provider’s own search where it has one. Sources are listed under the answer.

#Make one, or send one.

Make one: pick an image model (Gemini’s image models have zero retention routes) and describe the picture. It comes back in the chat and is kept only if history is on, encrypted like the rest.

Send one: attach an image to ask a model that can see. It is shrunk in your browser, travels inside the request, and is never stored by our server.

#The API.

Neuron speaks the OpenAI chat format at https://neuronmemory.app/api/v1. Make a key in the app under Billing → API keys. It starts with hk_, is shown once, and spends your wallet’s credits.

curl https://neuronmemory.app/api/v1/chat/completions \
  -H "Authorization: Bearer hk_..." \
  -H "Content-Type: application/json" \
  -d '{"model": "anthropic/claude-haiku-5.5", "messages": [{"role": "user", "content": "Say something quiet."}]}'

Memory endpoints

Errors

#Every purchase, split.

Chat credits and memory space are both bought by paying the Neuron program on Solana in USDC, by people in the app and by agents over x402 alike. The program divides each payment before the transaction ends:

#Staking, paid in USDC.

Stake $NEURON and you are paid your share of every purchase in USDC, in the same transaction that pays for it:

• Paid at once. Your share lands with each purchase; claim whenever you like.
• Locked 24 hours. Staking or adding to a stake locks it for a day, so no one can borrow tokens, collect and leave in one block.
• Counted as received. A stake counts what the vault actually received, so a token with a transfer fee cannot inflate it.

Stake and claim in the app at app/stake.

#What holders get.

• USDC from every purchase. Staked $NEURON receives 10% of every purchase, chat credits, memory space and agents paying over x402, split by stake.
• Buyback and burn. 10% of every purchase buys $NEURON on the open market and burns it.
• Memory space. A wallet holding or staking 1,000,000 $NEURON gets 1.00 GB more memory, room for millions of memories, from a snapshot taken once a week.

An example, not a forecast: if people and agents spend $20,000 in a month, stakers share $2,000 in USDC and $2,000 of $NEURON is bought and burned. A wallet with 1% of all staked $NEURON gets $20 that month. The holder numbers are proposed and set at launch.

#Buyback and burn.

The buyback part of every purchase goes to a single wallet whose only job is to buy $NEURON on its market and burn it. Both transactions are public, and the burned total is read from the token’s supply below.

#What the admin can do.

Only the program’s upgrade authority can set it up. After that, the admin key has exactly these powers, and nothing pauses staking, moves staked tokens or takes rewards.

Program: CtTn5A2GD4RebP3AdGNyBGPM6LSSsBpx51bVWETuAD5r, deployed at launch.

#Live numbers.

Starts at launch

The yearly rate is last week’s USDC to stakers scaled to a year, over what is staked at today’s price. It moves with every purchase and is not a promise.

#Who sees what.

#Limits, stated plainly.

• Zero retention is a promise. That providers keep nothing rests on their terms and on the routing above. The sealed room is how open models move from promise to proof.
• Our server relays your words. It sees them in passing and is trusted to keep nothing, as described here.
• A wallet is a name. The chain links an address to its purchases and to where its USDC came from. A fresh wallet used only for Neuron keeps those apart.
• Recall sends what matches. With Memory on, the entries that match a question go to the model with it. Keep in memory only what you would say to the model anyway.
• The wallet is the key. Lose it and no one can open the memory, us included. Anyone who can sign with it can.
• Words can name you. A message that identifies its writer still does, whoever carries it.
• Answers can be wrong. Neuron changes who keeps the conversation, not what the model knows. Nothing here is financial, medical or legal advice.

#What comes next.

• The sealed room: open models inside hardware enclaves, with a public signed report for each.
• A stakers’ allowance: free messages every week for staked $NEURON.
• Studio: video and audio under the same rules.
• Desktop: the same room and the same memory, with tools.

#Questions.