Claude Code asks your phone first.

Your API keys live in Vando on your phone, not in .env files or chats. When Claude Code needs one, your phone asks you.

$ npm i -g @getvando/cli --registry=https://registry.npmjs.org --@getvando:registry=https://registry.npmjs.org
$ vando connect
# enter the code in the Vando app on your phone, then
$ vando run --secret STRIPE_KEY -- node send.js
Connect an AI, step by step

Mac, Linux or a Claude Code cloud session. Connecting takes about a minute once the app is on your phone. No npm? The one-line installer.

> open a pull request for this branch

● vando - get_secret (MCP)
    item_hint: "github token"
    purpose:   "open a pull request on my-app"
  ⏳ Waiting on your phone…
  ✓ Given · receipt verified · opened locally

● Bash(gh pr create --fill)
  https://github.com/…/pull/42

(Sealed to this machine’s agent key on the
phone. Vando’s servers carried it, unreadable.
get_secret puts the value in the chat: it is for
the rare case Claude must read it. Usually Claude
runs vando run --secret GITHUB_TOKEN -- gh pr create,
and the token never enters the chat.)
What your agent sees.
An ask on the phone: Claude Code on a MacBook wants to use a GitHub token, with a choice between a personal and a work token. Lock: Just me. Deny and Give are the same size.
A secret: you pick which one.

Why care?

What you’d use it for.

Each one is a real command. Claude can run them for you; your phone does the saying yes.

Connect Claude Code.

Connecting takes about a minute, with the Vando app already set up on your phone (setting it up takes a few minutes, once). Setting up the project takes a minute or two more. Four steps, the same on your laptop and in a Claude Code cloud session, and Claude can do all of it except entering the code on your phone. After that, an ask takes a tap and your fingerprint.

  1. 1 · Install vandoOne npm line: one signed binary, no sudo, on your PATH. Never through npx. On a computer without npm, the second line installs the same signed vando.
    $ npm i -g @getvando/cli --registry=https://registry.npmjs.org --@getvando:registry=https://registry.npmjs.org
    $ curl -fsSL https://getvando.com/install.sh | sh
  2. 2 · Run vando connectIt shows a code that works once, for 10 minutes. Run by Claude, it shows the code and ends; run again, it waits while you enter it.
    $ vando connect
    On your phone: Vando → Connect an AI → enter the code:
    
    K7M2Q-X4PRZ
  3. 3 · Enter the code on your phoneIn Vando, Connect an AI: type the code, check what is connecting, then tap Connect. The session then names the account it joined, from what your phone signed.
    $ vando connect
    ✓ Connected to you@example.com’s Vando.
  4. 4 · Set up the project, and check itWrites the AGENTS.md note and Claude Code’s permission rules in .claude/settings.json. Other settings are left alone. It prints three lines: whose Vando this is, what is ready, and what to do next. vando doctor prints one line when all is well, else the fix for each thing wrong. Optional: the MCP tools (get_secret), for the rare case Claude must read a value.
    $ vando setup
    $ vando doctor

A cloud session needs a few of Vando’s domains allowed, depending on how you install; the docs list them. The exact steps, and a block to paste into Claude Code · Every command · Setting up the app.

The agent gets one job. You keep the keys.

A secret goes from your phone to your laptop, sealed.

Claude runs vando run --secret NAME -- <command>, or, for the rare case it must read the value, calls get_secret with a hint and a reason. Here’s what happens next.

  1. 1 · You pickYour phone shows the ask. You choose the item and approve under its own lock.
  2. 2 · Your phone seals itIt opens the item locally and seals it to the agent key it pinned when you connected. Not to a key the server hands it.
  3. 3 · Once, then goneThe server stores the sealed copy for up to 10 minutes and deletes it when the agent fetches it.
  4. 4 · Opened on your laptopThe agent checks your signed approval, then opens it with its own key. Nothing is written to disk or logged.

Be clear about the last step. vando run --secret NAME -- <command> hands it to one command’s environment, and it never enters the chat. With get_secret the secret comes back in the tool result, so Claude sees it. Every release leaves a signed receipt, so you know what to rotate.

When things go wrong, it says no.

Every path we could think of fails closed: no answer is a no. Here are the ones people ask about; what waits how long has the timings.

Our server says “approved” when you didn’t.
The agent doesn’t take our word for it. Before it opens anything, it checks your signed approval against the keys it pinned at connect. Any mismatch is a no.
Our server, the network or your phone is down.
No approval, no secret. The ask waits; everything else carries on as normal.
The agent keeps asking.
Three denies in a row pause it. A paused agent is refused on every call until you resume it. Disconnect it and its open asks are withdrawn at once.
The connect is intercepted.
The code is the check: it is a password both sides prove they know (CPace), and our server only passes the messages along, so it can’t put its own key in the middle. A wrong guess uses the code up and your phone raises the alarm. A code someone else used first shows “This code was already used”, and the session names the account it joined.

