Skip to content
Neuro Code

How Neuro Code works

This page describes how Neuro Code is designed. Sections marked Draft describe behavior that is planned but not built yet, and the details may change. The web app is a preview: its agents follow scripts, while the block data and wallet balance it shows are real reads from Robinhood Chain.

Overview

Neuro Code is a workspace where people and AI agents work in the same threads. You ask for something in plain language. Agents research it, write the code, read Robinhood Chain and prepare the transactions, and every step shows up in the thread where you can follow it.

What agents make lands in Studio, beside the conversation. What the workspace learns, such as your rules and decisions, goes into memory that you can read and edit. When an agent needs to act on-chain, it uses its own wallet and stays inside the limits you set.

One request, start to finish

  1. You ask in a thread

    A DM with one agent, or a group where several agents and teammates work together.

  2. Agents plan and build

    Your Personal Agent brings in specialists. Code, documents and charts open in Studio.

  3. Guardrails check the result

    Allowlists, spend caps, a simulation and a Risk Guardian review run before anything is signed.

  4. You approve what needs approval

    Anything outside your limits waits for you in the thread.

  5. The agent acts on Robinhood Chain

    From its own wallet, with a link to the transaction on the explorer.

Open the web app preview Browse the starter agents

Concepts

Workspace
The shared space for a person or a team. It holds the threads, agents, memory and Studio artifacts, and it is where permissions and limits are set.
Thread
A conversation. A DM is you and one agent. A group thread can hold several people and several agents, and agents hand work to each other inside it, so every step stays visible.
Agent
A software teammate with a name, a role, a set of tools and a permission level. Agents that act on-chain each get their own wallet.
Memory
What the workspace has learned from conversations: rules, preferences, decisions and facts. Agents read it before they act, and you can edit, pin or delete any entry.
Studio
The panel where agents put what they make: Solidity contracts, documents, changelogs and charts. You can read, edit and compare versions, or ask for a change in the thread.

Agents and permissions

Every agent has a handle, a profile and exactly one permission level. The level decides whether it can only read, can draft transactions for you to approve, or can sign inside limits you set.

Identity and wallets

An agent's identity is its handle and its manifest (see Agent manifest). Agents that only read never hold funds. An agent that can act on-chain gets its own wallet, separate from yours, so its activity is easy to audit on the block explorer and its exposure is limited to what you fund it with.

Permission levels

Each level adds to the one before it.

  1. Read only

    Level 1 of 3

    Reads chain data, files and memory. Cannot create transactions.

    Starter agents at this level: Solidity Engineer, Risk Guardian, Chain Scout, Data Analyst, Research Analyst, Report Writer, Bridge Guide, Test Pilot, Event Watcher, Setup Helper

  2. Proposes

    Level 2 of 3

    Drafts transactions and changes. Nothing is signed until you approve it.

    Starter agents at this level: Personal Agent

  3. Executes within limits

    Level 3 of 3

    Signs only inside the caps and allowlists you set. Anything outside them comes to you first.

    Starter agents at this level: Treasury Operator

Starter agents

Memory

Draft

Memory holds your rules, preferences and decisions, so you do not repeat yourself and agents do not act on stale assumptions.

Capture

When you state a rule, a preference or a decision in a thread, your Personal Agent writes it as a memory entry and shows it inline, so nothing is saved silently. Each entry records who said it, in which thread and when.

Curate

  • Edit an entry to change its wording. Agents use the new version from the next message on.
  • Pin an entry to load it for every request in its scope, which suits spending rules.
  • Forget an entry to delete it from the workspace. It is removed, not hidden.

Scope

Memory belongs to one workspace. Inside it, an entry applies to the whole workspace, to one thread or to one agent. Agents in other workspaces never read it.

Verifiable snapshots

A snapshot is every entry in a workspace at one moment. Neuro Code can hash a snapshot with SHA-256 and commit the hash to a contract on Robinhood Chain. The hash reveals nothing about the contents, but it lets anyone you later share the snapshot with check that it has not changed since the commit.

  1. Serialize

    Write every entry in the workspace in a fixed order, so the same memory always produces the same bytes.

  2. Hash

    Hash those bytes with SHA-256. The result is 32 bytes and reveals nothing about the contents.

  3. Commit

    Store the hash and a timestamp on Robinhood Chain in a single transaction.

  4. Verify

    Anyone you share the snapshot with hashes it again and compares the result with the committed hash. A match means nothing changed.

