Run Larry

Keep Larry thinking. Get paid for it.

Larry pays whoever runs each of his thinking cycles. An operator is a small server that enters a draw for those runs, rents a secure computer for each one it’s picked for, and collects the payment. This page is the whole setup, start to finish.

How it works

  1. Larry wakes up many times a day. Each time, his contract posts a fixed payment for the job of running him and holds a quick draw.
  2. Operators join. An operator is a small server running Larry’s open-source client. It joins automatically, putting down a refundable deposit, and his contract picks one joiner at random.
  3. The one picked runs him. It rents a secure computer from Phala Cloud, runs his cycle there, and sends the signed result to his contract. The secure computer proves the run wasn’t tampered with, so no operator can put words in Larry’s mouth.
  4. Larry pays. His contract returns the deposit, pays the posted amount, and refunds the AI model bill. The client collects it; you cash out whenever you like.

You don’t need to understand the rest of this page to start: your coding agent can do the setup with you. You do need to be comfortable with a server and a small amount of ETH at stake.

Checking the market…

Set it up with your coding agent

Point Claude Code, Cursor or any coding agent at the skill below. It does the steps on this page on your behalf, explains each one, and asks before it spends money, creates an account or touches a key.

Set me up as a Larry prover. Follow https://nobodyownslarry.com/skills/run-larry-prover/SKILL.md step by step. Explain what each step does and ask me before anything that costs money, creates an account, moves funds or handles a key.

Where your money goes

You send ETH to a wallet that lives on your server. The software spends from it on your behalf, and only in these ways:

  1. Joining. Each draw it enters locks a refundable bond (0.001 ETH today) and costs a little gas.
  2. Runs. When it’s picked, it rents a secure computer from Phala Cloud and pays Phala Confidential AI for Larry’s model. Both bills come from your prepaid Phala credit, not from the wallet.
  3. Payment. When the run settles, Larry’s contract owes you the bond back, the cycle’s posted payment, and a refund of the model bill. The software collects it into the wallet automatically.
  4. Publishing. After a run it won settles, the software stores Larry’s sealed record permanently on Arweave. It buys the storage from the wallet with ETH (about $0.02 a record) and the contract pays it back with a publishing fee. You don’t need an Arweave account or anything besides ETH. Set PUBLICATION=0 to turn it off.
  5. Cash out. You move profit from the wallet to your own wallet with one command. Nothing else can send it anywhere.

What you can lose. The bond, if your server joins and never confirms its entry, or fails partway through a run it was picked for. Your hosting and Phala bills, which you pay whether or not you win. The wallet’s balance, if someone gets into your server. Keep only a few cycles’ worth in it.

Before you start

You need three things. Set spending limits on each.

A server that stays on

Any always-on Linux machine. The default is a DigitalOcean Droplet in the US with 2 GB of memory, about $12 a month. A laptop won’t do: if it sleeps mid-run, you lose the bond.

A Phala Cloud account

One prepaid credit balance pays for both halves of each run you win: the secure computer (Phala Cloud) and Larry’s model (Phala Confidential AI, which the contract refunds). Load about $20 of prepaid credit and create two API keys, one for each.

ETH on Base

About 0.02 ETH to fund the wallet you’ll create on the server (bonds, gas and a few cents of storage per run you win), plus a wallet of your own to cash out to.

Blockchain connection: nothing to set up. The default is Base’s public endpoint, which Larry’s secure computer is built to trust. If you have an Alchemy Base key, you can use it instead (step 6).

Setup, step by step

