Commands

Every command the aile client accepts. Global options (--server, --insecure, --json) are documented on the CLI overview and are not repeated per command.

Coding tools

setup

Use aile from the coding tools on this machine. With no arguments it shows one checklist of the tools installed here, each ticked, with what setup will do to it. For Claude Code and Codex, one more row, Also make aile the default, makes aile their default instead of only adding the shortcuts. Setup then gets an API key, shows every change, and applies them after you confirm. A tool that is not installed is not listed: name it (aile setup droid) to set it up anyway, and aile detect lists every tool aile knows.

1aile setup                         # pick from what is installed
2aile setup claude codex            # just these
3aile setup --all --yes             # everything found, no questions
4aile setup claude --mode default   # make aile Claude Code's default, no questions

The key. If this machine is signed in, setup mints a key on that account. If not, it opens your browser to approve one. Approving a key does not sign the machine in, and it does not log out your other machines. A key is saved and reused by later runs, aile run and aile env.

If the server cannot approve a key from the browser, setup offers two other ways: sign in with your browser, after which the key is made on your account, or paste a key from the dashboard. Signing in works like aile login, so it signs out your other machines, and the option says so.

Shortcuts go in the first writable directory already on your PATH:

• macOS and Linux: ~/.local/bin
• Windows: npm's %APPDATA%\npm, or %LOCALAPPDATA%\Microsoft\WindowsApps

On Windows, both .cmd and a Git Bash script are written. A tool installed off PATH is started by its full path.

Safe edits. A file that is not plain JSON (comments, JSON5) is never rewritten; you get the snippet instead. Every value replaced is recorded.

aile setup status shows what is set up and where. aile setup refresh gives every tool already set up the current key: --new-key mints a new one (after revoking a key, or signing in to another account), and --key uses one you have. A route set with --route goes with its key and the tools it was given to: refresh keeps it on those tools for that key and takes it out of them for another (refresh --no-route takes it out for good). --no-route, or a --model of your own, on some tools takes it out of those only; the rest keep it. Taking it out gives a tool back the model the route replaced, and leaves a model you changed yourself since. A different route for only some of the tools holding one is refused until you name the rest.

aile setup --remove [tool…] puts every file back as it was and deletes the shortcuts. Removing every tool also forgets the key on this machine, and --revoke revokes it on your account too.

