Get started
How it works
Three ideas carry the whole system: an allowance the assistant can't exceed, receipts for everything it does, and settlement that ties the rollup back to Solana.
Allowances
Each assistant gets its own USDC vault on Solana, held by the neuron_allowance program. The assistant signs with a session key that can only move money through the program, and only inside the owner's rules:
| The owner sets | Enforced on chain as |
|---|---|
| "Spend up to $20 a week" | A period limit; the period resets on the same weekday, even after idle weeks |
| "Ask me before anything over $10" | An ask-first threshold; bigger payments become spend requests |
| "Only buy from these stores" | An allowlist of payee wallets |
| The Pause button | Blocks every assistant action until unpaused |
- Session keys never need SOL. The key only signs; a relayer pays the transaction fee.
- Rotating the key revokes the old one immediately, without moving the funds.
- Classic SPL Token only. Token-2022 extensions such as transfer hooks or a permanent delegate could bypass the rules, so those mints are refused.
Ask-first requests
A payment outside the rules isn't refused outright. It becomes a spend request the owner reviews ("Found a $274 flight. Book it?"):
- The assistant calls
request_spend. It records the destination, the wallet that owns it, the amount and a memo. - The owner approves or cancels. On approval the program pays the exact destination requested, and only if it still belongs to the same wallet and the assistant's key hasn't been replaced since.
- Approved payments don't use up the weekly allowance: the allowance is what the assistant may spend without asking.
At most 16 requests can be open at once, so a looping assistant can't bury the owner in them.
Receipts
Every model call, tool call and payment becomes a receipt: a small JSON record with the provider and model, the tool, the amounts and the timing, plus commitments to the content.
- Private by construction. Prompts, outputs, tool arguments and results are committed with an HMAC keyed by a random salt per receipt. Nothing readable, or guessable, goes on chain. Revealing one salt opens one receipt.
- Batched. The runtime groups receipts into a Merkle tree and posts only the 32-byte root to the assistant's
neuron_receiptslog. Posting costs one transaction fee and creates no accounts. - Hash-chained. Every batch extends a chain that starts from a value unique to that log. Replaying the history must reproduce the on-chain chain, so dropping or editing a past batch is detectable.
- Checkable on chain. The last 8 roots stay in the log, so
verify_receiptcan check a proof directly, for example in an escrow.
The verified checkmark
When an assistant pays for a tool, the payment's on-chain memo is the hash of its payment receipt. A feed line like "Paid search tool, $0.02 ✓" is verified by:
- reading the
Spentevent from the payment transaction, - finding the receipt whose hash equals the memo in the published batch file,
- checking its Merkle proof against the root in the receipt log.
Settlement and the rollup
The Neuron rollup runs agent actions fast and cheaply, and adds sol_infer for on-chain inference. Its sequencer posts checkpoints (slot, blockhash, state root) to neuron_settlement on Solana:
- Each checkpoint must move forward and name the previous checkpoint's blockhash, so the posted history is one unbroken line, folded into a hash chain.
- Recent state roots become verifiable after a challenge window. During it, the admin can invalidate a bad root, or pause and rewind to a known-good checkpoint; the rewind is recorded in the chain too.
- A checkpoint is still the sequencer's claim. Proving it wrong (fraud proofs) and moving funds between the layers (the bridge) are the next steps. See Security & trust model.