Docs

Cliff docs

Everything about the agent, the wallet, live links, MCP and the HTTP API. Agents: the same in one file is at /llms.txt.

Quickstart

You need Node.js 18 or newer and a key from one model provider. Then:

curl -fsSL https://readcliff.xyz/install.sh | sh
cliff setup
cd your-project && cliff

cliff setup asks for a provider, a model and the key, and keeps the key in ~/.cliff/keys.json, readable only by you. If ANTHROPIC_API_KEY, OPENAI_API_KEY or GEMINI_API_KEY is already set, you can skip setup. Then type what you want done, in plain words:

› add a dark mode to index.html and show me the diff
› why does npm test fail? fix it
› publish the site folder and give me the link
› what is my wallet balance?

Cliff reads files without asking. It asks before it writes a file, runs a command, publishes, or calls an MCP tool, and it always asks, with your passphrase, before it sends anything from the wallet. After each answer it prints tokens in, out and the cost at the provider's list price.

Install and update

The installer checks Node, downloads cliff.mjs and version.json, checks the file's SHA-256 against it, puts the file in ~/.cliff/bin and a small cliff launcher in ~/.local/bin. It never uses sudo. Read it first at /install.sh.

VariableDefaultWhat it changes
CLIFF_HOME~/.cliffWhere Cliff keeps everything
CLIFF_BIN_DIR~/.local/binWhere the installer puts the launcher
CLIFF_BASEhttps://readcliff.xyzWhere the installer downloads from
CLIFF_RPCRobinhood Chain public RPCThe RPC the wallet uses

No installer? It's one file:

curl -fsSLO https://readcliff.xyz/cliff.mjs
curl -fsSL https://readcliff.xyz/version.json   # compare sha256 with: shasum -a 256 cliff.mjs
node cliff.mjs

cliff update downloads the newest file, checks its SHA-256 against version.json and replaces the old one only if it matches. To remove Cliff: rm -rf ~/.cliff ~/.local/bin/cliff. That also deletes the wallet file, so move any funds first or keep wallet.json and your passphrase.

Commands

CommandWhat it does
cliffChat in this folder
cliff -p "question"Ask once and print the answer. --json adds the session, model, tokens and cost
cliff --continuePick up the last session in this folder
cliff setupChoose a provider, a model and a key
cliff models [--refresh]The models Cliff knows and their list prices; --refresh fetches the latest list
cliff publish <folder>Put a static site at a live link
cliff sites, cliff unpublish <id>Your live links, and removing one
cliff wallet …See the wallet
cliff mcp add|list|removeConnect MCP servers; see MCP
cliff key newGet a free Credits API key by signing a message with Cliff's own wallet (no gas)
cliff key set ck_…Save a Credits API key you got on the website, for Cloud tasks and paid publishing
cliff cloud run "task"Run a task on a cloud machine; see Cliff Cloud
cliff cloud status|logs|download|stop <task>, cliff cloud listFollow, collect or stop a Cloud task, and list yours
cliff doctorCheck Node, keys, the network, the wallet and updates
cliff updateInstall the newest cliff.mjs, checked against its SHA-256

Options: --provider anthropic|openai|gemini|compatible, --model <id>, --base-url <url>, --yes, --json, --log (with -p --json: each step to stderr), --version. For cloud run: --repo <url>, --branch <name>, --upload <folder>, --publish, --dir <folder>, --minutes <n>, --detach. In chat: /help, /model, /cost, /clear, /memory, /exit. Ctrl+C stops an answer.

For scripts and other agents, -p --json prints one JSON object:

{
  "answer": "The README describes …",
  "session": "2026-11-15T18-02-11-7f3a",
  "model": "gemini-3.8-flash",
  "usage": { "input": 2196, "cachedInput": 0, "output": 75, "cost": 0.0019 }
}

Models and keys

