Tin
Reference · tin.ad

On this page

tin.ad

tin deploy with no target: a URL like brisk-otter-k3m9.tin.ad in one command, each deployment in its own isolate, an EIP-8004 file per agent.

One command

tin deploy main.tin

A file can be just an agent: it needs no main, and every agent becomes an endpoint (POST /agents/<Name>, answered as JSON or streamed as server-sent events, plus /mcp), the same as under tin serve. With no --target, tin deploy compiles the program for Cloudflare Workers (the same checks as --target cloudflare), uploads the compiled module and its manifest to https://api.tin.ad, and prints a generated address:

uploading main.tin (14 KB) to https://api.tin.ad

live: https://brisk-otter-k3m9.tin.ad   anonymous, expires in 24 h
  agent Hello: curl -N https://brisk-otter-k3m9.tin.ad/agents/Hello -H 'accept: text/event-stream' -d '{"prompt":"hello"}'
    EIP-8004: https://brisk-otter-k3m9.tin.ad/agents/Hello/registration.json
  manage: tin ls · tin logs brisk-otter-k3m9 · tin rm brisk-otter-k3m9

Without an account a deployment is anonymous and lives 24 hours. The key that controls it is saved in ~/.tin/cloud.json (readable only by you). Running tin deploy on the same file again updates the same address; --new makes a new one.

Sign in

tin login
To sign in to tin.ad with GitHub, open https://github.com/login/device and enter the code:

    WDJB-MJHT

signed in to tin.ad as @you. Deploys are now kept and owned; tin deploy app.tin --name <name> picks the name.

tin login uses GitHub's device flow, run by api.tin.ad: the server receives the GitHub token, checks with GitHub that it was issued to the tin.ad app, reads your user id, and drops the token (it is stored nowhere). Your machine only gets a tin.ad session token, saved in ~/.tin/session.json (readable only by you) for 90 days. tin.ad asks GitHub for no scopes and keeps no GitHub token. Your account is your numeric GitHub id, so renaming your GitHub login keeps your deployments.

Signed in:

  • deployments are kept (no expiry) and owned by your account, up to 20;
  • tin deploy app.tin --name shop asks for shop.tin.ad;
  • tin ls, tin logs, tin rm and tin secrets reach every deployment you own, from any machine you signed in on. Another account gets 404 on all of them, the same answer as a name that does not exist;
  • an anonymous deployment from this machine becomes yours the next time you tin deploy it (that needs both your session and its deploy key).

tin whoami shows the account; tin logout revokes the session on the server and deletes the file. In a browser, api.tin.ad/auth/github signs in with the same GitHub app and api.tin.ad/console shows what you own (see Console). That cookie is set only for api.tin.ad, so no name.tin.ad deployment can read it. For scripts and CI, TIN_SESSION takes the place of the file.

Commands

CommandWhat it does
tin deploy app.tin [--yes] [--new] [--name n]build, upload, print the URL (--name needs sign-in)
tin login · tin logout · tin whoamisign in to tin.ad with GitHub, sign out, show the account
tin lsthe deployments your account owns, and the ones made from this machine, with version and expiry
tin logs [name] [-f] [--level error|warn] [--grep text]the last 200 lines: one per request, plus what the program printed; -f follows
tin requests [name] [-f] [--status 5xx] [--agent A] [--route /x]recent requests: time, status, duration, tokens, model, trace id
tin traces [name] [--errors] · tin traces name <trace id>recent traces, or one trace as a tree with timings, tokens and errors
tin metrics [name] [--range 1h|24h|7d]requests, errors, p50/p95/p99, cold starts, tokens and an estimated cost, per model and tool
tin rm namedelete it now
tin secrets [ls | set NAME | unset NAME] [--app name]the deployment's secrets, by name
tin register [name] [--agent A] [--chain c] [--agent-id N]opt-in EIP-8004 registration on a test network

Console

api.tin.ad/console is the signed-in side: every deployment you own, what it served, what its agents did and what that cost. It shows what the CLI commands above show, from the same /v1 API.

PageWhat it shows
Deploymentseach deployment: requests and error rate in the last 24 h, median and p95 latency, tokens, the last error with its text, a 24 h chart
Requeststhe newest requests with status, duration, cold start, tokens (input, output, cache, thinking), model and a link to the trace; filters; a live tail
Tracesone trace as a waterfall: the request, then invoke_agent, each model call (chat) and tool call (execute_tool) under it, with OpenTelemetry GenAI attributes, timings, tokens and errors
Metrics1 h, 24 h or 7 days: requests, errors, exact percentiles, cold starts, tokens by model, tool calls, estimated cost
Logssearch, level, time; each request line links its trace; a live tail
Agentsper agent: calls, errors, average time, model and tool calls, tokens, estimated cost, top errors
Settingssecrets by name, content capture, export to your own OpenTelemetry collector, versions and rollback, delete
Accountyour sessions (revoke them), CI tokens, usage against the limits

Where the numbers come from. tin.ad records one line per request after the answer is sent (method, path without the query string, route, agent, status, time to the last byte, cold start, trace id, the first 300 bytes of a 5xx answer). The Tin runtime in your deployment sends its built-in OpenTelemetry spans (see Telemetry) to tin.ad as well. Request bodies, headers and secret values are not stored, and attribute names that look like credentials are replaced by [redacted]. Records are kept 7 days; a deployment keeps at most 20,000 spans a day. Deleting a deployment deletes them too.

