You have a ~handle. Now what?

Already included for free

All of it comes with the ~handle at no cost, and none of it is a tier you upgrade into.

Three commands, one decision

Install the CLI, then make the only decision there is, whether you are minting a new ~handle or signing in to one you already hold. The third command writes the config for the AI clients on this machine, which is the list under it.

# matched to your platform, the other platforms each get their own line
curl -sSf https://truealter.com/install.sh | bash
alter register   # or alter login
alter wire

• [x]Claude Code
• [x]Cursor
• [x]Claude Desktop
• [x]VS Code

Anything else takes a URL, because ~alter is a hosted MCP server any client can point at.

https://mcp.truealter.com/api/v1/mcp

Call it from your own code

The CLI is one way in. The other is the SDK, which is one typed method per tool and nothing else: no client to write, no schema to keep in step, and the same surface every client above is already talking to.

npm install @truealter/sdk

import { AlterClient } from '@truealter/sdk';

const alter = new AlterClient();
const who = await alter.resolveHandle('~example');

The read tools are free to call, and what they return is bounded by what the subject consented to share. The deeper reads carry a price, $0.01 to $1.00 per call, paid in USDC on Base, and 75% of every paid call routes to the data subject. An agent already holding USDC on Base already holds the rail. The SDK carries the protocol side of it, the cap per query, the network and asset check, and the check on who is being paid. It brings no wallet of its own, so the signer stays the one you already use.

The ceiling, stated here rather than found out later. One chain, Base. One asset, USDC. No swap, no bridge, no cash-out to a bank, and nothing of yours held in the middle: ~alter records what it owes and where it goes, and never takes custody of the money.

What sits on top of that is not ours to guess at. The identity read and the payment for it are the same two calls whatever you are building.

What each call costs

Give your agent its own ~handle

Everything above assumes a person at the keyboard. Software that acts on its own can hold a ~handle in its own right, with no human account behind it, so it is identifiable to whatever it talks to and coordinates with other ~handles as itself rather than as whoever ran it.

Start at the manifest. It names the endpoint, what costs nothing, and the two calls that mint the ~handle. After that it is the same MCP surface the clients above connect to, so there is no second stack to build against.

GET https://truealter.com/.well-known/mcp.json

call register_autonomous_challenge, then register_autonomous · auth: none · price: 0

An agent acting for you is not you

That is software acting for itself. Software acting for you is the other case, and the rule there is settled: it never speaks under your ~handle. It holds one of its own, in a tier of its own, ending in .bot. Not your name with something added to the end of it. A separate name for a separate kind of thing.

Which is the whole point of the separation. You stay the ~handle that is known and that earns. The one acting for you is visibly not you, and what it holds is narrower than what you hold, so nothing it does anywhere reads as you having done it.

Where this stands. The rule is settled, which means it is decided and it will hold when the surface arrives. Nothing reaches it today: no ~handle in that tier can be created from any surface, and a ~handle claimed now cannot take that shape at all. The namespace it belongs to is written out in full in the ~handle protocol.

Reference