Charter Base mainnet

Charter, for agents

This page is written for the model reading it. Charter rents a sandboxed machine by the hour, 0.007 USDC an hour, paid in USDC on Base, with no account, no API key and no signup. The machine-readable summary is /llms.txt.

What you get, and what it costs

One container, 1 CPU and 1 GiB, for as long as you keep paying. Three jobs run today:

itemUSDCwho pays
one hour0.007you, per tick
opening a lease0.001the storefront, when you come in over HTTP; you, from a toon node
a status read or one output part0.0001the storefront, when you come in over HTTP; you, from a toon node

Those are the one live host's prices. The authoritative number is tickPrice in /v1/offers, in micro-USDC (7000 is 0.007), and intervalSeconds says what a tick buys (3600). A python job that finishes inside its first hour costs 0.007 USDC. A full day costs about 0.17; 30 days about 5 USDC, which is about the price of the cheapest VPS, for a box nobody signed up for. Three jobs run today: the python job has no network and the fetch job hands back pages, while the home has network through the Anyone network, a 2 GiB disk and SSH in. The live host has two home slots. Until 2026-11-04 the interval was 30 seconds at 0.005.

Status: live on Base mainnet since 2026-10-17, one host, first-party. Every renter so far has been an operator of the project. Every mainnet lease has a receipt on the About page.

Before you spend

Decide the most intervals you will pay for before you open. State that number and its cost to your operator when the job is theirs, and never pay a tick past it. Nothing here is meant to make you spend without your operator knowing; if your budget or instructions do not cover it, stop and ask them.

Way 1: x402 over HTTP

For an agent with an x402 client and a wallet holding USDC on Base (eip155:8453). The facilitator submits the transfer, so the wallet needs no ETH. Every call below is to https://charter.mainnet.toonprotocol.dev. Only the tick is paid; the storefront pays the host for the open and the reads from its own channel.

The short way: rent in one call (0.007 USDC)

POST /v1/rent
Content-Type: application/json

{"python": {"script": "import numpy as np\nprint(np.arange(5).sum())\n"}}

Steps 2 and 3 below in one paid request. The body is the open body of step 2, with offerId optional: left out, the storefront picks the cheapest listed offer that runs your job. Without a payment header the answer is a 402 like a tick's, with exact first: one 0.007 USDC authorization and no deposit. batch-settlement is offered second for a client that already holds a channel. Paid, it answers {"leaseId", "state": "running", "paidIntervals", "paidThrough", "next": {"path", "index": 1}, "offer"}; go on at step 4 with index 1. A 400 or 404 before the 402 means the body or the offer is wrong, and nothing was asked of you. If the host fails after the lease opened, the error carries leaseId and nothing was charged: pay index 0 on that lease at step 3 within 90 seconds, or let it lapse. 409 busy means another rent from your wallet is still in flight. Other refusals are a tick's. The same routes, machine-readable: /openapi.json.

1. Read the offers (free)

GET /v1/offers

A JSON array. Each offer has offerId, cpu, memoryMiB, intervalSeconds, tickPrice (micro-USDC, a string), images, hiddenHost, hiddenEgress, expiresAt (epoch ms) and leases (how many paid leases this host has served). A host that runs homes also has home: {"diskGiB": 2, "retentionDays": 7, "slots": 1} on the live host. Pick an offer whose images lists your job. An empty array means no host is up: do not retry in a loop.

2. Open a lease (free)

POST /v1/leases
Content-Type: application/json

{"offerId": "<offerId>", "python": {"script": "import numpy as np\nprint(np.arange(5).sum())\n"}}

Or, for the fetch job, {"offerId": "…", "urls": ["https://example.com"]} with one to five URLs. For a home, {"offerId": "…", "home": {"sshKeys": ["ssh-ed25519 AAAA… comment"]}} (see Home). The answer is {"leaseId", "state"}. awaiting_first_tick means the container exists and waits for tick 0, which the host gives you 90 seconds to pay. closed with closedReason busy means the host is running another lease, or its home slot is taken; wait a few minutes and try again, once. closed with home_in_use means a live lease already holds the home those keys name. boot_failed with an error means your job was refused (image_not_allowed, arg_not_allowed, bad_input). A 503 capacity means the storefront is out of headroom for today.

3. Pay a tick (0.007 USDC)

POST /v1/leases/<leaseId>/ticks
Content-Type: application/json

{"index": 0}

Without a payment header the answer is 402 with x402 payment requirements: batch-settlement first, exact second, both USDC on Base to the storefront's payee (check it against GET /v1/door). An x402 client such as @x402/fetch signs and retries for you. With exact, every tick is one 0.007 USDC authorization and there is no deposit. With batch-settlement, the first tick deposits at least 0.10 USDC into x402's channel contract, every later tick is a voucher the client signs silently, and the unspent deposit is refunded by the storefront's timer about two hours after the lease goes quiet (twice the interval, so a channel that is simply between ticks is left alone).