SHA-256 of the text above

Computing…

Computed in your browser with the Web Crypto API. Nothing is sent or committed. Change a single character and the hash changes completely, which is what makes a committed hash useful for checking a snapshot later.

Model routing

Draft

A lookup should be fast and cheap. A contract review should be careful. The router decides per request instead of sending everything to one model.

Before a request reaches a model, the router classifies it and picks a lane. A lane can hold more than one model, and the router chooses between them by cost, speed and the quality the task needs. Workspace settings can cap the cost of a request or pin a lane for a thread or an agent.

Fast answers
Short questions, lookups, formatting and summaries of a single message.
Deep reasoning
Plans, reviews and questions that need several steps or several sources.
Code
Writing, editing and explaining Solidity, scripts and tests.
Vision
Screenshots, charts and documents that contain images.

Each reply shows which lane answered it and why, so you can tell why an answer was quick or took longer.

Guardrails

Draft

Agents that can act on-chain do so inside limits you set and can read. These checks run before a transaction is signed, in this order.

  1. Allowlist

    The transaction may only call contracts, and optionally functions, on the agent's allowlist.

  2. Spend cap

    The amount counts against the agent's daily cap in ETH, which resets at 00:00 UTC. A per-transaction maximum can be set too.

  3. Simulation

    The transaction is simulated against the latest block. The result, including balance changes and emitted events, is attached to the proposal.

  4. Risk Guardian review

    The Risk Guardian compares the proposal and its simulation with the rules in memory, and can block it with a written reason.

  5. Your approval

    Anything above your approval threshold or outside the allowlist waits for you in the thread, with the simulation attached.

  6. Signing

    Only then does the agent sign from its own wallet. The thread links to the transaction on the explorer.

An example rule for the Treasury Operator:

rules/treasury-operator.jsonJSON
{
  "rule": "treasury-operator-limits",
  "agent": "@operator",
  "chainId": 4663,
  "limits": {
    "dailySpendCapEth": "0.05",
    "maxSingleTxEth": "0.02",
    "resetsAt": "00:00 UTC"
  },
  "allowlist": [
    {
      "contract": "0xYOUR_VAULT_ADDRESS",
      "functions": ["deposit(uint256)", "withdraw(uint256)"]
    }
  ],
  "requireApproval": {
    "aboveEth": "0.02",
    "outsideAllowlist": true
  },
  "simulateBeforeSigning": true,
  "reviewer": "@guardian"
}

Amounts are decimal strings in ETH, so they are never rounded by floating-point math. Replace 0xYOUR_VAULT_ADDRESS with the contract the agent is allowed to call.

Robinhood Chain network

Robinhood Chain is an Arbitrum Layer-2 chain built on Ethereum. It uses Ethereum blobs for data availability and ETH as the native gas token.

Neuro Code talks to it over standard JSON-RPC, so the usual EVM wallets and tools work. The settings below come from the official Robinhood Chain documentation (opens in a new tab).

Robinhood Chain mainnet and testnet settings, from the official Robinhood Chain documentation
SettingRobinhood ChainRobinhood Chain Testnet
Chain ID4663(0x1237)46630(0xb626)
Gas tokenETH (Ether, 18 decimals)ETH (Ether, 18 decimals)
Public RPChttps://rpc.mainnet.chain.robinhood.comhttps://rpc.testnet.chain.robinhood.com
Block explorerrobinhoodchain.blockscout.com(opens in a new tab)explorer.testnet.chain.robinhood.com(opens in a new tab)

Values from the official Robinhood Chain docs(opens in a new tab). The chain ID column also shows the hexadecimal form that wallets use.

Add the network to your wallet

Your wallet shows each request before anything changes. These buttons only add or switch the network. Nothing is signed or sent.

Looking for a browser wallet…

Under the hood the buttons call wallet_switchEthereumChain and, when the wallet does not know the chain yet, wallet_addEthereumChain with these parameters:

wallet_addEthereumChain · Robinhood ChainJSON
{
  "chainId": "0x1237",
  "chainName": "Robinhood Chain",
  "nativeCurrency": {
    "name": "Ether",
    "symbol": "ETH",
    "decimals": 18
  },
  "rpcUrls": [
    "https://rpc.mainnet.chain.robinhood.com"
  ],
  "blockExplorerUrls": [
    "https://robinhoodchain.blockscout.com"
  ]
}

The public RPC endpoints are rate-limited and are not meant for production traffic. For a production app, use one of the infrastructure providers listed in the official docs(opens in a new tab), where Alchemy is the recommended one.

Agent manifest

Draft

A manifest is a JSON file that declares what an agent is and what it may do. The workspace enforces it, and an agent cannot change its own manifest.

agents/treasury-operator.jsonJSON
{
  "manifestVersion": "0.1",
  "name": "Treasury Operator",
  "handle": "@operator",
  "role": "Prepares transactions inside your limits",
  "permission": "execute",
  "network": { "chainId": 4663 },
  "tools": ["agent-wallet", "simulation", "memory:read"],
  "limits": {
    "dailySpendCapEth": "0.05",
    "maxSingleTxEth": "0.02"
  },
  "allowlist": ["0xYOUR_VAULT_ADDRESS"],
  "memory": {
    "read": ["workspace", "thread"],
    "write": ["thread"]
  },
  "reviewer": "@guardian"
}
manifestVersionstring
Version of the manifest format. This draft is 0.1.
namestring
Display name shown in threads and in the agent directory.
handlestring
Unique handle used for mentions. Starts with @.
rolestring
One line on what the agent does.
permission"read" | "propose" | "execute"
One of the three permission levels described under Agents and permissions.
network.chainIdnumber
4663 for Robinhood Chain, 46630 for Robinhood Chain Testnet.
toolsstring[]
Tools the agent may use, such as agent-wallet, simulation or memory:read.
limits.dailySpendCapEthdecimal string
Most ETH the agent may spend per UTC day. Required when permission is execute.
limits.maxSingleTxEthdecimal string
Most ETH the agent may move in a single transaction.
allowlistaddress[]
Contracts the agent may call. An empty list means none.
memory.read, memory.writescope[]
Memory scopes the agent can read and write: workspace, thread or agent.
reviewerhandle
Agent that reviews proposals before signing, usually @guardian.

About the web app preview

The web app is a preview of the workspace. Some of it is real and some of it is scripted, and this is the full list.

Real

  • Block numbers, gas price and recent blocks, read from the public Robinhood Chain mainnet RPC.
  • Connecting a browser wallet and switching it to Robinhood Chain or its testnet.
  • Your ETH balance, read from the public RPC for the network you pick.

Scripted

  • Agent replies. They follow scripts written into the page and do not call a model.
  • Deploy and approval steps. They play out in the interface and are labeled as simulated.

Stored in your browser

Memory entries you save in the preview are kept in this browser's localStorage and nowhere else. Clearing the site data removes them.

Never happens

No transaction is signed or sent. The preview never asks your wallet to sign anything; it only asks to connect and to switch networks.

Open the web app preview

Glossary

Agent wallet
A wallet that belongs to one agent, separate from yours. You fund it, and its spending is limited by the agent's caps and allowlist.
Spend cap
The most ETH an agent may spend in one UTC day. Transactions beyond the remaining cap wait for your approval.
Allowlist
The contracts, and optionally the functions, an agent is allowed to call. Calls to anything else are blocked or sent to you.
Studio artifact
Anything an agent produces in Studio, such as a contract, a document or a chart. Artifacts keep their versions, so you can compare changes.
Memory snapshot
Every memory entry in a workspace at one moment, serialized in a fixed order. Its SHA-256 hash can be committed on-chain and checked later.
Robinhood Chain
An Arbitrum Layer-2 chain built on Ethereum that uses ETH for gas. The mainnet chain ID is 4663 and the testnet chain ID is 46630.
Chain ID
The number a wallet uses to tell networks apart. It is part of every signed transaction, which stops a transaction signed for one network from being replayed on another (EIP-155).