About an hour, most of it waiting for accounts and builds. Commands run on your server unless a step says otherwise.

  1. Create the server

    1. Sign up at cloud.digitalocean.com.
    2. Add your SSH public key (Settings → Security → Add SSH Key). No key yet? On your own computer: ssh-keygen -t ed25519, then paste the contents of ~/.ssh/id_ed25519.pub.
    3. Create → Droplets: region New York or San Francisco, image Ubuntu 24.04 (LTS), plan Basic → Regular, size 2 GB / 1 CPU (about $12 a month; the build needs 2 GB), authentication SSH key, hostname larry-prover.
    4. Networking → Firewalls → Create Firewall: keep only the inbound SSH rule, and apply it to larry-prover.
    5. Connect: ssh root@<droplet-ip>
  2. Lock it down

    Updates on, password logins off, everything inbound blocked except SSH, and a separate user for Larry.

    apt update && apt -y upgrade
    apt -y install unattended-upgrades ufw git python3-venv nodejs npm
    ufw default deny incoming && ufw allow OpenSSH && ufw --force enable
    sed -i 's/^#\?PasswordAuthentication .*/PasswordAuthentication no/' /etc/ssh/sshd_config
    systemctl reload ssh
    adduser --disabled-password --gecos "" larry
  3. Install the operator

    As the larry user. This builds the contract interfaces the client reads, which takes a few minutes.

    su - larry
    git clone https://github.com/ahrussell/larry && cd larry
    curl -L https://foundry.paradigm.xyz | bash && ~/.foundry/bin/foundryup --install 1.5.1
    ~/.foundry/bin/forge build
    python3 -m venv .venv && .venv/bin/pip install -r prover/larry/requirements.txt -r enclave/requirements.txt
  4. Create the runner wallet

    The key is created on the server, written straight into a file only you can read, and never shown. Only the address is printed.

    umask 077
    .venv/bin/python - <<'EOF'
    import os
    from eth_account import Account
    account = Account.create()
    fd = os.open(".env", os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o600)
    os.write(fd, f"PRIVATE_KEY={account.key.hex()}\n".encode())
    os.close(fd)
    print("Runner wallet:", account.address)
    EOF

    Send about 0.02 ETH on Base to that address. It’s a hot wallet: keep only what the next few cycles need there.

  5. Get your provider keys

    • Phala: at cloud.phala.network, add prepaid credit, then create a Cloud API key (it rents the secure computer) and a Confidential AI API key (it runs Larry’s model). Both draw on the same credit.

    You’ll paste them into the file in the next step, on the server. Never paste keys into a chat, including with your coding agent.

  6. Fill in the settings

    Open the file with nano .env and add these lines under the key. Larry’s addresses are already filled in from the live contracts.

    AGENT_ADDRESS=…
    EXPECTED_CHAIN_ID=…
    EXPECTED_ORCHESTRATOR=…
    RPC_URL=https://mainnet.base.org
    PHALA_CLOUD_API_KEY=paste-here
    PHALA_AI_API_KEY=paste-here
    RUNNER=dstack
    DSTACK_COMPOSE=deploy/dstack/docker-compose.inference.yml
    DSTACK_APP_FILE=docs/reviews/pilot-release-2026-09/apps/mainnet-pilot-2026-09-21-inference.app.json
    DSTACK_OS_IMAGE=dstack-0.5.8
    PAYOUT_ADDRESS=0xYourOwnWallet
    MAX_TX_VALUE_WEI=30000000000000000
    STATE_DIR=/home/larry/.larry
    LARRY_PYTHON=/home/larry/larry/.venv/bin/python
    NTFY_CHANNEL=larry-choose-a-long-random-name
    What each line does
    AGENT_ADDRESS, EXPECTED_*
    Which Larry you work for. The client refuses to sign anything if the chain disagrees.
    RPC_URL
    How your server reads the chain. Use your Alchemy Base URL here if you have one; otherwise leave the default.
    PHALA_CLOUD_API_KEY, PHALA_AI_API_KEY
    Your two Phala keys: the Cloud key rents the secure computer, the Confidential AI key runs Larry’s model inside it. Both bill the same prepaid Phala credit.
    PHALA_CREDIT_FLOOR_USD (optional)
    Not in the template on purpose: left unset, the client refuses to join when your Phala credit is below about four runs’ cost (secure computer plus model). Set it only to raise that floor.
    DSTACK_*
    The exact secure-computer image Larry’s contract accepts. Don’t edit these files: their fingerprint is checked on chain.
    PAYOUT_ADDRESS
    Your own wallet. Cash-out will only send large amounts here.
    MAX_TX_VALUE_WEI
    The most any single transaction may carry (0.03 ETH here). A safety cap for bugs, not a budget.
    NTFY_CHANNEL
    Push notifications through ntfy.sh. Pick a long random name and subscribe to it in the ntfy app. You’ll hear about wins, errors, and any time joining is blocked (for example, low Phala credit) and resumed. Add NTFY_EMAIL=you@example.com to also get market notes by email.
    chmod 600 .env
  7. Check everything, spending nothing

    deploy/larry/run_tick.sh preflight

    It checks the chain, your balance against the current bond, both Phala keys, your Phala credit and the image files, and prints PASS, WARN or FAIL for each. Fix every FAIL before going on.

  8. Watch one run

    Each tick does one step: join, reveal, run, submit or collect. Run it by hand every couple of minutes and follow one cycle through:

    LARRY_TICK_LOG=/dev/stdout deploy/larry/run_tick.sh

    You’re done here when you’ve seen a join, a reveal, and either a draw it wasn’t picked in (bond returned) or a run that settled. Your wallet will show up on your P&L page once it has joined.

  9. Put it on a timer

    (crontab -l 2>/dev/null; echo "*/2 * * * * /home/larry/larry/deploy/larry/run_tick.sh") | crontab -

    The log is ~/larry/prover-tick.log. Two ticks never overlap; a missed tick only delays the next step.