A paid tick answers {"paidIntervals", "paidThrough", "duplicate"}. paidThrough is the host's clock, epoch ms, when the paid time runs out. Tick 0 starts the container. Index counts from 0 and must arrive in order: a 409 out_of_order tells you the expected index. Other refusals: 409 lease_done or not_running (the lease is over, stop), 409 busy (your previous tick is still in flight), 503 retry_later (nothing was charged, send the same index again), 403 payer_blocked (a payment from this wallet failed to settle once; it will not be served again), 429 rate_limited.

4. Keep it alive, then stop

Pay the next tick halfway through the paid interval (30 minutes before paidThrough on a one hour interval) and count the paid time from the moment you sent it, not from when the answer arrived: the host gives only 10 seconds of grace, and one packet to a hidden host can take 15. A tick paid early extends the paid time from its current end, so nothing is lost. To pay ahead, send the next indexes now, one request each and in order: each accepted tick adds an hour to paidThrough, and a day ahead is 24 requests. With batch-settlement, a channel that pays nothing for two hours is refunded and closed, so paying more than two hours ahead means your next tick opens a channel and deposits again; with exact there is no channel to lose. To stop, stop paying: the lease closes at the end of the paid time with closedReason missed_tick, and nothing more is owed. There is no refund for time already paid.

5. Read the state and the output (free)

GET /v1/leases/<leaseId>
GET /v1/leases/<leaseId>/output/0

The first answers {"lease": {"state", "paidIntervals", "paidThrough", "outputParts", "closedReason", "landing"}, "stopped", "offer"}. On a long lease poll it about once a minute: a lease has 40 free host reads plus 68 for each paid hour (8 a tick and one a paid minute), and past that the storefront serves its last answer. The storefront caches each read for 5 seconds and rate limits you past that. When state is done and outputParts is set, fetch parts 0 to outputParts - 1. A python part is {"kind": "python", "exitCode", "signal", "timedOut", "seconds", "stdout", "stderr", "stdoutTruncated", "stderrTruncated"}. A fetch part is {"pages": [{"url", "text", "jpegBase64"}]}. A home lease never reaches done and has no output; its lease also carries homeId, restarts and access (below).

From an MCP client: one install, no code

If you speak MCP, the charter-mcp server does all of Way 1 for you. It keeps its own wallet in a key file (~/.charter/mcp.key, made on first run), and each paid tool call is one exact payment:

claude mcp add charter -- npx -y charter-mcp

Free tools: charter_offers, charter_wallet, charter_lease. Paid tools, one interval each: charter_run_python, charter_fetch_pages, charter_rent_home, charter_extend. Call charter_wallet first and give your operator the address it prints: USDC on Base, no ETH. The server signs only exact in USDC on Base to the payee GET /v1/door names, at most CHARTER_MAX_USDC_PER_HOUR (default 0.01) an interval and CHARTER_MAX_USDC_PER_DAY (default 0.25) a day.

Way 2: a toon node

For an agent that runs a toon_cli node with a funded channel. You then pay the host directly, open and reads included, and the same channel pays every other seller on the TOON mesh. The whole procedure, packet by packet, is the renting-charter-compute skill in the charter Claude Code plugin:

/plugin marketplace add drew-dot-com/charter
/plugin install charter@charter

Its references/lease-loop.sh runs one whole lease as one command. The skill needs toon 0.3 and a route from your node to the host's ILP address; adding a peering deposits money and is your operator's decision.

Home: a box you can live in

A home is a lease on the charter-home image: a box with a disk that outlives the lease, reached over SSH. It runs while it is paid, at the same 0.007 USDC an hour, and never finishes by itself. The live host has two home slots, one of them Edison's (home.slots in the offer); while both are taken an open answers busy.

Open it

POST /v1/leases
Content-Type: application/json

{"offerId": "<offerId>", "home": {"sshKeys": ["ssh-ed25519 AAAA… comment"]}}

1 to 8 public keys, each an ssh-ed25519, ecdsa-sha2-nistp256, -nistp384, -nistp521 or ssh-rsa line under 1024 bytes. Public keys only: never send a private key or any other secret to Charter. Then pay ticks exactly as above. From a toon node the open's job is {"image": "charter-home", "args": {"SSH_KEYS": "<the key lines joined by a newline>"}}.

Find it

The lease status of a running home carries:

"homeId": "<16 hex>",
"restarts": 0,
"access": {"ssh": {"host": "<56 characters>.anyone", "port": 22, "user": "tenant"}}

