# How Companies Let Agents Sign Up

Date: 2026-11-18

I read the auth.md of all 18 production services on the WorkOS adopters list. Fourteen let an agent sign up, eight do it anonymously, and anonymous signup is turning into the agent-only free trial.

---

Six months after WorkOS released _auth.md_, the companies listed as adopters have taken it in very different directions. One lets an agent create a full account by solving a captcha. Others use theirs to tell agents clearly that they can't sign up, which is still far better than having no file at all. In between, the pattern that stands out is anonymous signup that a human claims later, which is the agent-only free trial in practice.

I went through every auth.md linked from the WorkOS adopters list to see what each company actually ships, rather than what being on the list implies.

## What is auth.md?

auth.md is an open protocol for agent registration. A service publishes a Markdown file on its domain, usually at `/auth.md`, that tells an agent how to register a user: which flows are supported, which scopes are available, and which endpoints to call. The agent reads the file, follows it, and gets credentials without anyone filling in a signup form.

The protocol defines two main flows:

- **Agent verified.** The agent's identity provider vouches for the user with an [ID-JAG](https://datatracker.ietf.org/doc/html/draft-ietf-oauth-identity-assertion-authz-grant), a signed _identity assertion_, and no human interaction is needed.
- **User claimed.** The agent starts the registration and the human confirms it with a code.

Everything after that is standard OAuth. WorkOS wrote it, but it isn't tied to their infrastructure. Any service can publish a file and any agent can read one.

It's been around since May 21, 2026. WorkOS announced it at MCP Night 4, with Cloudflare and Firecrawl demoing it live.

I wrote about it two days later in [The Agent-Only Free Trial](/blog/the-agent-only-free-trial), when the only thing to go on was the spec. Six months is long enough to see what people actually built.

## The adopters

