# letme

> What letme does today and what comes later. Today an agent asks letme.dev for the best tool for a job, by listing, capability or the job in words, with filters, and letme picks it by a published rule from the Anchor grades and says how to call it direct. Later, calling through letme with one self-issued key at the vendor's own price. How it picks, how it reads a job, what calling will cost, paying per call, selling through it, the letme key, the letme CLI and the disclosure.

- Canonical: https://www.anchorterminal.com/letme/
- Markdown: https://www.anchorterminal.com/letme/index.md (~6,450 tokens)
- Slim: https://www.anchorterminal.com/letme/index.min.md (~1,030 tokens, same facts, less prose, for token-sensitive contexts)
- JSON: https://www.anchorterminal.com/letme/index.json (this page as data, same URL with Accept: application/json)
- Site index for agents: https://www.anchorterminal.com/llms.txt (full text: https://www.anchorterminal.com/llms-full.txt)
- API: https://www.anchorterminal.com/api/v1/index.json
- Updated: 2026-10-04

## What it does

Anchor Terminal grades the tools. letme uses them. Today that means picking. An agent asks letme.dev for the best tool for a job and gets one answer, the listing the published rule picks, with how to call it direct (endpoint, auth, connect snippets, x402 endpoints and the listing's agent notes), one sentence on why it won, the alternatives in the rule's order and the date of the ratings it read.

```text
https://letme.dev/{job in words}    a job, hyphens for spaces (send-an-sms, transcribe-a-phone-call)
https://letme.dev/?q={job}          the same, or POST / with {"job": "...", ...filters}
https://letme.dev/{capability}      a capability id (web.search, db.sql), letme picks the tool
https://letme.dev/{slug}            one listing, by its directory slug (exa-mcp, tavily-mcp)
```

A path that is a slug is read as one, then as a capability id, then as a job in words. Filters narrow the field before the rule runs. `keyless=1` (no key of your own, meaning auth none, an x402 route or anonymous use the record describes), `where`, `kind`, `auth`, `x402=yes`, `pricing`, `max` (the lead unit price in dollars), `minGrade`, `not` (to fall back after a failed call) and `n` for the number of alternatives. When nothing fits, the answer says so and names the best listing without the filters and the filter that ruled it out, because "no keyless tool does data.company, the best with a key is X" is more use than a 404. The same answers come over MCP at `https://letme.dev/mcp`.

Later, calling. The request will name a listing, a capability or a job, and letme will call the tool it picked with the vendor's credential at the vendor's price, then return the result with the Anchor grade of the tool that answered attached, along with what the call cost. Most of this page describes that design, and its future tense is that later part.

At a slug address the call will be the tool's own request. Same tools, same arguments, same results as going direct. At a capability address the request will take the capability's shape and letme will map the arguments onto the tool it picked, with the mapping published per capability so nothing is hidden. The reply will say which tool answered (`Anchor-Served-By`), what it cost (`Anchor-Cost`) and the Anchor grade that tool holds, so the agent can see what it was given and why.

Reading this site is free and needs no key, and so is asking letme for a pick. The directory, the grades, the reviews, the API, the Markdown twins, the MCP server at `https://www.anchorterminal.com/mcp` and letme.dev's picks stay that way. Calling will go through letme, with one key the agent issues itself (below). That's the whole split.

Once calling opens, letme will log method, tool, timing, status class, response size and the calling agent's id, per call, and nothing else. Arguments, results and credentials aren't stored, and bodies stream through. A vendor will see which agent ids used its tool, how often and with what outcome class, never the content of a call.

## How it picks

The published rule is "highest Anchor grade for the capability, then price, compared only between prices whose item names the job, in one unit (the unit most listings at that grade price the job in, usage before plans), then p95 latency, then the Anchor score, then the name". Each step only breaks the ties the one before it left, and `why` in every answer says which step decided.

| Step | Picks | Read from |
| --- | --- | --- |
| 1. Grade | The listings holding the highest Anchor grade for the capability (AA before A before BB, and so on down) | The [published method](/benchmark/), and nowhere else |
| 2. Price | Of those, the cheapest for the job in one unit. Only a price whose item names the job counts (every word of the capability id's last part, plurals and -ing forms included, so "Web Search" for web.search and "JS rendering" for scraping.js-render). The unit is the one most of them price the job in, a usage unit (per 1,000 requests, per minute of audio, per 1M characters) before a plan (per month, per seat), ties to the first unit key alphabetically, and it needs at least two of them priced for the job in it. A listing with no price for the job in that unit comes after the ones with one. A listing priced free with no unit prices counts as $0 for any job. When no two share a unit, price breaks no ties | The vendor's rate card, as the `unitPrices` in each listing's JSON, with each price's `item` |
| 3. p95 latency | Of those, the lowest p95 | The benchmark's probes from London, Virginia and Singapore, which haven't run yet, so this step breaks no ties today |
| 4. Score, then name | The higher Anchor score, then the name, so the answer is the same on every run | The listing's JSON |

Until 2 October 2026 the price step compared each listing's lowest price in any unit, so Spider's $0.0001 per credit beat You.com's $0.005 per call for web.search. A credit isn't a search. Prices are now compared like with like, and letme's `why` names the unit it compared in ("cheaper per 1,000 requests than You.com APIs" for web.search today) or says price couldn't be compared. Comparing like units wasn't enough on its own. Browserbase's cheapest price per 1,000 requests is a page fetch at $0.50 and its search is $7, so our first fix made it the web.search pick on its fetch price. A second try fell back to a listing's cheapest price in the unit when none of its items named the job, and Spider won web.search on "Scrape via x402". So there's no fallback. A price that doesn't name the job is never compared, whatever it costs. A listing whose rate card names its items some other way ("Queries", "Pay as you go", a plan) has no comparable price, and when no two listings at the top grade price the job in the same unit, the tie falls to the score. Some picks are decided that way today, and a vendor that names its prices after the job gets compared on them.

No manual overrides and no paid placement. Nobody at Anchor Terminal Ltd can move a tool up that order by hand, and no vendor can pay to be picked. letme's commercial terms (the partner rate, the free-call allowances, the per-call fee) are never an input to any grade, rank or review. A grade moves when the method says it moves, in public, with the change recorded in the tool's history. A request that names a slug skips the rule and gets that tool. Filters don't change the rule either; it runs over the listings that fit them. With no filters, letme's pick for a capability is the one `/api/v1/capabilities.json` publishes, and letme recomputes every one of those from the tool records as a check.

## How it reads a job

A job in words is matched to a capability without a model or any other service, so the same words always land on the same capability and anyone can see why. The words come from the directory itself (every capability id split into its parts, and each category's name, title and description) and from a small table of the words agents write that the directory doesn't (transcribe, text message, geocode, otp), published at `https://letme.dev/words.json` with the steps and the weights.

Each of the job's words counts once per capability, at its strongest source. A phrase from the table counts most, then the last part of the capability's id, then the first part, then the category's words, then the listings' own text. Category and listing words count for less the more common they are, generic verbs (send, get, make) count half, and the first verb that decides a job (transcribe, translate, scrape) counts half again, so "transcribe a phone call" is about transcribing. The best capability wins, and the margin over the next one sets the confidence (high, medium or low).

Every answer to a job says what letme understood. The capability, the words that matched and through what, the confidence, and when the margin is small up to three other readings with their own picks, so an agent can correct course in one more request. A job that names a listing ("search with exa", "use firecrawl to scrape") gets that listing beside the rule's pick, never instead of it. A job that matches nothing is a 404 with the nearest capabilities and the directory's search.

## What it costs

Picking is free and needs no key. What follows is calling through letme, which comes later.

The vendor's price, and nothing on top. A search that costs $0.007 direct will cost $0.007 through letme. Prices come from the vendor's published rate card or its live `402`, and each call's cost comes back in the `Anchor-Cost` response header and is charged against the agent's balance.

Vendor-funded calls come first. Partner vendors fund an allowance of free first calls for every new key, because a tool that gets tried gets chosen. Those draw down before the balance does.

Top-ups are by x402 with USDC on Base or Solana, in one round trip (next section). Operators who prefer an invoice will fund a key from the vendor portal with a card and can set a monthly cap per key. Failed calls aren't charged. A `429` isn't charged. A `5xx` from the vendor isn't charged.

A tool without a partner agreement will still work through letme with the agent's own credential in the `Anchor-Upstream-Authorization` header, forwarded per request and forgotten. Those calls will be free up to 10,000 a month per key and $0.001 each after that, plus the tool's own x402 price where it has one.

What Anchor Terminal Ltd earns is 15 per cent of what partner vendors bill through letme, paid by the vendor at the end of the month. The agent never pays a markup. The vendor pays for the introduction instead.

| Who | Pays | For |
| --- | --- | --- |
| The agent | The vendor's own price per call, from its balance, after any vendor-funded free calls | Every partner tool it calls |
| The agent | $0.001 per call past 10,000 a month per key, plus the tool's own x402 price if any | Calls with its own credential to tools that aren't partners |
| The vendor | 15% of billed usage, monthly | Being reachable by every letme key on day one, and the usage view |
| Nobody | Nothing | Reading this site |

## Paying per call

An agent won't pay forty tools. It will pay letme once, and letme will pay the tools.

The agent holds one balance with letme instead of a drawer of keys and a wallet per vendor. Funding it is one x402 round trip. The top-up request answers `402` with a `PAYMENT-REQUIRED` header, the agent signs a USDC transfer on Base (`eip155:8453`) or Solana mainnet, retries with `PAYMENT-SIGNATURE`, and the `200` carries `PAYMENT-RESPONSE` with the transaction. The amount sent is the amount credited, no fee. From then on letme will be the payer. Each call will draw the vendor's price from the balance, and for tools that sell over x402 directly, letme will settle the tool's own `402` on the agent's behalf at the tool's price.

Terms are x402 v2, the `exact` scheme, USDC on Base or Solana mainnet, settled through the Coinbase CDP facilitator. letme's `402` responses will carry the `bazaar` extension so the top-up endpoint gets indexed. Nobody needs to hold ETH or SOL (the facilitator pays gas). The header formats, step by step, are on the [x402 page](/x402/#the-flow-precisely). None of this takes money yet.

## For vendors

Selling through letme has no effect on your grade.

A partner listing is how an agent reaches your tool through its letme key without ever seeing your signup form. You issue letme a scoped credential, you set the price (the same one an agent would pay you directly, letme will add nothing), and you decide whether to fund an allowance of free first calls per new key. You pay 15% of billed usage at the end of each month, and nothing until then. Listing stays free, claiming stays free, and the score doesn't know or care whether you're a partner.

What you get back is the usage view your own logs can't produce. Which agent ids called you, how often, the outcome class of every call, where the errors clustered, which of your tool descriptions made a small model pick the wrong tool, and how you compare with the other tools in your capability. Never the arguments or results, which aren't stored. It's the audit, running continuously, paid for by the calls it brings you.

Tools that take x402 directly don't need any of this. letme will pass those payments through at your price and take nothing until you opt into the partner rate. Tools that would rather not partner stay listed and reachable direct, and agents can bring their own credential through letme.

Partner listings open when calling through letme does. Until then, claiming, manifests, disputes, reports and audits are on the [builders page](/builders/).

## The letme key

One self-issued key, when calling opens (picking needs none). The agent will generate an Ed25519 keypair, post the public half with a handle, the harness it runs in and optionally its operator's domain, and get back one key that works on every partner tool at the vendor's price. No email, no card, no browser. Key creation will be rate-limited per address, and the address that issues keys is published when they're issued.

The request body, as specified.

```json
{
  "publicKey": "MCowBQYDK2VwAyEA5c7rQ3...",
  "handle": "scout-4",
  "harness": "in-house Go research harness",
  "operator": "example.com"
}
```

The reply.

```json
{
  "agent": "ed25519:7f3a9c1e2b...",
  "key": "ak_live_9Xm3...",
  "tier": "unverified",
  "limits": { "requestsPerSecond": 5, "concurrent": 4 },
  "credits": { "balanceUsd": 0, "vendorFunded": [ { "tool": "exa-mcp", "calls": 200 }, { "tool": "firecrawl-mcp", "calls": 100 } ] }
}
```

The `agent` id is the RFC 7638 thumbprint of the public key, the same id that signs reviews. The `key` is a bearer secret for clients that can't sign requests. Keep one or the other.

Two ways to authenticate, pick the one your client supports. Bearer is `Authorization: Bearer ak_live_...` on every request, and works with any HTTP client and any MCP client that can set a header. Signed is RFC 9421 HTTP Message Signatures with the Ed25519 key over `@method`, `@target-uri`, `content-digest` and `created`, with `keyid` set to the agent id, `alg="ed25519"` and `tag="anchor"`. No secret leaves the process, replay is bounded by `created`, and it's the same mechanism as Web Bot Auth, so a harness that can sign for Cloudflare can sign for letme. Signed requests count as stronger identity and get the higher limits below.

An MCP client pointed at one listing, with a bearer key.

```json
{ "mcpServers": { "exa": { "url": "https://letme.dev/exa-mcp", "headers": { "Authorization": "Bearer ak_live_9Xm3..." } } } }
```

Clients that only speak OAuth will get an OAuth 2.1 authorisation server with dynamic client registration, where the one-time login is pasting a letme key. That path exists for interactive desktop clients and isn't the one we'd point an autonomous agent at.

| Tier | How | Requests per second | Free calls | Balance cap |
| --- | --- | --- | --- | --- |
| Unverified | Any key | 5 | Vendor-funded allowances | $20 |
| Signed | RFC 9421 signatures with your key | 20 | Vendor-funded allowances | $200 |
| Verified operator | Public key listed in your operator's `/.well-known/http-message-signatures-directory` | 100 | Larger allowances, set per vendor | Per agreement |

A verified operator is a domain that publishes its agents' keys the Web Bot Auth way. It's the same directory that gets your reviews shown with an operator name, so publishing it once does both jobs. A leaked bearer key is capped by its balance and its per-second limit and can be rotated with one call. A leaked private key can't sign anything once the public key on the agent record is rotated.

## letme CLI

Today's binary is `anchor`. It reads the directory, checks servers and signs reviews, and it calls no tool. One static file, no key, `--json` on every command. Builds for Linux, macOS and Windows on amd64 and arm64 are at `/dl/index.json` with their SHA-256 sums, also at `/dl/SHA256SUMS`, or build it with `go build -o anchor ./cmd/anchor` from the site's source, which needs Go and nothing else.

```bash
# Linux on x86-64. For other systems swap the suffix: linux-arm64, darwin-arm64, windows-amd64.exe
curl -fsSLO https://www.anchorterminal.com/dl/anchor-linux-amd64
curl -fsSL https://www.anchorterminal.com/dl/SHA256SUMS | sha256sum -c --ignore-missing
chmod +x anchor-linux-amd64 && mv anchor-linux-amd64 ~/.local/bin/anchor
anchor version
```

The commands people use most.

| Command | What it answers |
| --- | --- |
| `discover <capability>` | Which listings can do this, best first. Takes an id (`web.search`) or a word (`scrape`). `--agent-ready`, `--remote`, `--min-grade A`, `--x402 yes`, `--limit`. |
| `search <words>` | Listings that match every word, closest match first and then by score. |
| `tool <slug>` | One listing, grade, rank, verdict, endpoint, auth, pricing, how to connect. `--slim` is the cheapest full description we publish. |
| `compare <a> <b>` | Two listings dimension by dimension, with an arrow on the better score. |
| `prices` | Model prices per million tokens, cheapest blended first. `--unit 1k-requests` for everything else, `--under 2` to cap. |
| `sunsets` | Dated shutdowns, breaking changes and price changes. `--next 60d`, `--tool`, `--kind`, `--ics`. |
| `live [slug]` | Up or down now, 24-hour and 30-day uptime, latency, latest releases. |
| `changes` | What the workers noticed. `--since 7d`, `--slug`, `--kind possible-sunset`. |
| `check <url>` | An MCP server's tool list the way an agent meets it. `-- <command>` for a stdio server, `-H` for credentials. Every rule is on [/check](/check). |
| `key`, `review`, `verify`, `retract` | Your Ed25519 key, and signing, checking and taking back a review. |
| `page <path>` | Any page on this site as Markdown, or `--slim`, `--json`. |

Every command takes `--json` and prints the API's own response (`ANCHOR_FORMAT=json` makes that the default). Exit codes are `0` success, `1` a network or server error, `2` a usage mistake and `3` not found, so a script can tell "no such listing" from "the network is down". `ANCHOR_API` or `--api` points it at another host. Nothing needs a key, and nothing is sent except the request itself and a `User-Agent` naming the CLI and its version. `anchor help <command>` lists a command's flags.

When calling through letme opens, the letme CLI will add it. A key made and funded from the terminal, a `discover` that ends in a call, and the result with the grade attached, in the same tables and the same `--json`.

## The disclosure

Same company, same founders. Anchor Terminal and letme are both run by Anchor Terminal Ltd, by the people who built the benchmark. One grades, the other routes on the grades, and they share a bank account. We'd rather say that plainly than have someone find it.

The separation, as rules.

- letme picks by a published rule, highest Anchor grade for the capability, then price, compared only between prices whose item names the job in one unit, then p95 latency, then the Anchor score, then the name. No manual overrides and no paid placement.
- letme's commercial terms are never an input to any grade, rank or review. Grades come only from the [published method](/benchmark/).
- letme is graded in the directory like any listing, under the stricter rule for our own products on the [benchmark page](/benchmark/#own), with a founder disclosure ([its listing](/tools/letme), `own: true` in its JSON). letme never picks the directory's own products, itself and LocalGhost, whatever their grades. Asking letme.dev for `letme` or `localghost` gets a `404` that says so.

If a grade ever looked like it was moved to send calls somewhere, anyone can check, because the score arithmetic is public, every deduction has a date and a source, and every dispute is answered in public. That's the same answer the [about page](/about/#two-names-one-company) gives for audits, and it's the only one we have.

## Status

Picking works today. letme.dev answers every one of its addresses with the listing the published rule picks and how to call it direct. `https://letme.dev/send-an-sms` for a job in words, `https://letme.dev/web.search` for a capability, `https://letme.dev/exa-mcp` for one listing, with filters on all of them, `https://letme.dev/llms.txt` as the index and `https://letme.dev/mcp` the same over MCP, with an OpenAPI description, an Agent Skill and the word table beside them. letme runs as its own service and reads nothing but the directory's public JSON (`/api/v1/tools.json`, `/api/v1/capabilities.json` and `/api/v1/categories.json`), so every pick it names can be recomputed from those files, and it recomputes them itself as a check.

Limits. Each IP address can ask 20 times a second, with bursts of up to 40. Over that, letme.dev answers `429` with `Retry-After: 1` and `{"error": "rate_limited"}`, and while it restarts or loads the ratings, `503` with `Retry-After`. Nothing is billed, so a retry costs nothing but the wait.

Uptime. `https://letme.dev/status` says how letme.dev is right now: whether it has ratings to pick from and how old they are, whether its own run of the rule agrees with the directory's picks, and how long it's been up. Uptime by day and every outage in the last 90 days, from probes every five minutes, are on the [status page](/status/). Security reports go to the contact in `https://letme.dev/.well-known/security.txt`, the same as this site's.

Calling doesn't. Nothing on letme.dev calls a tool, issues a key or takes a payment, and every answer says so (`calling.open` is false, and `live` stays false for older clients). An agent calls the pick direct with the details letme hands it, which are the same connection snippets every [tool page](/tools/) carries. When calling opens, `/api/v1/index.json` will say so, the capability list will start carrying free-call allowances per tool, and this page loses its "calls later" label. Progress goes in the [changelog](/changelog/).

To hear when calling opens, join the waitlist.

The form on the HTML page joins the letme waitlist. The same from an agent is `POST https://www.anchorterminal.com/api/v1/contact` with JSON `{"kind": "waitlist", "product": "letme", "email": "…"}` (optional `message`, at most 500 characters), or the `contact` tool at `https://www.anchorterminal.com/mcp`.

## What we haven't settled

Whether 15 per cent is the right cut. Whether unverified keys should get any vendor-funded calls at all before the first abuse report teaches us otherwise. Whether the OAuth path is worth keeping for clients that can't set a header (I think not, and we'll keep it only as long as a large client needs it). Whether the binary gets a new name or `anchor` learns to call. And whether mapping arguments per capability holds up for anything beyond search, where the argument names differ in ways that are mechanical. Whether the word table holds up past the jobs we wrote it against; the first month of real jobs will show which words we missed, and the table is public so anyone can tell us sooner. We'll find out from the first month of traffic, not before.

### Why would a vendor let letme hold its credential?

Because the alternative is an agent that never tries the tool. Partner vendors issue a scoped credential, set the price, and see every call's outcome class by agent id. They can revoke it in one place. A vendor that would rather not can still be listed and reached direct, and agents can bring their own credential.

### Isn't a bearer key just another secret to leak?

Yes, which is why the signed path exists and gets the better limits. A leaked bearer key is capped by its balance and its per-second limit and can be rotated with one call. A leaked private key can't sign anything after you rotate the public key on your agent record.

### What stops someone minting a thousand keys for the free calls?

Rate limits on key creation, small allowances for unverified keys, larger ones only for signed and verified-operator keys, and vendors set their own allowance and can set it to zero. We expect to tune this from the first abuse report rather than guess it right first.

### Does letme replace x402?

No. Tools that take x402 directly keep doing so and letme will pay their `402` at the vendor's price. The key is for the much larger set of tools that only have an API key or OAuth, and for harnesses that would rather hold one balance than forty.

### Can a vendor pay to be picked?

No, because there's nothing to pay for. The order is the grade, then the price for the job in a unit the tied listings share, then the p95, and the grade comes from the published method. A partner pays 15% of what it bills, and the benchmark never sees that number.

### Does letme add latency?

Calling through letme isn't open, so today it adds nothing; you call the pick direct. Once it opens, one hop, in the same regions as the probes. Budget 10 to 30 ms. The p50 and p95 numbers on tool pages will be measured upstream of letme so the tool is judged, not us.