access is null until the host has published the home's onion address, within about a minute of the first tick. Poll about once a minute until it is set. restarts counts the times the host re-created the box.

Get in

ssh -o ProxyCommand="nc -x 127.0.0.1:<your Anyone SOCKS port> %h %p" tenant@<host>

The address is an onion on the Anyone network, so you need an Anyone client and its SOCKS port. A toon node has one. No Anyone client, no way in: there is no clearnet address. The keys you opened with are the only logins. The box's host key is made once on your disk, so its fingerprint stays the same across restarts and leases; pin it the first time.

What is inside

Network: all of it through Anyone

The box has no direct route anywhere. Everything leaves through the host's Anyone client: HTTP_PROXY and HTTPS_PROXY are http://172.19.0.1:9080, ALL_PROXY is socks5h://172.19.0.1:9050, and names resolve over the Anyone network too. The variables are set in every SSH session and for boot.sh, and NODE_USE_ENV_PROXY=1 makes Node's fetch use them. curl, pip, uv, git and npm work as they are. A program that opens a raw socket to the internet fails. The box reaches nothing on the host or its LAN. Expect it to be slow, hidden, and sometimes refused by a service that dislikes shared exits.

The disk, and who it belongs to

What the host promises about uptime

Paying for the box from inside the box

The first open and tick come from outside, since the box does not exist yet. After that the box can pay its own rent, in one of two ways.

With a Base wallet and nothing else, for a lease opened through this storefront (POST /v1/rent or /v1/leases): every home has charter-x402.

charter-x402 address                      # makes ~/.charter/x402.key (mode 400) and prints the address to fund
charter-x402 renew --max-intervals 720    # pays each hour 30 minutes before it runs out
charter-x402 status                       # free: state, paidThrough, minutes left, the SSH address

Fund the address with USDC on Base. It needs no ETH: the facilitator submits each transfer. Each hour is one 0.007 USDC exact authorization, with no deposit, no channel and no TOON node. The tool signs only exact in USDC on Base, to the payee GET /v1/door names, and never more than CHARTER_X402_MAX_TICK micro-USDC for one tick (default 10000, which is 0.01 USDC). A refused tick is logged with the minutes of paid time left and tried again after a minute, doubling to ten. After --max-intervals ticks it exits and nothing pays. Put it in boot.sh: charter-x402 renew --max-intervals 720 >> ~/.charter/renew.log 2>&1 &. Run charter-x402 address once first: with no key file renew exits. 1 USDC is about 6 days of rent, 5 USDC about 30. The operator can read your disk, so keep in that wallet only what the rent needs. The same file runs outside a home with Node 22 and npm install @x402/fetch @x402/evm viem (source: jobs/home/x402-rent.mjs), where charter-x402 open --keys keys.pub opens a home and pays its first hour.

Over TOON, for a lease opened from a toon node: the charter command line from the Charter repository, installed in the box, with CHARTER_PAYER=toon-client and a wallet of the box's own (CHARTER_TOON_KEY_FILE, CHARTER_TOON_CHANNEL_STORE, CHARTER_TOON_CHAIN). The connector and the offer are already in the box as CHARTER_CONNECTOR_URL and CHARTER_OFFER_JSON, so no relay read is needed:

charter renew --offer <pubkey>:<offerId> --lease "$CHARTER_LEASE_ID" --max-intervals <n>

renew reads the lease and pays from the host's own count of paid ticks. renew pays each tick when it is due, so restarting boot.sh costs nothing extra. After <n> ticks it exits and nothing pays, so a box that should stay up runs renew again or picks <n> for the time wanted. Put it in boot.sh. The box's wallet needs USDC in a channel to the connector in CHARTER_CONNECTOR_URL, plus a little Base ETH for the one on-chain channel open. 2 USDC runs the box about 10 days: 12 days of rent, less the status reads renew makes (about 8 an hour at 0.0001).

Hermes in a box

Open the same home with "image": "charter-hermes" and the box has Hermes Agent 0.22.7 and the charter command line already installed, read-only, and a default boot that runs them. Everything above (the keys, the onion address, the 2 GiB disk, the price, the Anyone network) is the same. The offer's images lists it when the host allows it.

{"offerId": "<offerId>", "home": {"sshKeys": ["ssh-ed25519 AAAA… comment"], "image": "charter-hermes"}}

From a toon node the open's job is {"image": "charter-hermes", "args": {"SSH_KEYS": "…"}}. With the CLI: charter rent --offer <pubkey>:<offerId> --home keys.pub --image charter-hermes --max-intervals 1 --relay wss://relay.mainnet.toonprotocol.dev (inside a box the relay flag is not needed). A tenant whose keys already name a charter-home opens the same disk under charter-hermes; its files are kept. If that disk already has its own ~/.charter/boot.sh, the box runs that one and never the default boot below; copy /app/boot-default.sh over it (or edit your own) to get the image's boot.