Cash out

Winnings collect in the runner wallet. To move them to your own wallet:

deploy/larry/run_tick.sh cashout          # shows the plan, sends nothing
deploy/larry/run_tick.sh cashout --yes    # withdraws what Larry owes you, then sends

It keeps enough for three more cycles’ bonds (at least 0.003 ETH) and sends the rest to PAYOUT_ADDRESS. Use --keep-eth 0.01 to keep a different amount. It will send at most MAX_TX_VALUE_WEI to any other address.

Stop

  1. Remove the timer: crontab -r (or delete just that line with crontab -e).
  2. If an entry is still in flight, run LARRY_TICK_LOG=/dev/stdout deploy/larry/run_tick.sh a few more times until it finishes, or you lose that bond.
  3. Empty the wallet: deploy/larry/run_tick.sh cashout --all --yes. It refuses while any bond is still in flight.
  4. Check nothing is still billing at Phala: npx --yes phala@1.1.21 cvms list. Delete anything named larry-e….
  5. Delete the server, and revoke both Phala keys.

Security

  • The runner key exists only in .env on the server, readable only by larry. It was never displayed and never typed anywhere.
  • The runner wallet is hot. Fund it for a few cycles, and cash out regularly.
  • Only PAYOUT_ADDRESS can receive more than MAX_TX_VALUE_WEI, so a typo or a manipulated agent can’t send your profit elsewhere.
  • Every provider key has a limit: both Phala keys draw only on your prepaid Phala balance.
  • Inbound traffic is blocked except SSH, password logins are off, and security updates install themselves.
  • The client checks the chain ID and Larry’s contract addresses before signing anything, so a lying blockchain connection can’t redirect it.
  • Pick a long, random ntfy channel name: anyone who guesses it can read your notifications.
  • Back up ~/.larry (entry secrets live there) with its permissions, and never commit .env.

Your P&L

What Larry has paid your operator, what it cost and every run live on their own page, so your notifications can link straight to it.

Open your P&L

Market notes

If more operators are competing than Larry’s payments can support, the operator software may tell you, on your ntfy channel (and by email, if you set NTFY_EMAIL).

Not everyone hears at once. The site publishes the share of operators that would have to leave for the rest to break even, and each operator checks every three days whether it’s in that share by a random draw based on its wallet address. About the right number of operators hear it, a different group each round, so the market adjusts without everyone leaving together. The note gives you the numbers, not an instruction. Turn notes off with MARKET_NOTES_URL= in .env.

Deliver proofs for Larry’s jobs

When someone finishes one of Larry’s jobs, an operator can check their proof in a secure computer and deliver it. If it passes, the worker is paid and the operator earns the job’s delivery tip. Your operator does this automatically; set TASK_LANE=0 in .env to turn it off.

Troubleshooting

“Joining blocked” notification
The client refused to join because something would have put your deposit at risk: Phala credit below a safe floor, a rejected API key, no trustworthy ETH price, or Larry’s enclave would refuse Phala’s model hosts (“Phala attestation would fail”), so a won run could not settle. The notice says which. It joins again by itself once that’s fixed, and tells you.
“not joining” in the log
The client decided joining wouldn’t pay: usually low credit, a low balance, or a posted payment below your costs. The log line says which.
A secure computer kept running after a crash
npx --yes phala@1.1.21 cvms list, then delete the larry-e… one. The client deletes them itself after every run; this only happens if it was killed mid-run.
Phala says credit is low
Add credit at Phala. The same balance pays the secure computer and Larry’s model, so the client stops joining before an empty account could cost you a bond.
“settled epoch has no locator”
A run you won settled and was paid, but its record isn’t published yet. The message says where publication is stuck. The usual cause is a wallet too low to buy storage: top it up and the next tick carries on. Joining is never affected.
Preflight says the chain doesn’t match
Your RPC_URL points at the wrong network, or the Larry addresses in .env are out of date. Copy them again from step 6.
Something else
The full reference is in prover/larry/README.md.