ProviderKeyExample
AnthropicANTHROPIC_API_KEYcliff --provider anthropic --model claude-sonnet-5-5
OpenAIOPENAI_API_KEYcliff --provider openai --model gpt-6.1-sol
Google GeminiGEMINI_API_KEY or GOOGLE_API_KEYcliff --provider gemini --model gemini-3.8-flash
OpenAI-compatibleCLIFF_API_KEYcliff --provider compatible --base-url https://openrouter.ai/api/v1 --model <name>

A model on your own computer works through the compatible provider, with no key and no cost per token:

ollama serve &   # or LM Studio, llama.cpp, vLLM
cliff --provider compatible --base-url http://localhost:11434/v1 --model qwen3-coder

Cliff prices every answer from its price list: the providers' public list prices, checked on 2026-11-15, with a link to each source. It turns on prompt caching for Anthropic, so long sessions mostly pay the cached-input price. A compatible endpoint on your own computer shows $0; one elsewhere shows token counts but no price, since Cliff can't know what it charges.

Offline, with a local model

Cliff talks to models in the OpenAI chat format with tool calls, which local model servers offer too. With one running on your computer, Cliff needs no key and no internet, and every answer costs $0. The model must support tool calls for Cliff to read, edit and run things; small models that don't will only chat.

ServerStart itBase URL
Ollamaollama pull <model>; the app or ollama serve keeps it runninghttp://localhost:11434/v1
LM StudioLoad a model and start the local serverhttp://localhost:1234/v1
llama.cppllama-server -m model.gguf --jinja (--jinja turns on tool calls)http://localhost:8080/v1

Then, once:

