# Charter > Charter rents a sandboxed machine by the hour, 0.007 USDC an hour (about 5 USDC for 30 days), paid in USDC on Base with no account. The buyer is an agent; its operator funds the wallet. Charter is a compute marketplace on the TOON payment network. A host publishes an offer for a machine. A renter opens a lease, pays one interval at a time, and a container runs the renter's job for as long as the payments keep arriving. There is no signup, no API key and no account on either side: the renter is whoever pays. Three jobs exist today. `charter-job-python` runs your Python 3 script (up to 8 KiB, NumPy included, no network) and returns its stdout, stderr and exit code. `charter-job-fetch` loads up to five pages in a headless browser through a hidden exit and returns the text and a screenshot of each. `charter-home` is a box of your own: a 2 GiB disk kept between leases, SSH in at an onion address on the Anyone network, network out only through the Anyone network (see Home below). Prices on the one live host, in USDC: one hour 0.007, a deposit of at least 0.10 that is refunded unspent about two hours after the lease goes quiet. Opening a lease and reading its state cost you nothing through the storefront. A python job that finishes inside its first hour costs 0.007; a day about 0.17; 30 days about 5. Paying ahead is sending the next ticks now, each adding an hour; a batch-settlement channel idle for two hours is refunded and closed, so paying more than two hours ahead means depositing again on the next tick. The cheapest comparison is a 5 EUR per month VPS: Charter costs about the same for a month and needs no account, only a wallet. 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. Status: live on Base mainnet since 2026-10-17, one host, first-party. Every renter so far has been an operator of the project. Receipts for every mainnet lease are on the About page. ## Home - Open: `POST /v1/leases` with `{ "offerId": "...", "home": { "sshKeys": ["ssh-ed25519 AAAA... comment"] } }`: 1 to 8 public keys (`ssh-ed25519`, `ecdsa-sha2-nistp256|384|521`, `ssh-rsa`), each line under 1024 bytes. Then pay ticks like any lease. Over TOON the job is `{ "image": "charter-home", "args": { "SSH_KEYS": "" } }`. Public keys only: no secret ever goes through Charter. - Find it: a running home's status has `homeId`, `restarts` (times the host re-created the box) and `access: { "ssh": { "host": "<56 chars>.anyone", "port": 22, "user": "tenant" } }`. `access` is `null` until the onion address is published, within about a minute of the first tick; poll about once a minute. A home never reaches `done` and has no output. - Get in: `ssh -o ProxyCommand="nc -x 127.0.0.1: %h %p" tenant@`. A toon node has such a port. No Anyone client, no way in. The keys you opened with are the only logins; the host key is made once on your disk, so the fingerprint is stable across restarts and leases. - Inside: Debian trixie-slim (glibc 2.41, so a binary built on a current distribution starts as it is; bookworm until 2026-11-16), aarch64, user `tenant` (uid 10001, no root, no setuid), Python 3.13 with venv and pip, `uv`, Node 22, git, curl, jq, rsync, tmux, and `charter-x402` (the rent payer below); 1 CPU, 1 GiB, 512 processes. `/home/tenant` is the disk; the root filesystem is read-only; `/tmp` is 256 MiB in memory. - `~/.charter/boot.sh`, if executable, runs in the background at every start (output in `~/.charter/boot.log`). `/charter/paid-through` holds the epoch ms the paid time runs out, rewritten on every tick. `CHARTER_LEASE_ID`, `CHARTER_HOME_ID`, `CHARTER_OFFER_JSON` and `CHARTER_CONNECTOR_URL` are in the environment. - Network: everything goes 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`, DNS resolves over Anyone, `NODE_USE_ENV_PROXY=1` is set for Node; all of it in every SSH session and in `boot.sh`. A program that opens a raw socket to the internet fails. The box reaches nothing on the host or its LAN. Slow, hidden, sometimes refused by a service that dislikes shared exits. - Disk: 2 GiB ext4. The key set is the home's identity (`homeId` is a hash of the sorted keys): the same keys open the same home, the same disk and the same onion address; there is no key rotation, and a lost key is a lost home once the retention runs out. Kept 7 days free after a lease that paid a tick closes; removed at close if the lease never paid a tick. - Anyone with your public keys can open your home and hold it, though not enter it (your open is then refused: `closedReason: "home_in_use"`). The operator can read your disk: keep secrets elsewhere or encrypt them. Secrets go in over SSH (`scp`, as it is since 2026-11-16; an older box needs `scp -O`), never through Charter. - Two home slots on the live host, one of them Edison's (`home.slots` in the offer, beside `diskGiB: 2` and `retentionDays: 7`). While both are taken an open answers `busy`. - Uptime, as a list, not a promise: - No uptime figure. Expect restarts. Your disk survives them; your processes do not, so put what must run in `~/.charter/boot.sh`. - A tick pays an hour from the end of the paid time. Pay the next tick half an hour early (the tenant loop already does) so a short outage does not end the lease. Paying several ticks ahead buys that much patience and nothing else; a lease that closes refunds nothing. - A closed home keeps its disk and onion address for 7 days. Open again with the same keys. - A restart of the host program leaves a running home alone. A reboot of its VM puts a paid home back on its disk (`restarts` goes up), as long as the paid time has not run out. - Paying from inside with a Base wallet and nothing else (a lease opened through this storefront): `charter-x402`, in every home. `charter-x402 address` makes a key at `~/.charter/x402.key` (mode 400, on your disk) and prints its address; fund that address with USDC on Base (no ETH: the facilitator submits each transfer). `charter-x402 renew --max-intervals ` then pays each hour 30 minutes before it runs out, one 0.007 USDC `exact` authorization a tick: no deposit, no channel, no TOON node. It signs only `exact` in USDC on Base to the payee `GET /v1/door` names, at most `CHARTER_X402_MAX_TICK` micro-USDC a tick (default 10000). A refused tick is logged with the minutes of paid time left and tried again (after 1 minute, doubling to 10). After `` ticks it exits and nothing pays. Put it in `boot.sh`: `charter-x402 renew --max-intervals 720 >> ~/.charter/renew.log 2>&1 &`. `charter-x402 status` (free) prints the state, `paidThrough`, the minutes left and the SSH address. The same file runs outside a home with Node 22 and `npm install @x402/fetch @x402/evm viem`: `charter-x402 open --keys keys.pub` opens a home and pays its first hour (source: `jobs/home/x402-rent.mjs`). 1 USDC is about 6 days; 5 USDC about 30. The operator can read your disk, so keep in that wallet only what the rent needs. - Paying from inside over TOON instead (a lease opened from a toon node): the `charter` CLI installed in the box, with `CHARTER_PAYER=toon-client` and the box's own `CHARTER_TOON_KEY_FILE`, `CHARTER_TOON_CHANNEL_STORE` and `CHARTER_TOON_CHAIN` (the connector and the offer come from `CHARTER_CONNECTOR_URL` and `CHARTER_OFFER_JSON`, set in the box): `charter renew --offer : --lease "$CHARTER_LEASE_ID" --max-intervals ` reads the lease and pays from the host's count. `renew` pays each tick when it is due, so restarting `boot.sh` costs nothing extra. After `` ticks it exits and nothing pays, so a box that should stay up runs `renew` again or picks `` for the time wanted. Put it in `boot.sh`. The wallet needs USDC in a channel to that connector and a little Base ETH for the one on-chain channel open; 2 USDC runs the box about 10 days. - What to tell your operator: a home is about 5 USDC for 30 days; in a channel, add 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 and a little Base ETH. ## Hermes in a box - Open the same home with `"image": "charter-hermes"`: `{ "offerId": "...", "home": { "sshKeys": ["ssh-ed25519 AAAA... comment"], "image": "charter-hermes" } }`. Over TOON the job is `{ "image": "charter-hermes", "args": { "SSH_KEYS": "..." } }`. CLI: `charter rent --offer : --home keys.pub --image charter-hermes --max-intervals 1 --relay wss://relay.mainnet.toonprotocol.dev`. Keys, onion address, disk, price and network are as in Home. The offer's `images` lists it when the host allows it. A tenant whose keys already name a `charter-home` opens the same disk under `charter-hermes`. If that disk already has its own `~/.charter/boot.sh`, the box runs that one and never the default boot; copy `/app/boot-default.sh` over it (or edit your own) to get the image's boot. - Preinstalled, read-only: Hermes Agent 0.22.7 (`hermes --version`, `hermes doctor`) on its own Python 3.14 with the extras `telegram`, `discord`, `google`, `mcp` and `web`; the `charter` CLI at `/usr/local/bin/charter`; ripgrep; Node 22; Debian's Python 3.13. The version is the host's: a new build reaches a running box only at its next re-create. - You bring, over `scp`: `~/.hermes/.env` (model provider key, `TELEGRAM_BOT_TOKEN`, allowed user ids), optionally `~/.hermes/config.yaml` and `~/.hermes/SOUL.md`. - Boot: the first start copies `/app/boot-default.sh` to `~/.charter/boot.sh` if absent; it is yours to edit and the image never overwrites it. It logs `boot:` lines to `~/.charter/boot.log` and takes the lock `/tmp/charter-boot.lock`, so a second run exits. In order: read `~/.charter/payer.env` if present (overrides `CHARTER_TOON_KEY_FILE`, `CHARTER_TOON_CHANNEL_STORE`, `CHARTER_TOON_CHAIN`, `CHARTER_TOON_RPC_URL_FILE`, `CHARTER_PAYER_URL`); make `~/.charter/payer.key` if absent (the box's own wallet, on its own disk; the boot runs before you can SSH in, so on a new disk this key is the normal path, and you fund `payer.address`; with the rent line's `--max-intervals 1` it must hold funds within the hour, or pay more ticks from outside first); start `charter payer` (log `payer.log`, restarted 30 seconds after it exits) and write its address to `~/.charter/payer.address`; start `charter renew --max-intervals 720` (30 days) in a loop that restarts it after 5 minutes (log `renew.log`); once `~/.hermes/.env` exists, run `hermes gateway run`, restarted 30 seconds after it exits. - Logs: the image keeps every `~/.charter/*.log` under 10 MiB whatever your boot does (past it, the log is copied to `.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. - To change the key or `payer.env` after the first boot: replace the file, run `~/.charter/boot.sh stop` (it stops the boot, so renew and the gateway stop with it, and the payer, which a boot leaves running on purpose and which holds the old key; it kills a pid only while it still names a boot or a payer, so a stale pidfile never kills anything else), then start the boot again detached, as the box does: `nohup ~/.charter/boot.sh >> ~/.charter/boot.log 2>&1 &`. Run in the foreground over SSH, it stops when the session closes. A key placed before the first boot works only on a disk carried over from a `charter-home` lease. - Fund the address in `payer.address` with USDC and a little Base ETH for the channel's one on-chain open. About 5 USDC runs 30 days; 2 USDC runs about 10 days. Until it is funded each `renew` try fails and the box lives on ticks paid from outside. - Plugins live on your disk: `hermes plugins install --ref https://github.com/drew-dot-com/hermes-toon#src/` from inside the box, `` being the commit you reviewed. The boot exports `TOON_PAYER_URL`, `CHARTER_PAYER_URL`, `CHARTER_BIN` and `CHARTER_OFFER_ID`, so an installed plugin pays through the box's payer. A plugin needing Python dependencies outside the venv cannot be installed. - Limits: 1 GiB of memory (measured: gateway 348 MB, payer 153 MB, renew 140 MB), so one gateway and nothing heavy. `HERMES_DISABLE_LAZY_INSTALLS=1` is set by the image and `config.yaml` cannot undo it, so Hermes's tool bundles are never downloaded: no WhatsApp bridge, browser tool, voice or TUI. Traffic leaves through shared Anyone exits that Telegram and the model provider may rate-limit. - Size: 1.94 GB on the host, 842 MB of it the shared `charter-home` base. One of the live host's two home slots is Edison's while Edison lives there. ## OpenHuman on Charter [OpenHuman](https://github.com/tinyhumansai/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 below was measured there. What was not checked is listed last. - 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. The answer carries `leaseId`. Read `GET /v1/leases/{leaseId}` (free) about once a minute until `lease.access.ssh` is set, then SSH in as in Home. No x402 client at hand: `charter-x402 open --keys keys.pub` (see Home, paying from inside) does the same from any machine with Node 22. - Install, in the box (141 MB down in about a minute through the hidden network, 293 MB unpacked 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`; the start log names the version). - Set `OPENHUMAN_SKILL_REGISTRY_REFRESH_ON_BOOT=0` 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`, `chmod 700`: ``` #!/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 `~/.charter/*.log` under 10 MiB. - Your credential goes in over `scp`, never through Charter: `scp env tenant@:.openhuman/env` (mode 600) with a line such as `OPENHUMAN_BACKEND_API_KEY=...`, which OpenHuman's own cloud-deploy doc names for a headless core. The boot script above exports that file. - Rent, from inside: `charter-x402 address` prints the box's wallet (key at `~/.charter/x402.key`); run it once before the boot script, since with no key file `renew` exits. Fund the address with USDC on Base; the `renew` line in the boot script pays each hour 30 minutes early and logs to `~/.charter/renew.log`. It uses about 170 MB while it runs. Or pay from outside: `POST /v1/leases/{leaseId}/ticks` with `{ "index": n }`, n counting up from 1, by x402, before `paidThrough`. - Paid-through: `cat /charter/paid-through` (epoch ms, rewritten by the host on every tick, costs nothing), or `charter-x402 status` (state, `paidThrough`, minutes left, SSH address). Under 20 minutes left means a tick is late: check the wallet and `renew.log`. A home that lapses closes `missed_tick`; its disk and address are kept 7 days and an open with the same keys brings it back. - Skill: `mkdir -p ~/.openhuman/workflows/charter-home && curl -fsS https://charter.mainnet.toonprotocol.dev/openhuman/SKILL.md -o ~/.openhuman/workflows/charter-home/SKILL.md` puts these rules where OpenHuman v0.64.15 lists skills (`./openhuman-core skills list`). In that release a `SKILL.md` under `~/.openhuman/skills` is not listed. - Limits, plainly: - Release v0.64.15 has no wallet and no x402 RPC: its `/schema` lists neither. `openhuman.x402_fetch` exists only on OpenHuman's main branch, in no release as of 2026-11-16. Until a release carries it, the agent cannot pay by itself; `charter-x402` pays the rent from a key file on the disk. - Not checked here: an agent turn (it needs your TinyHumans credential), and OpenHuman paying for anything. - The network is HTTP and HTTPS through a proxy (github.com and api.tinyhumans.ai answered from the box). A raw socket to the internet fails. Read from OpenHuman's source, not tested: its backend Socket.IO connection, used after a session-token login, does not go through a proxy, so sign in with an API key. - aarch64 only, 1 CPU, 1 GiB, 2 GiB disk: one core and the renew fit; a second agent or a local model does not. - One host, one operator, no uptime figure. The way in is SSH at an onion address, so the person or agent logging in needs an Anyone client; slow, and some services refuse shared exits. - The operator can read the disk, the wallet key included. Keep in it only what the rent needs. ## Rent - [How an agent rents](https://charter.mainnet.toonprotocol.dev/agents): the two ways in (x402 over HTTP, or a toon node), every call, every price, the home and how to SSH in, what to tell your operator. - Rent in one x402 call: `POST https://charter.mainnet.toonprotocol.dev/v1/rent` with `{ "python": { "script": "print(2 + 2)" } }` (or `urls`, or `home`; `offerId` optional) answers 402 for one interval; paid, the lease is open with its first hour paid. Keep it with `POST /v1/leases/{leaseId}/ticks` and `{ "index": 1 }`, then 2, and so on. - [OpenAPI](https://charter.mainnet.toonprotocol.dev/openapi.json): the paid rent route and the free routes, for x402 clients and indexes. - [Live offers, JSON](https://charter.mainnet.toonprotocol.dev/v1/offers): the machines on sale right now. Free to read. - Rent and renew with only a Base wallet: `charter-x402` (`open`, `renew`, `status`, `address`), in every home and in the source at `jobs/home/x402-rent.mjs`. `exact` only: one 0.007 USDC authorization an hour, no deposit, no channel, no ETH. - [OpenHuman skill](https://charter.mainnet.toonprotocol.dev/openhuman/SKILL.md): the rules for an OpenHuman agent living in a home, as one `SKILL.md`. - [MCP server](https://www.npmjs.com/package/charter-mcp): `npx -y charter-mcp` over stdio, for any MCP client (`claude mcp add charter -- npx -y charter-mcp`). Seven tools: `charter_offers`, `charter_wallet`, `charter_lease` (free) and `charter_run_python`, `charter_fetch_pages`, `charter_rent_home`, `charter_extend` (one 0.007 USDC `exact` payment each). It makes its own wallet at `~/.charter/mcp.key`; the operator funds it with USDC on Base. It 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. Source: `mcp/` in the repository. - [Claude Code plugin](https://github.com/drew-dot-com/charter/tree/main/plugins/charter): `/plugin marketplace add drew-dot-com/charter` then `/plugin install charter@charter`. For an agent with a toon node. - [Storefront](https://charter.mainnet.toonprotocol.dev/): for a human with a browser wallet. ## Reference - [Source, MIT](https://github.com/drew-dot-com/charter): the door is `src/door/server.ts`, the host is `src/host/server.ts`, the packet shapes are `src/tenant/host-api.ts`. - [About and receipts](https://charter.ar.io/): what it is, the price table, every mainnet transaction. - [TOON](https://toon.ar.io/): the payment network under it. ILP routes each packet, x402 settles it. ## Optional - [Running a host](https://github.com/drew-dot-com/charter#host): sell time on a machine of your own next to a toon node. - [toon_cli](https://github.com/toon-protocol/toon_cli): the node an agent runs to pay Charter and other TOON sellers from one funded channel.