What it doesn’t do.

Know the edges before you rely on it.

For the people who read specs

Under the hood.

Standard parts, used as specified. No custom cryptography.

Every answer is a signed receipt.

The phone builds a receipt core, hashes it as canonical JSON (JCS, RFC 8785) with SHA-256, and that hash is the WebAuthn challenge. Your passkey signs it, and so does a key in the phone’s secure chip (StrongBox on Android, Secure Enclave on iPhone), so every receipt names the device that answered. A deny is signed the same way.

The phone rebuilds the core itself from what it showed you, and refuses to sign anything that differs from what the server sent. Anyone with your public key can verify a receipt without asking us.

// receipt core, trimmed
{
  "v": 1,
  "rp": "id.getvando.com",
  "request_id": "…",
  "type": "credential_use",
  "authorization_details": [{
    "type": "credential",
    "hint": "github token",
    "purpose": "open a pull request on my-app"
  }],
  "recipe": ["level_just_me"],
  "agent_jkt": "",
  "decision": "deny",
  "iat": 1790000000,
  "exp": 1790000120
}
The agent proves who it is on every call.
It holds a P-256 DPoP key (RFC 9449) and a P-256 HPKE key, made on your machine. The server and your phone only ever see the public halves. The HPKE key is signed by the DPoP key, and your phone checks that before it seals anything.
Asks are signed too.
The agent signs each secret ask with its DPoP key. Your phone checks it against the key it pinned at connect and never shows an ask that fails.
Standard flows.
Asks go through CIBA (bc-authorize) with RFC 9396 authorization_details. Tokens are ES256 JWTs bound to the agent key (cnf.jkt), single use, with your receipts inside. Waiting asks live in a Durable Object per request.
Sealing.
HPKE to the pinned agent key, info = "vando/v1/credential", with the request and item ids as associated data. Only the fields a tool needs are released: a login’s username and password, an API key, an SSH key. Never notes or tags.
Rules in Cedar.
Each ask is turned into fixed attributes (category, reversible, sensitivity, strong), then Cedar policies add what it needs. There are floors nobody can go below. You never have to write a policy.
Keys on the agent machine.
The private keys sit in the macOS keychain or Linux’s secret service; in a cloud session, only for that session. ~/.vando/agent.json, mode 0600 in a 0700 folder, holds the rest; the CLI refuses a key file anyone else can read.
Your account’s own keys.
The vault’s root key is derived on your phone from your passkey’s PRF output and never reaches us. Each item has its own key, wrapped once per key that can open it (envelope encryption).

What our server can and can’t do.

What Vando’s server can and cannot do with agent asks
It canIt can’t
See which agent asked, when, the item’s id and the stated reason.Read your vault, or any secret released to an agent.
Delay or drop an ask, or go offline.Turn that into a yes. Every one of those ends in a deny.
Pass receipts along.Forge one, or reuse one for a different ask or a different agent.

The MCP tools Claude gets.

A local stdio server. Each result carries a status, a plain sentence (“Denied: didn’t ask for this. Don’t retry.”) and the receipt id.

Vando’s MCP tools
ToolWhat it does
get_secretAsks for an item by hint and purpose, waits for your phone, verifies the receipts, opens the sealed copy.
check_approvalPicks up an ask the client stopped waiting for. A decided ask returns its cached result; a secret is never fetched twice.
list_pendingThis agent’s open asks.
cancel_requestWithdraws an ask from your phone.
whoamiAgent name, your first name and its status. Never your rules.

The locks, for engineers.

Everyone else sees five words: things, locks, keys, levels, backups (how protection works). Underneath, it’s a small set of rules over facts. An agent’s ask goes through the same levels as your own things.

Keys are facts, not types.
Every key declares a strength from 1 to 5, where it lives (this device, another device, an object, paper, an email account) and who checks it (your device, or our server). A new kind of key plugs in by declaring its facts.
Levels are rules over those facts.
Easy: the vault was opened recently on this device by a key of strength 3 or more. Just me: this device’s own unlock, now (the PIN is enough). Two devices: Just me, plus a signed approval from another enrolled device of yours. Fort Knox: this device’s strict biometric key (strength 4, not the PIN), plus a security key (strength 5). “Different places” is the independence rule in the EU’s strong customer authentication (SCA).
A thing is as strong as the weakest key that opens it.
A lock is a level and one or more keys that open it, and its strength is computed over every one of them. A weaker key, like the recovery kit, exists only behind a server-held time lock that alerts every device.
The lock guards its own weakening.
Tightening applies at once. Loosening first passes the current lock. A new device or security key is ready at once only when a strong key approves it (a strict biometric or a security key); otherwise after 24 hours, with every device alerted and able to cancel. Codes generated from seeds stored in the vault never help open it.

What we can’t see, and what goes wrong → · The code, coming soon → · The three releases →