$ cliff setup
Provider: 1 Anthropic, 2 OpenAI, 3 Google Gemini, 4 any OpenAI-compatible endpoint (…) [1]: 4
Base URL (Ollama http://localhost:11434/v1, LM Studio http://localhost:1234/v1, llama.cpp http://localhost:8080/v1): http://localhost:11434/v1
Model []: qwen3-coder
API key for compatible (a local server usually needs none: press Enter):
Saved: qwen3-coder on compatible at http://localhost:11434/v1, on this computer: no internet needed, $0 per token. Run cliff in any folder to start.

From then on cliff uses it: the first line reads (compatible, a local model, no key) and each answer ends with $0.0000 (local model). For one run without setup: cliff --provider compatible --base-url http://localhost:11434/v1 --model <model>. If your server wants a key, set CLIFF_API_KEY; Cliff never sends another provider's key to a local server.

Cliff itself calls nothing else while you chat. Tools that go online by nature still need the internet when used: web_fetch, the wallet, publish, MCP servers elsewhere, models --refresh, doctor and update. A Cloud task can't reach a model on your computer, so it needs a hosted one.

How we checked 0.2.0: cliff setup with the answers above, then chat and -p runs against a stand-in local server that speaks the same format, with every other connection blocked. File edits with approvals, commands and the $0 line all worked, and nothing else was contacted.

Tools and approvals

ToolWhat it doesAsks first
list_files, read_file, search_filesLook around the project. Skips .git, node_modules and build folders, and files over 1 MB in searchNo
write_file, edit_fileCreate or change a file; you see the change firstYes
run_shellRun a command in the project folder; 120 s by default, at most 600 sYes
web_fetchRead a web page or file over http(s), as textNo
rememberSave a note to ~/.cliff/memory.md, loaded every sessionNo
wallet_info, swap_quoteRead balances and quote Pons tokens. Nothing is signedNo
wallet_sendSend ETH or a token from your walletAlways: type send and your passphrase
publish_sitePut a folder at a live linkYes
MCP toolsAnything your MCP servers offerYes

At each question, y allows once, n refuses, and a allows that tool for the rest of the session. --yes allows file changes, commands, publishing and MCP calls without asking: use it only in a throwaway folder or a container. With no terminal attached (a script, CI, another agent), tools that change things are refused unless --yes is given. Wallet sends never run without a person at the keyboard, with or without --yes.

Text from web pages, files and MCP servers reaches the model marked as data, and Cliff tells the model never to follow instructions inside it. That lowers the risk of a page steering the agent; it doesn't remove it. The approvals are the real guard, so read what you approve.

The wallet

Cliff has a wallet on Robinhood Chain (chain id 4663). The private key is made on your computer, encrypted with your passphrase (scrypt, then AES-256-GCM) and kept in ~/.cliff/wallet.json, readable only by you. It is never sent anywhere, and the model never sees it.

cliff wallet new                 # or: cliff wallet import
cliff wallet address
cliff wallet balance [token]
cliff wallet send <to> <amount> [token]
cliff wallet quote <token> buy|sell <amount>
cliff wallet limit <eth>         # most ETH per send, 0.05 to start
cliff wallet export              # shows the private key: type export, then your passphrase

Every send shows the wallet, the recipient, the amount and the most it can cost in network fees, and says whether the agent asked for it. Then it waits for you to type send and your passphrase. Cliff signs on your computer and hands the signed transaction to the RPC. Answer anything else and nothing is sent. A send above your limit is refused before it reaches you.

Quotes work for any Pons token: on the bonding curve before graduation and in the Uniswap v4 pool after. They come from the chain itself (a simulated call), show the creator tax, and sign nothing. Cliff doesn't place swaps yet.

Live links

$ cliff publish ./site
  Publish 3 files (4 KB) from /Users/you/site to a public link? [y/N] y
https://readcliff.xyz/api/live/k3v9q2m7xa/
  expires 2026-11-22T18:38:47.388Z. Remove it with: cliff unpublish k3v9q2m7xa
  • An index.html at the top; up to 200 files and 2 MB; static web files only (HTML, CSS, JS, JSON, images, fonts, audio, video, wasm). Hidden files are skipped.
  • Free: 5 links a day per IP, each up for 7 days. With credits: 30 days, no daily cap, and extend adds 30 more (up to a year ahead).
  • Pages run in a browser sandbox: their own opaque origin, no cookies or storage shared with anything, no form posts, no top-window navigation. They are never indexed and carry a small "hosted by Cliff" note with a report link.
  • Cliff keeps each link's delete token in ~/.cliff/sites.json. cliff unpublish <id> removes it; cached copies can show for up to 60 seconds.
  • No phishing, malware, or anything illegal. Report a link at report.html; we take down what breaks the rules.

Cliff Cloud tasks

A task runs Cliff on a throwaway cloud machine and comes back with the files it changed. The steps: a fresh Vercel Sandbox (2 vCPUs, 4 GB) starts for your task alone; it installs the cliff.mjs this site serves with install.sh, which checks it against version.json; it clones your public repo or copies your uploaded files; it runs cliff -p "<task>" --yes --json with your model and key while the log streams; then it packs the changed files as a .tar.gz, publishes a folder to a live link if you asked, and the machine is stopped and deleted.

cliff key new                       # once: a free API key signed by Cliff's wallet (or cliff key set ck_… from the website)
cliff cloud run "add a dark mode toggle to index.html" --repo https://github.com/you/site --publish --dir site
cliff cloud logs <task>               # follow the log; Ctrl+C stops following, not the task
cliff cloud status <task>             # state, answer, changed files, live link, cost
cliff cloud download <task>           # cliff-<task>-changes.tar.gz; unpack it over your copy with tar xzf
cliff cloud stop <task>               # stop early: the changes so far are packed and unused minutes come back
Your model key is sent per task, passed to the sandbox only as an environment variable, and never stored or logged. The log, the answer and the files are scrubbed of it, and files that contain it are left out of the download and the live link. The agent on the machine uses the key as it would on your computer, so a key with a spending limit is wise.
  • No wallet in the cloud. Cliff runs there without its wallet tools and refuses every wallet command. --yes is on, so it edits and runs commands without asking, inside that machine only.
  • Input: a public https git repo (and branch), or up to 200 uploaded files and 2 MB, or nothing. Model: Anthropic, OpenAI, Gemini, or an https OpenAI-compatible endpoint. A model on your own computer can't be reached from there.
  • Time limit: 3 to 20 minutes (the operator's cap). Cliff is stopped 75 seconds before the limit so the changes can be packed. Output: up to 4 MB packed; publishing makes a free 7-day live link.
  • Price: one free task per wallet per UTC day (and two per connection), before and after $CLIFF launches. After that, 1 credit a minute of the time limit, charged up front; whole minutes it didn't use come back. You also pay your model provider for the tokens.
  • What a task costs the operator at Vercel's list prices (checked 2026-11-16: $0.128 per vCPU-hour of active CPU, $0.0212 per GB-hour of memory): about $0.0018 a minute when the machine mostly waits on the model, at most $0.0057 a minute with both vCPUs busy, so at most $0.11 for 20 minutes. Each finished task shows its own cost.
  • Paused: Cloud stops taking new tasks, and says so, when the operator turns it off, when today's machine budget or a wallet's share of it is used, when all task slots are busy, or for 10 minutes after the sandbox provider fails to start one. Nothing is charged for a task that doesn't start.
  • Kept 7 days: the task record, log and changed files, then deleted. ~/.cliff/cloud.json remembers your task ids and tokens.

MCP

Cliff as an MCP client

cliff mcp add docs https://example.com/mcp          # remote, Streamable HTTP
cliff mcp add files -- npx -y @modelcontextprotocol/server-filesystem .
cliff mcp list
cliff mcp remove docs

Servers are saved in ~/.cliff/mcp.json as { "servers": { "name": { "url" } or { "command", "args" } } }. Their tools show up as mcp_<server>_<tool> and ask before each call.

Cliff's own MCP server

The live-link host, the price list and Cloud tasks are a remote MCP server for any agent:

claude mcp add --transport http cliff https://readcliff.xyz/api/mcp
ToolArgumentsCredits
model_pricesprovider?0
estimate_costmodel, input, cachedInput?, output1
publish_sitefiles[{path, text|data}], title?10
site_infosite0
unpublish_siteid, token0
cloud_run_tasktask, provider, key, model?, baseUrl?, repo?, branch?, files?, minutes?, publish?, publishDir?Free once a day per wallet, then 1 a minute; needs a key
cloud_task_statustask, token?, offset?0

Without a key, calls use the free tier. With a key, send Authorization: Bearer ck_….

HTTP API

Base URL https://readcliff.xyz. JSON in and out, CORS open to every origin, no key needed for the free tier. Read routes are cached for 60 seconds at the edge. Errors are { "error": "code", "message": "…" } with a fitting status: 400 bad input, 402 needs credits, 404 not found, 413 too big, 415 file type, 429 free limit.

GET /api/models

The price list, the same as /models.json. Cost: free.

curl -s https://readcliff.xyz/api/models
{"checked":"2026-11-15","unit":"USD per million tokens","note":"…","providers":[
  {"id":"anthropic","name":"Anthropic","env":"ANTHROPIC_API_KEY","source":"https://platform.claude.com/docs/en/about-claude/pricing",
   "models":[{"id":"claude-opus-5-5","name":"Claude Opus 5.5","input":4,"output":20,"cachedInput":0.2,"cacheWrite":5,"default":true}, …]}, …]}

GET POST /api/estimate

What one request costs at list price. Pass model, input (all prompt tokens), cachedInput and output, as query or JSON. Cost: 1 credit, or free within the free tier.

curl -s -X POST https://readcliff.xyz/api/estimate -H 'content-type: application/json' \
  -d '{"model":"claude-sonnet-5-5","input":40000,"cachedInput":30000,"output":2000}'
{"model":"claude-sonnet-5-5","provider":"anthropic","prices":{"input":2,"output":10,"cachedInput":0.1,"cacheWrite":2.5,"unit":"USD per million tokens"},
 "tokens":{"input":40000,"output":2000,"cachedInput":30000},"usd":0.043,"checked":"2026-11-15","source":"https://platform.claude.com/docs/en/about-claude/pricing"}
404 {"error":"unknown_model","message":"Cliff has no list price for nope. GET /api/models lists the models it knows."}

POST /api/publish

Put files at a live link. Body: {"title"?, "files": [{"path", "text"} or {"path", "data": "<base64>"}]}, up to 3.4 MB of JSON. Cost: 10 credits with a key (30 days); free without one (5 a day per IP, 7 days).

curl -s -X POST https://readcliff.xyz/api/publish -H 'content-type: application/json' \
  -d '{"title":"Hello","files":[{"path":"index.html","text":"<h1>Hello from Cliff</h1>"}]}'
{"id":"nen5mkh6d7","url":"https://readcliff.xyz/api/live/nen5mkh6d7/","expires":"2026-11-22T18:38:47.388Z","days":7,"files":1,"bytes":25,
 "token":"zIYmpqgXdUH_xbmkjgZv-4y4A4QFBr8W","mode":"preview","credits":{"cost":10,"left":56,"mode":"preview"}}

Keep token: it is the only way to remove the site. mode is paid, free, or preview (free, before the token launches). Errors include no_index, bad_path, duplicate, 413 too_big, 415 file_type and 429 free_publish_limit.

GET /api/live/<id>/<path>

Serves a published file. HTML gets the sandbox headers and the hosted-by note. Cost: free.

HTTP/1.1 200 OK
Content-Security-Policy: sandbox allow-scripts allow-popups allow-modals allow-downloads; form-action 'none'; frame-ancestors 'none'; base-uri 'self'
X-Robots-Tag: noindex, nofollow
Referrer-Policy: no-referrer
Cache-Control: public, max-age=0, s-maxage=60

An unknown site is 404, an expired one 410, a removed one 410 with the reason.

GET /api/hosted?site=<id>

A site's status. Cost: free.

curl -s 'https://readcliff.xyz/api/hosted?site=nen5mkh6d7'
{"id":"nen5mkh6d7","title":"Hello","url":"https://readcliff.xyz/api/live/nen5mkh6d7/","status":"live","created":"2026-11-15T18:38:47.388Z",
 "expires":"2026-11-22T18:38:47.388Z","files":1,"bytes":25,"mode":"preview"}

POST /api/unpublish

Removes a site. Body: {"id", "token"}. Cost: free.

curl -s -X POST https://readcliff.xyz/api/unpublish -H 'content-type: application/json' -d '{"id":"nen5mkh6d7","token":"…"}'
{"removed":true,"id":"nen5mkh6d7","note":"Cached copies can show for up to 60 seconds."}

POST /api/extend

Adds 30 days to a site, up to 365 days ahead. Body: {"id", "token"}, with a key. Cost: 10 credits.

402 {"error":"needs_credits","message":"Extending a live link takes 10 credits from a key with credits, bought by burning $CLIFF once it launches. Free links last 7 days."}

POST /api/report

Reports a site that breaks the rules. Body: {"site", "reason"}. 10 a day per IP. Cost: free.

{"ok":true,"message":"Thank you. The operator reviews reports and takes down sites that break the rules."}

GET /api/cloud/info

Whether Cloud is open or paused (and why), the caps, the price, the machine and what it costs at Vercel's list prices. With a key, you says whether your free task today is still there. Cost: free.

{"state":"open","code":null,"reason":null,"version":"0.2.0","launched":false,
 "caps":{"dailyUsd":5,"walletDailyUsd":1,"maxRunning":2,"maxMinutes":20,"minMinutes":3,"paused":false},
 "price":{"freeTasksPerWalletPerDay":1,"freeTasksPerIpPerDay":2,"creditsPerMinute":1,"chargedUpFront":true,"unusedMinutesRefunded":true},
 "machine":{"vcpus":2,"memoryGb":4,"region":"iad1", …},"vercelCost":{"worstPerMinute":0.00568,"typicalPerMinute":0.00184,"worstMaxTask":0.113601, …},
 "key":"Your model key is sent per task, passed to the sandbox only as an environment variable, and never stored or logged. …","you":null}

Paused looks like {"state":"paused","code":"paused"|"unavailable"|"daily_capacity"|"busy", "reason":"…"}.

POST /api/cloud/run

Starts a task. Needs Authorization: Bearer ck_…. Body: {"task", "provider": "anthropic"|"openai"|"gemini"|"compatible", "key", "model"?, "baseUrl"?, "repo"?, "branch"?, "files"?: [{"path", "text"|"data"}], "minutes"?, "publish"?, "publishDir"?}. Returns the task and a token for later calls (or use the key). Cost: your free task of the day, then 1 credit a minute up front.

curl -s -X POST https://readcliff.xyz/api/cloud/run -H "authorization: Bearer $CK" -H 'content-type: application/json' \
  -d '{"task":"add a dark mode toggle","provider":"anthropic","key":"'"$ANTHROPIC_API_KEY"'","repo":"https://github.com/you/site","minutes":10}'
{"task":"te9jkpcvmt6n","state":"running","minutes":10,"billing":{"mode":"free","credits":0,"refunded":0},"secondsLeft":600,
 "cost":{"reservedUsd":0.056801},"keptUntil":"2026-11-23T15:24:48.199Z","token":"tt_…","note":"Keep the token: …"}

Errors: 401 sign_in, 402 free_used or needs_credits, 400 bad_input, 413 too_large, 429 wallet_daily_cap, 503 paused, unavailable, busy or daily_capacity. Nothing is charged when a task doesn't start.

GET /api/cloud/task?task=<id>

A task's state, answer, changed files, live link and cost. Send the task token as x-task-token, or the owner's key. Cost: free.

{"task":"te9jkpcvmt6n","state":"done","endReason":"done","minutes":5,"billing":{"mode":"free", …},
 "result":{"exitCode":0,"answer":"Done: I wrote site/index.html …","usage":{…},"changed":["site/index.html"],"deleted":[],"keptOut":["notes/secret.txt"]},
 "download":{"bytes":406,"files":1,"route":"/api/cloud/download?task=te9jkpcvmt6n"},
 "published":{"url":"https://readcliff.xyz/api/live/x4ukr2f7yd/","expires":"2026-11-23T15:24:49.566Z","deleteToken":"…"},
 "cost":{"reservedUsd":0.028401,"actualUsd":0.001419,"cpuMeasured":true,"minutes":1}, …}

GET /api/cloud/logs?task=<id>&offset=<n>

The log from byte offset: {"state", "text", "next", "done"}. Call again with offset=next until done. Cost: free.

POST /api/cloud/stop · GET /api/cloud/download?task=<id> · GET /api/cloud/tasks

Stop a task early with {"task"} (the changes so far are packed and unused minutes come back); download the changed files as application/gzip; list your wallet's tasks from the last 7 days. Same token or key as above. Cost: free.

POST /api/waitlist

Joins the waitlist for what Cloud doesn't run yet. Body: {"email", "interests"?}, interests from services, apps, phone, desktop, team. {"email", "remove": true} takes you off. Cost: free.

curl -s -X POST https://readcliff.xyz/api/waitlist -H 'content-type: application/json' -d '{"email":"you@example.com","interests":["services","apps"]}'
{"ok":true,"message":"You are on the Cliff Cloud waitlist. One email when it opens; nothing else.","interests":["services","apps"]}

GET /api/stats

The agent's version and files, live sites, free publishes today, the limits and the price list date. Cost: free.

{"agent":{"version":"0.2.0","file":"/cliff.mjs","checksums":"/version.json","install":"/install.sh"},
 "hosting":{"liveSites":10,"freePublishesToday":5,"limits":{"freeDays":7,"paidDays":30,"maxDays":365,"freePublishPerIp":5,
 "freePublishTotal":300,"maxFiles":200,"maxBytes":2000000,"cacheSeconds":60}},"prices":{"checked":"2026-11-15","models":18}}

POST /api/mcp

The MCP server above (JSON-RPC 2.0, Streamable HTTP). Cost: per tool.

curl -s -X POST https://readcliff.xyz/api/mcp -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"model_prices","arguments":{"provider":"openai"}}}'
{"jsonrpc":"2.0","id":1,"result":{"content":[{"type":"text","text":"List prices in USD per million tokens, checked 2026-11-15.\nOpenAI …"}],
 "structuredContent":{"checked":"2026-11-15","unit":"USD per million tokens","providers":[{"id":"openai", …}]}}}

Static files: /version.json (version, size and SHA-256 of cliff.mjs), /models.json, /install.sh, /cliff.mjs, /llms.txt and /.well-known/agent-registration.json.

Free tier and credits

The agent is free and needs no account. On this server, every route works without a key up to 100 calls a day per IP (10,000 a day for everyone), plus the publishing caps above. Above that, credits pay for the hosted extras.

CallCredits
estimate, estimate_cost1
cloud/run, cloud_run_task, after the free task of the day1 a minute
publish, publish_site10
extend10
Everything else0
  1. Get a key: sign a short message with your wallet on the home page, or POST /api/credits/key {"wallet", "issuedAt", "signature"}. Keys start with ck_ and are shown once.
  2. Buy credits on the home page: the Credits contract burns credits × price $CLIFF from your wallet.
  3. Send the key as Authorization: Bearer ck_… or x-api-key, or save it in the agent with cliff key set ck_….

Every response says x-credits-mode and x-credits-left. GET /api/credits/info shows the price and totals; GET /api/credits/balance your balance and last calls; POST /api/credits/revoke deletes a key. A charged call that fails is refunded, and every refund is listed at /api/credits/refunds. A 402 is plain HTTP with instructions, not x402.

{"launched":false,"chainId":4663,"contract":null,"token":null,"ticker":"CLIFF","pricePerCredit":null,"totalCredits":null,"totalBurned":null,
 "costs":{"estimate":1,"publish":10,"extend":10},"free":{"perDay":100,"perDayTotal":10000},"buyCall":"buyFor(address account, uint256 credits, uint256 maxBurn)", …}

The token

$CLIFF is a plain ERC-20 on Robinhood Chain, launched on Pons: 1,000,000,000 tokens, 18 decimals, nothing can mint more. Its one use is buying credits, and buying credits burns it: the tokens go to 0x000000000000000000000000000000000000dEaD and are gone. You never need it to run the agent, use a model, or use the wallet. It pays no fees, shares, or anything else to holders. Live numbers are on tokenomics.

Files and privacy

File in ~/.cliffWhat's in it
config.jsonYour provider and model
keys.jsonModel keys and your Credits key (mode 600)
wallet.jsonThe encrypted wallet key, address and send limit (mode 600)
memory.mdNotes the agent saved with remember; edit or delete freely
sessions/Your conversations, for --continue
sites.jsonYour live links and their delete tokens
mcp.jsonYour MCP servers
cloud.jsonYour Cloud task ids and their tokens

What leaves your computer: your messages and the files the agent reads go to the model provider you chose, under that provider's terms. Wallet reads and signed transactions go to the Robinhood Chain RPC. publish uploads the folder you name. cloud run sends the task, your model key and any files you upload to readcliff.xyz, which hands them to that task's machine. models --refresh, doctor and update download public files from readcliff.xyz, and the wallet asks readcliff.xyz for the $CLIFF token address so balances can include it. Nothing else: no telemetry, no account, no analytics in the agent.

Speed

62 mscliff --version
46 MBMemory at start
1.8 msSign a transaction
0Dependencies

Medians of repeated runs on an Apple M1 Pro with Node 22; bare Node starts in 48 ms and 40 MB on the same machine. Answers take as long as your model takes.

Troubleshooting

Run cliff doctor first. It checks the Node version, that ~/.cliff is writable, which keys it finds and where from, the provider and model, the Robinhood Chain RPC, the wallet and its send limit, your MCP servers, and whether an update is out.

  • cliff: command not found: add ~/.local/bin to your PATH; the installer prints the line for your shell.
  • 401 or 403 from the provider: the key is wrong or has no credit with that provider. Run cliff setup again.
  • 429 from the provider: Cliff waits and retries a few times on its own; if it keeps happening, pick a smaller model or wait.
  • Wallet: forgot the passphrase: there's no reset. The key is encrypted with it and we never had a copy.
  • Windows: Cliff runs under Node on Windows too, but the installer is for macOS and Linux; see download.