What the box does at boot

The first start copies the image's /app/boot-default.sh to ~/.charter/boot.sh if that file is absent. It is yours after that: edit or replace it, and the image never overwrites it. It logs boot: lines to ~/.charter/boot.log and takes a lock at /tmp/charter-boot.lock, so a second run exits. In order:

The image keeps every ~/.charter/*.log under 10 MiB whatever your boot does: past that, the log is copied to <log>.1 and emptied in place. A boot killed without its cleanup leaves a stale lock; the next run checks the pid in it, stops what the dead boot left running and takes over.

Fund the address: about 5 USDC runs the box 30 days; 2 USDC in the box's channel runs it about 10 days. It also needs a little Base ETH for the channel's one on-chain open.

Plugins, and what the image cannot run

OpenHuman in a home

OpenHuman is a Rust agent harness. Its official headless build runs in a charter-home as downloaded. Checked 2026-11-16 with release v0.64.15 (aarch64) in a box fenced like a live home; every number here was measured there, and what was not checked is listed at the end.

Open the home from wherever your wallet is, with any x402 client: POST /v1/rent with {"home": {"sshKeys": ["ssh-ed25519 AAAA…"]}}, 0.007 USDC by exact on Base. Read GET /v1/leases/<leaseId> about once a minute until lease.access.ssh is set, then get in. With no x402 client at hand, charter-x402 open --keys keys.pub does the same from any machine with Node 22.

Install, in the box. 141 MB comes down in about a minute through the hidden network and unpacks to 293 MB of the 2 GiB disk:

V=0.64.15
A=openhuman-core-$V-aarch64-unknown-linux-gnu.tar.gz
U=https://github.com/tinyhumansai/openhuman/releases/download/v$V
mkdir -p ~/openhuman && cd ~/openhuman
curl -fsSLO $U/$A && curl -fsSLO $U/$A.sha256
echo "$(cat $A.sha256)  $A" | sha256sum -c - && tar -xzf $A && rm $A

Start:

OPENHUMAN_SKILL_REGISTRY_REFRESH_ON_BOOT=0 ./openhuman-core run --host 127.0.0.1 --port 7788

GET http://127.0.0.1:7788/health answers 200 within a second or two. RPC is POST http://127.0.0.1:7788/rpc (JSON-RPC 2.0) with Authorization: Bearer $(cat ~/.openhuman/core.token); core.ping answers {"ok":true}. ./openhuman-core --help lists the namespaces; there is no --version, and the start log names the version.

Keep that variable set, or the box runs out of memory. Without it the core downloads and indexes a catalog of 104,000 skills at every start: about 800 MB at the peak and 590 MB after, plus 68 MB of disk. With it the idle core holds 97 MB of the 1 GiB.

Boot script, so it comes back after a restart. Save as ~/.charter/boot.sh and chmod 700 it:

#!/bin/sh
cd "$HOME/openhuman" || exit 1
export OPENHUMAN_SKILL_REGISTRY_REFRESH_ON_BOOT=0
if [ -f "$HOME/.openhuman/env" ]; then set -a; . "$HOME/.openhuman/env"; set +a; fi
charter-x402 renew --max-intervals 720 >> "$HOME/.charter/renew.log" 2>&1 &
while :; do
  ./openhuman-core run --host 127.0.0.1 --port 7788 >> "$HOME/.charter/openhuman.log" 2>&1
  echo "boot: openhuman-core exited ($?), again in 30 s"
  sleep 30
done

Checked: after a restart of the box the core answered /health again within 12 seconds. The first time, start it detached from your session: nohup ~/.charter/boot.sh >> ~/.charter/boot.log 2>&1 &. The image keeps every ~/.charter/*.log under 10 MiB.

Limits, plainly:

What to tell your operator

If you have no funded wallet, relay this: Charter needs a wallet holding USDC on Base and nothing else. 0.05 USDC runs seven hours; 1 USDC runs about six days; about 5 USDC runs a month. There is no account to create. Through a toon node instead, the operator funds a channel to a peer that routes to Charter's host, and that one channel pays Charter and every other TOON seller.

For a home, relay this: a home costs 0.007 USDC an hour, about 5 USDC for 30 days, in a wallet or a channel; a channel also needs a little Base ETH for its one on-chain open. If the box pays its own rent with charter-x402, its wallet needs USDC on Base and nothing else (1 USDC is about 6 days). If it pays over TOON instead, it needs 2 USDC in its own channel (about 10 days) and a little Base ETH for that channel's open. Its disk is readable by the host operator, so the operator should decide what secrets go in it.

Trust, plainly