Not supported yet, because they have no setting that points at another provider: Gemini CLI (it speaks only Google's own API format), GitHub Copilot, Amp, Kiro, Warp, Augment and Trae. aile detect still lists them.

Run from inside an agent. When setup runs inside Claude Code, Codex, opencode or another agent, it pre-selects that tool. It also tells you that changing that tool's settings takes effect in its next session. Whether to ask questions is still decided by whether there is a terminal.

detect

Which coding tools are installed here, and where. Aliased as tools.

1aile detect
2aile detect --json

A tool is found in any of these places:

• a command on PATH;
• a command at its installer's own location, even off PATH (~/.local/bin, ~/.opencode/bin, ~/.claude/local, uv and pipx tool folders, …);
• an app (Cursor, Devin Desktop, Zed, Kiro, Warp);
• an extension in VS Code, VSCodium, Cursor, Devin Desktop, Kiro or Trae (Cline, Roo, Kilo, Continue, Claude Code, Codex, Copilot).

Each tool's own directory variables are honoured, such as CODEX_HOME, CLAUDE_CONFIG_DIR, OPENCODE_INSTALL_DIR, VSCODE_EXTENSIONS and UV_TOOL_DIR. A config directory with nothing else is shown as a hint, not as installed.

--fast skips reading versions. --json also reports invoker, the coding agent running the command, if any.

run

Start a tool through aile without editing anything. Everything after the tool's name is passed to the tool unchanged.

1aile run claude
2aile run codex exec "fix the failing test"
3aile run --model cc/claude-opus-5 aider

The key travels in the tool's environment, never on its command line.

env

Print the environment aile run would set, for any other way of starting a tool.

1eval "$(aile env claude)"
2aile env --shell powershell codex

--shell takes sh, fish, powershell or cmd.

doctor

Checks that the server answers, the key works, each shortcut is on PATH, and each tool's config still points at aile. It also warns about shell variables that would override those settings.

Account

login

Sign in and register this machine, in one step. Shows a code, opens your browser, waits for approval, then stores a token with permissions 0600. Your password never reaches the terminal.

1aile login

Both flows race, so the paste fallback is offered from the second one. You do not have to wait for the browser path to fail first.

A pasted token is normalised (surrounding quotes, a leading Bearer, stray whitespace) and screened before use: a URL, a device code, or anything under 20 or over 512 characters is rejected with a reason. It is then verified against the server before it is written to disk.

register

Register this machine against a token that was issued out of band. aile login does this for you; this is the separate half, for images and provisioning.

1aile register --token <token>

logout

Sign out. Clears this machine's local token and relay state. Connected accounts stay on the server. This does not unlink anything.

1aile logout
2aile logout --tools   # also take aile out of your coding tools, and revoke their key

The coding tools aile setup configured use a separate API key. It keeps working after you sign out, so logout says so. On a terminal it asks whether to remove aile from the tools too. Signing in as a different account offers to move the tools to a key on that account (--yes accepts); the manual equivalent is aile setup refresh --new-key.

donate

Contribute this machine unpaid, with no account. Aliased as contribute.

1aile donate
2aile donate --yes    # skip the confirmation, for images and provisioning

Nothing accrues and nothing can be claimed later. A donor machine's token is the only copy. There is no identity to prove, so the server cannot reissue it. Lose it and the machine enrols again as a new donor.

Sharing

connect

Link a provider account. With no argument you get a menu, split into Subscriptions (sign in with the provider) and API keys (paste a key, billed to you).

1aile connect                    # menu
2aile connect codex              # a specific subscription
3aile connect openrouter         # an API-key provider — prompts, masked

Reading a key from stdin:

1echo "$KEY" | aile connect groq --key -

Without a terminal and without --key, the client declines rather than hanging on a stdin nobody is writing to.

The CLI links the providers most sharers use; the dashboard and the MCP link tools reach every provider the server supports. Linking the same API key again updates that account (Reconnected) and keeps its nodeless setting unless you pass --nodeless or --no-nodeless. After a link the client names the next step: aile start for a node-backed account, aile test <n> for a nodeless one (its models are not tested at link), and --nodeless for a provider only Aile can serve, such as Cloudflare Workers AI.

accounts

Connected accounts, grouped by provider and numbered. The numbers are what every other command means by <n>.

1aile accounts
2aile accounts --json

Each account shows its route: this machine, another of your machines, Direct (nodeless), or no route (no node up and Direct off). The route says how a request would reach the provider, not what is on sale; the line under it counts the account's models as listed, untested, failed or can't sell.

A machine sharing only a self-hosted model will say "no accounts" here and point you at aile capacity. A local model is capacity, but it is not an account.

capacity

Everything this machine shares, separated by kind, with the privacy difference between them spelled out.

1aile capacity
2aile capacity --json

label

Name an account. Aliased as rename.

1aile label 2 work-laptop

models

What an account lists, and why a model does not: listed, untested, failed, can't sell or off, each with the server's reason.

1aile models 3
2aile models 3 --json

test

Test an account's models so they list. It runs the same test as the dashboard's Test button: one small request per model on the account's own quota.

1aile test 3                      # every untested model
2aile test 3 gpt-5.5 gpt-5.4      # just these
3aile test 3 <image model> --yes  # renders output and bills the account
4aile test 3 --timeout 300        # wait up to 300 s per call (default 120)

Image, video and music models are tested only when named, and a lone one asks first. More than 25 untested models asks first too; --yes skips it (needed off a terminal). A timeout is not a failure: the server may still be testing, so check aile models before running it again.

check-key

Ask the server to re-probe a credential. Aliased as retest and recheck. With no number it checks everything.

1aile check-key
2aile check-key 3

Each account prints works, rejected or no answer (no healthy egress to test through), with the server's reason, e.g. refused-on-serve for a key a provider refused on a real request, which a passing check cannot clear.

This updates the live half of an account's status (working / failing / unchecked). It does not test models; aile test does. It cannot change the identity half. See Verification.

An API key the provider refused on a real request reads rejected (refused-on-serve) even when the key check passes. It clears once a request on that key succeeds, or when you re-link it.

usage

The quota each provider reports, per account. Aliased as quota.

1aile usage
2aile usage --json

nodeless

Serve an account with no machine in the path. on is accepted for API-key accounts only; off works for any account.

1aile nodeless 1 on
2aile nodeless 1 off

rates

What you charge, and what you will not serve. You set only a margin: a multiplier on each model's published list price, 0 (free) to 1 (list). Margins are per (sharer, model), never per account. Two keys for one provider share one price sheet, which is why no rates command takes an account number.

1aile rates                                       # margin, per-model margins, disabled models, bounds
2aile rates --margin 0.9                          # 0 (free) to 1 (list price), on every model
3aile rates set claude-opus-5 --model-margin 0.8  # a margin for one model
4aile rates clear claude-opus-5                   # back to the global margin
5aile rates off claude-opus-5                     # stop serving one model
6aile rates on claude-opus-5                      # serve it again

Dollar prices are retired, and --in/--out are refused (aile.sh 1.1.6 and later). A per-unit model (images, audio, video, …) with a published list sells at list × margin by default; aile rates off <model> stops one. A model with no list price is not sold.

disabled is kept separate from price, so clearing a margin never re-enables a model you turned off.

disconnect

Remove a linked account, by list number or id.

1aile disconnect 2
2aile disconnect 2 --yes

local

Download a model, run it on this machine, and share it. Or share a model server you already run (vLLM, LM Studio, anything speaking the OpenAI API). See Self-hosted models.

1aile local setup                        # one command: engine, model, test, share
2aile local                              # what is set up, and what each model sells as
3aile local models [query]               # models that download and sell, and which fit here
4aile local pull qwen/qwen3-8b           # download one: a curated id or an Ollama tag
5aile local pull hf.co/<user>/<repo>     # any GGUF on Hugging Face (:Q8_0 picks a quant)
6aile local list                         # what is downloaded
7aile local run <model> "a prompt"       # talk to it; no prompt opens a chat
8aile local rm <model>                   # delete one
9aile local install [ollama|llamacpp]    # install an engine on its own
10aile local on                           # offer it to callers
11aile local --off                        # stop sharing it; the endpoint is remembered
12aile local http://127.0.0.1:1234        # share a server you already run, and turn it on

A model sells only under an id with a published list price. The curated models are saved under that id (Ollama's llama3.1:8b becomes meta-llama/llama-3.1-8b-instruct), and every screen says whether a model sells, from the server's own price check. Any other model runs here but may not sell.

The endpoint is validated before it is saved and constrained to loopback or LAN addresses. A public value would turn the node into an open proxy.

Callers send local/<model>. The relay strips local/, so your endpoint sees the id it advertised.

mcp

Share an MCP server running on this machine, declared in mcp-servers.json next to your config. See Share via MCP.

1aile mcp              # what is declared, and whether it can run
2aile mcp check        # validate the file, print the exact argv
3aile mcp test <id>    # start it here and list its tools
4aile mcp path         # where mcp-servers.json lives

Each session a caller opens runs in its own throwaway container. With no sandbox there is no sharing: there is no unsandboxed fallback.

1claude mcp add --transport http aile https://api.aile.sh/mcp

start

Run this machine as a relay node. Long-running and foreground.

1aile start

• One node per machine. The node id derives from the machine, so a second aile start is refused and names the running pid.
• Starting with no accounts is fine. It serves the moment one is added.
• It reconnects on its own after a drop unless autoReconnect is off. If the server permanently refuses this machine it exits non-zero, so a service manager sees a failure rather than a node that looks alive.
• It refuses a plain http:// server other than localhost/127.0.0.1 unless allowInsecure is saved (aile config allowInsecure true), and exits saying so. --insecure does not apply here: every reconnect sends the account token.
• SIGINT / SIGTERM drain in-flight streams and exit cleanly.

status

Everything about this machine, one fact per line: its id and server, changed settings, the API key and coding tools, the account and its balance, each connected account and where it is served (this node, another node, nodeless or no node), requests served, local AI and MCP, and the relay. It ends with the next step that applies. aile start is suggested only for an account a node must serve: a nodeless account is served without any machine.

1aile status
2aile status --json

Reads the lock file, so it can report a relay running in another process. --json returns one object: machine, server, config, signedIn, account, accountError, accounts, served, balance, relay, key (masked), tools, notSetUp and settingsChanged.

stats

What each of your machines has served and earned.

1aile stats
2aile stats --json

status answers "is this box working?"; stats answers "which of my machines is carrying the traffic?" A machine that has served nothing is flagged, because that is the one to look at.

wallet

Your balance, and where earnings land. Aliased as payout.

1aile wallet
2aile wallet --qr      # with a QR code of the address, to fund it from a phone
3aile wallet --json

Your account's wallet is custodial: its private key lives in the wallet provider's enclave, and aile wallet only ever reads it. A balance that cannot be read shows as unknown, never as $0. While anything is owed for usage it also shows Owed and Spendable, the figure a withdrawal is checked against; with sharing earnings not yet paid out it shows Incoming. See Getting paid.

wallet own

An optional second wallet whose key stays on this machine. Nothing creates it but you, and nothing but aile chat --pay own, aile pay, aile deposit --from-own and aile wallet own send uses it.

1aile wallet own create               # new recovery phrase, shown once
2aile wallet own import               # restore from a phrase (typed hidden, or piped)
3aile wallet own                      # its address, USDC, SOL and a QR code
4aile wallet own send 5 USDC <addr>   # send USDC or SOL from it
5aile wallet own swap 0.05 SOL USDC   # turn SOL into the USDC calls are paid in
6aile wallet own remove               # delete it from this machine

The phrase restores the same address in Phantom or Solflare (m/44'/501'/0'/0'). It is encrypted with your passphrase in own-wallet.json next to your config; --no-encrypt skips that for a throwaway wallet. The phrase is never read from the command line, where it would land in your shell history.

Every payment and send is checked against your cap (walletMaxCents, or --max-usd for one command) before anything is signed.

Calls are paid in USDC, so a wallet funded with SOL needs swap first. It trades through Jupiter, on mainnet, and shows the quote before signing. It keeps 0.004 SOL back for fees and rent, and refuses a route that moves the price more than 2%.

Calling

sharers

Who is sharing, and what they charge. Aliased as market.

1aile sharers
2aile sharers --model gpt-5.2
3aile sharers --max-price 8

Every filter is applied by the server and echoed back. Nothing is filtered locally, so the CLI, the API and the web page never disagree about who is available.

The default order is the order requests are routed in: cheapest first, ties to the least-busy machine. The top row is the machine your next request goes to. --sort asks for a reading order instead, and the footer then says so.

A /v1 request's model must be <provider>/<model> (cc/claude-sonnet-5, local/llama3), or a bare id with x-aile-provider, which names the provider and sends the id upstream as written. A bare id alone is a 400, except on a key pinned to one provider, or from Claude Code or the Codex CLI, which route it to claude and codex. --model here and aile price still take bare ids.

price

What one request would cost, at each sharer's rate. Aliased as quote. Sends nothing.

1aile price claude-opus-5
2aile price gpt-5.2 --max-tokens 1024
3aile price gpt-5.2 --in 3000

Output is priced at the max_tokens your request authorises, not at the reply that comes back. That field is the one lever you hold over your bill. The default ceiling is quoteMaxTokens (4096). A key's balance is billed up to the cap sent upstream (the model's context window when none is sent), which tools, thinking, an unset max_tokens or a route that sends no cap (codex) can put above aile price; so can cache writes the provider reports, which bill at up to 2x input. An x402 payment is the quote itself: a request naming no cap is sent the one it was priced at, and a route that sends no cap (codex) is refused.

spend

What each sharer has cost you.

1aile spend
2aile spend --json

Counted from your own served requests, so a sharer who was cheap but timed out a third of the time looks worse here than any listing can show. Keyed on the sharer's handle, not their machine, so their history follows them across boxes and cannot be shed by re-enrolling a node.

chat

Call an AI model once, from the terminal. Aliased as ask. To call a tool another agent offers instead, see agents.

1aile chat "explain this error" --model claude/claude-sonnet-5
2git diff | aile chat - --model codex/gpt-5.6-sol --system "review this"
3aile chat "hi" --model <model> --max-tokens 800
4aile chat "hi" --model <model> --anthropic      # Anthropic's format (/v1/messages)
5aile chat "hi" --model <model> --pay own      # from your own wallet, no account needed

The price is quoted on --max-tokens, not on tokens used. Without the flag the request carries your quoteMaxTokens setting, the same ceiling aile price quotes.

--pay chooses who pays:

A call quoted under the facilitator's minimum settlement ($0.0008) cannot be paid per call and needs the balance.

agents

Find tools other agents offer, and call one at its flat price per call. This is the counterpart of mcp, which shares your tools; for an AI model, use chat.

1aile agents                                     # what other agents offer, with prices and tools
2aile agents summarize                           # only listings matching a word
3aile agents use <listing> <tool> --task "…"     # call one tool, paid from your balance
4aile agents use <listing> <tool> --task "…" --pay own          # …or from your own wallet
5aile agents use <listing> <tool> --args '{"q":1}' --task "…"   # the tool's own parameters

--pay works as on chat: auto (default), balance or own. The price is set by the agent that lists the tool and checked against your cap before your own wallet signs anything. The task text and arguments go to another agent, so never send a secret you would not show a stranger.

balance

What you can spend: your account's balance and, if you made one, the local wallet's.

1aile balance
2aile balance --qr     # a QR code for each wallet's address
3aile balance --json

deposit

Where to add funds to your account. Aliased as topup.

1aile deposit                    # the address to send USDC to, with a QR code to scan
2aile deposit --from-own 5     # send 5 USDC from your own wallet to your account

aile deposit and aile wallet own draw the QR code on a terminal and leave it out of a pipe; --qr and --no-qr decide either way. It encodes the bare address, which every Solana wallet app scans.

USDC sent to the address counts as soon as it lands; SOL, USDT and $AILE are converted to USDC. Off a terminal, --from-own needs --yes.

pay

Pay any x402 endpoint from your own wallet.

1aile pay https://example.com/paid
2aile pay <url> --method POST --body '{"q":1}'
3aile pay <url> --max-usd 0.10

The 402 is read, the amount checked against your cap, the payment signed, and the request sent again. Only exact payments in USDC on your own wallet's network are signed. A 402 that offers only MPP (WWW-Authenticate: Payment), or only another chain such as Base, is named rather than paid; aile's own 402s always include a Solana entry.

Client

config

Read or change settings. Aliased as settings. Full key reference: Configuration.

1aile config                        # every setting, grouped, with * on what you changed
2aile config maxConcurrent 8        # change one
3aile config maxConcurrent          # show one, with its default and range
4aile config --reset                # restore defaults, keeping sign-in and accounts
5aile config --reset maxConcurrent  # reset just one
6aile config --path                 # print the config file's location

update

Check for and install a newer client. Aliased as upgrade.

1aile update
2aile update --yes

Forces a fresh registry read rather than the once-a-day cache, so "up to date" is honest the instant you ask. On a terminal it confirms before touching a global install; off a terminal it names the command instead of running an unattended npm i -g, unless you pass --yes.

help

1aile help                 # every command, grouped
2aile help sharers         # one command: examples and details
3aile sharers --help       # the same
4aile -h

Help runs nothing: aile start --help does not start a node, and aile sharers --help makes no network call.

version

1aile --version

Also accepted as aile version, -v and -V.