The [auth.md page](https://workos.com/auth-md) has an "Adopted By" section. More companies than that have shipped one, and WorkOS called out a couple in its one-week follow-up, but I only looked at the ones on the page.

That list had 19 links. I left out agents-txt, which is a reference demo of the spec rather than a production service, and drpr.host redirects to gatedpage.com, so it appears here under that name, leaving 18 companies.

1. **Four of the 18 don't let an agent sign up, and they're still doing something useful.** Resend, Rize and HelixDB publish an auth.md that explains how an agent should handle a key a human already created, or that there's nothing to register with.

   Cloudflare, one of the two companies that demoed it live at launch, publishes a [placeholder](https://www.cloudflare.com/auth.md) saying it's working toward registration, including the ID-JAG flow, but nothing is live yet.

   A clear "no" beats silence. The agent gets an accurate answer quickly instead of hunting for a signup form, can plan its next step properly, and can tell the human exactly what they need to do themselves.
2. **Anonymous is the most common answer.** Of the 14 that do support signup, eight let an agent register with no user identity at all.
3. **Agent verified barely exists yet.** Five companies support it, but the only trusted issuers anyone names are WorkOS itself and ZeroClick's own provider. Cogny says outright that it's waiting for a major provider to start issuing the tokens.
4. **Long-lived API keys are the norm.** The protocol describes short-lived, revocable tokens, but most adopters return a static API key, and several set its expiry to null. Only Polar, Neon, Parallel, ZeroClick and Sendmux's sending token follow the short-lived model.
5. **Nobody agrees on the names.** "Agent verified" and "user claimed" rarely appear in the files. You see `anonymous`, `identity_assertion`, `verified_email` and `service_auth` instead, and several files are custom prose a generic auth.md client couldn't parse.
6. **Three adopters give an agent more than I'd expect.** monday.com has the agent solve a server-side captcha, accept the terms itself, and receive an email, password and API token. Cloudinary gives an anonymous caller a root API secret. The only controls are an IP lock on media delivery (uploads and API calls aren't restricted) and a 24-hour deadline, after which unclaimed content is deleted. Parallel lets a claimed agent top up the account balance against the org's real payment method.

## The details

This table covers every company I looked at, as a snapshot from mid-November 2026. These files change, so check the source before you build against one.

| Company | Agent signup? | Flows | Anonymous? | Credential | Human step |
| --- | --- | --- | --- | --- | --- |
| monday.com | Yes | Anonymous, captcha-gated | Yes, no claim path stated | API token plus email and password | None |
| Cogny | Yes | Anonymous | Yes, key never expires | API key | Consent only |
| Neon | Yes | Anonymous, then claim | Yes, 72 hours | Assertion for short-lived tokens | Device-code claim |
| Polar | Yes | Anonymous, then claim | Yes, one org, money locked | 1-hour OAuth token | Code at claim time |
| Cloudinary | Yes | Anonymous claim, or MCP OAuth | Yes, 24 hours, media IP-locked | Root API key and secret | Email claim |
| Sendmux | Yes | Anonymous, then owner invite | Yes, read-only until approved | Read token plus 1-hour send token | Owner approves sending |
| ZeroClick | Yes | Anonymous, claim, verified, Link CLI | Yes, a few days | Assertion for short-lived tokens | Code at claim time |
| gatedpage.com | Yes | Anonymous, email code, verified | Yes, limited scopes | API key, never expires | Consent or email code |
| here.now | Yes | Email code | Partial, sites last 24 hours | API key | Emailed code |
| Kernel | Yes | Email code | No | API key | Emailed code |
| Parallel | Yes | User claimed | No | Short-lived token, then API keys | 6-digit code |
| Firecrawl | Yes | Verified only | No | API key | Consent |
| Alpic | Yes | Verified only | No | API key, never expires | Claim email after |
| InsForge | Yes | Verified (preview), device flow | No | API key or OAuth token | Consent or device code |
| Cloudflare | Not yet | Placeholder | Planned | n/a | n/a |
| Resend | No | Key-handling guide | No | Dashboard API key | Human creates key |
| Rize | No | MCP OAuth or API key | No | Dashboard API key | Magic-link signup |
| HelixDB | No | None | No | Dashboard key | Dashboard or OAuth |

## Polar gets it right

If you're implementing auth.md and want one file to copy, read [Polar's](https://api.polar.sh/auth.md). It matches the intent of the protocol better than the others and is the most careful about what an unclaimed agent should and shouldn't be able to do.

The whole flow is four calls:

```
POST /v1/agent/identity         # anonymous signup: assertion + claim token
POST /v1/oauth2/token           # swap the assertion for a 1-hour access token
POST /v1/agent/identity/claim   # send the claim token and the human's email
POST /v1/oauth2/token           # poll with the claim grant until the human finishes
```

### No human needed

The agent registers anonymously and gets back an identity assertion, valid for 30 days, and a claim token, also valid for 30 days and returned exactly once. Rather than being the credential, the assertion gets exchanged for an access token that lasts an hour, with no refresh token. When the token expires, the agent swaps the same assertion for a new access token.

Polar is one of the few adopters following the short-lived model the protocol describes. A leaked access token is useless within the hour.

### Gate the risky parts

Before a claim, the agent can create one organization and build out everything an evaluation needs: products, benefits, discounts, files, meters, events, checkouts and checkout links.

What it can't access is anything involving money or other people's data: customers, orders, subscriptions, refunds, payouts, members, webhooks and organization access tokens.

An agent evaluating Polar needs to find out whether it can model a product catalog and generate a checkout. It doesn't need to take a payment or see a customer list to do that. Polar lets it do the first job fully and holds back the second until a human owns the account.

### A clean handover

When the human wants to keep the account, the agent asks for their email and starts a claim. Polar returns a verification link and a code made of three hyphenated words. The agent hands both to the human, who signs in and enters the code. Only someone signed in with that email can complete it.

The link and code last seven days. The agent can start a new claim while the claim token is still valid, which is 30 days from signup.

The agent polls every five seconds and waits five seconds longer if told to slow down.

Once the claim completes, every credential issued before it stops working, including the original assertion. The agent gets a new assertion tied to the human's account. No credential from the anonymous phase survives into the real account.

Error codes like `claimed_or_in_flight`, `claim_expired` and `invalid_claim_token` each tell the agent exactly what to do next, which matters when there's no human reading the response.

**Learning:** Gate an anonymous account on what can cause harm, not on everything, and let the agent do real work inside that gate.

## The agent-only free trial

In that post I argued that agents would soon be signing up for products, building something small with each one, and reporting back on the experience. I thought the sticking point would be signup, and that email verification through an agent's inbox was the likely workaround.

Anonymous signup with a later claim is a better answer than the one I gave, and it feels more agentic. The agent gets a working account immediately and does the evaluation. The email step doesn't disappear. It moves to the end, and it only happens if the human wants to keep what the agent built, which makes the claim the conversion moment.

Each company sets the clock differently:

- **Cloudinary:** 24 hours, then the unclaimed cloud and its content are deleted.
- **here.now:** 24 hours for anonymous sites.
- **Neon:** 72 hours for an unclaimed Postgres project.
- **ZeroClick:** "a few days" for an anonymous credential.
- **Polar:** 30 days on the assertion and claim token, with the gate doing most of the work.
- **Cogny and gatedpage.com:** keys that never expire.

Cloudflare isn't on that list yet, but it already has something close outside auth.md: `wrangler deploy --temporary` deploys a Worker without an account.

A human free trial has typically run 14 or 30 days, because humans need that long. They sign up, get pulled into something else, come back a week later, and need a meeting before anyone commits.

An agent needs none of that, because it reads the docs, builds the integration and logs the friction in a single session. If it can't get somewhere useful in a few hours, the evaluation is already over, and that's a result worth reporting too.

A short clock also keeps unclaimed databases and inboxes from piling up on the provider's bill. It limits what an abusive signup can get away with, too.

A short expiry fits the user, so it isn't stingy. I'd want a clock, a capability gate, or ideally both. A key that never expires and never needs claiming is an open account with nobody responsible for it, not a trial.

## Where to start

Six months in, auth.md works as a shared place to describe how agents get in. The answers in those files are still all over the place. A few companies use it to tell agents they can't sign up yet, which still saves a wasted attempt and keeps the human correctly informed about their options. Verified identity is waiting on identity providers that haven't shown up yet. Most adopters still issue long-lived keys.

The pattern that's emerging is anonymous signup with a human claim at the end. Eight of the 14 companies offering signup support it, each with its own expiry, and Polar shows how to do it carefully: short-lived tokens, a gate on money and customer data, and a claim that revokes every anonymous credential.

If you're adding auth.md to your own product, start there. When I implement it next, I'll have my agent follow Polar's example: let visiting agents in, decide what they can't access, give them a deadline, and make the claim the point where a human takes over.

The free trial is still there. The agent runs it, and the human only shows up to keep the result.

---
Source: https://martyndavies.me/blog/how-companies-let-agents-sign-up.md