Content capture is off: spans carry names, timings, tokens and errors, never prompts or replies. Turning it on in Settings sets OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=true for the deployment; the trace page then shows the messages. Export: Settings stores an OTLP/HTTP endpoint (https only) and headers as the deployment's OTEL_EXPORTER_OTLP_* secrets, and the same spans also go to your collector.

Cost is an estimate: tokens of each model call times Anthropic's API list prices as published on 2026-11-16 (cached input, cache writes and output priced separately; thinking counts as output). Your provider, discounts or batch rates may differ, and models without a known price show "no price". CPU time is not shown: a Worker cannot read its own CPU time.

CI tokens (Account): tin_ci_…, read-only or read + deploy, for all deployments or one, 30 to 365 days. Use one as TIN_SESSION in CI. A token cannot make other tokens or sign in to the console.

Security. The console lives only on api.tin.ad; its cookie is __Host-, HttpOnly, Secure, SameSite=Lax. Every change is a form that must come from https://api.tin.ad and carry a per-session token (every name.tin.ad is the same site until tin.ad is on the Public Suffix List, so SameSite alone is not enough). Pages run no inline script or style (script-src 'self'); the only script is the 1 KB live tail. Another account's deployment is the same 404 as one that does not exist.

Secrets

The manifest lists the keys the program reads (from its agents' model strings). For each one, tin deploy takes the value from your environment only after you say yes (--yes for scripts), or asks for it without echoing. Long-lived AWS access keys are refused unless you pass --allow-access-keys; use a scoped key such as a Bedrock API key. tin secrets set NAME reads the value from a prompt or from standard input, never from the command line.

On the platform, each deployment's secrets are encrypted with AES-GCM under a key derived from the platform key and the deployment's name, with the name as associated data. Values are never shown again: tin secrets ls lists names. Setting or removing a secret takes effect on the next request.

How deployments are kept apart

  • Each deployment runs in its own isolate (Cloudflare's Worker Loader), created with only that deployment's secrets. The isolate's id includes the deployment's key, creation time, secrets and runtime version, so a name that is used again, or a changed secret, always gets a fresh isolate.
  • You upload app.wasm and manifest.json, never JavaScript. tin.ad runs its own copy of the Tin runtime around the module and checks the manifest against the module's own tin.meta. Programs that need Node (import js/py/mcp) or compile code at run time (code: true) are refused, as on --target cloudflare.
  • A deployment has no storage bindings. Its outbound requests go through the platform, which refuses tin.ad itself, plain http:// and private or loopback addresses.
  • Every control-plane call needs that deployment's key; only a SHA-256 of it is stored. A wrong key and an unknown name get the same 404 (401 only when no session or key was sent).

EIP-8004 files

For each agent, the platform serves an EIP-8004 registration file at /agents/<Name>/registration.json (type …#registration-v1, name, the agent's /// doc as the description, an image, its services, registrations, supportedTrust), and the endpoint-domain file at /.well-known/agent-registration.json. Both are checked by a validator written from the spec before a deploy is accepted, and the tests check it against the spec's own example.

Registering on a chain

Optional, and on test networks only: base-sepolia (chain 84532), sepolia (chain 11155111). tin never holds a wallet key or sends a transaction.

tin register brisk-otter-k3m9 --agent Support --chain base-sepolia
  Identity Registry: 0x8004A818BFB912233c491871b3d84c89A494BD9e
  agentURI:          https://brisk-otter-k3m9.tin.ad/agents/Support/registration.json
  calldata:          0xf2c298be…
  with Foundry:      cast send … "register(string)" "…" --rpc-url https://sepolia.base.org --account …

Send that call from your own wallet, then give tin.ad the agent id:

tin register brisk-otter-k3m9 --agent Support --agent-id 42

tin.ad reads tokenURI(42) on the chain and lists the registration only if it is this agent's file. After that, the registration file and the well-known file name the agent, so the domain verifies for it.

Limits

anonymous lifetime24 hours, then removed (signed in: kept)
signed-in deployments20 per account; no per-deployment daily request cap, the platform-wide cap still applies
anonymous deploys10 per address per day; 200 live in total
requests1000 per anonymous deployment per day; 60 per minute per address; 50,000 per day for the whole platform
CPU1 second per request (time spent waiting on a model does not count)
upload6 MB; 20 secrets of up to 4096 bytes

Names and abuse

Generated names are an adjective, a noun and four characters. Custom names (after sign-in) must be 3 to 40 characters; platform names (www, api, admin, login, auth, app, docs, mail and more), names with another company's brand, phishing words and the generated shape are refused. Pages from anonymous deployments are served with Content-Security-Policy: sandbox (no scripts, no forms), and a deployment cannot set cookies for all of tin.ad. Report a deployment:

curl -X POST https://api.tin.ad/v1/abuse -d '{"url":"https://name.tin.ad/","reason":"phishing"}'

What does not work yet, and one number

  • Sign-in is GitHub only; Google and Apple are not built.
  • WebSockets on tin.ad.
  • Measured on a second machine with an empty home directory: curl -fsSL https://tin.ad/install.sh | bash, write a one-agent file, tin deploy, and stream a Claude Haiku 4.5 answer with curl -N took 4.6 seconds in total, first byte 0.44 s (cloud/three-minute.sh, 2026-11-16).