Agents are beginning to choose vendors for the software they build, but human-oriented signup flows prevent them from accessing most services.
2
auth.md is an open specification built on OAuth standards that tells agents how to register, prove an identity, receive credentials, and understand a service's signup constraints.
3
An agent can use auth.md to register with Cloudflare, receive temporary access through ID-JAG, and deploy an application without a human filling out a form or copying an API key.
Summary
Michael Grinich argues that agent registration is a missing piece of the agent software stack. Agents can run for hours, choose vendors, and build applications, but conventional signup assumes a person can fill out forms, solve CAPTCHAs, verify email, select a plan, and copy credentials. MCP helps agents connect to tools after a human has authenticated, but it does not remove that human step. Grinich introduces auth.md, an open specification that describes how a service accepts agent registrations, which identity proofs and OAuth flows it supports, what scopes or free-tier limits apply, and how a person or organization can claim the account later. In his Cloudflare demo, the agent discovers auth.md, sends an ID-JAG identity assertion, receives a temporary API token, and deploys an app. Grinich also argues that services should let agents start using products before payment, then charge downstream based on usage and the provider's pricing model.
Long-running agents change software work from interactive prompting to delegated execution
Grinich contrasts earlier coding workflows, where a person alternated between prompting an AI model and writing code, with agents that can run for hours or days after a single prompt. Engineers can run several coding agents in parallel, and he says the limiting factor becomes how much context a person can keep in mind. He expects this pattern to spread beyond software engineering. His comparison is autonomous vehicles: once a rider gives a destination, the vehicle handles the driving, and the rider quickly stops thinking about the interface. Agents similarly let people work at a higher level while the system handles planning and execution.
An agent needs a complete harness around the model before it can act
Grinich describes the language model as an engine and the agent harness as the rest of the car. The model provides the intelligence, while the harness gives it a runtime or sandbox, tools, context, feedback, and human review. A sandbox needs to be safe, secure, and performant. Tools let the agent take actions. Context provides information about the project, system, and goals. Feedback lets it check whether its work is correct and continue when it is not. Human review still matters through code review, evaluations, or other checks. Better models therefore require changes to the harness around them.
Agents are already selecting vendors while they build software
When an agent is asked to build a product, it can identify the services it needs, such as a database, deployment system, image or video processing, and email delivery. Grinich says agents are already choosing vendors for these tasks. He points to products whose growth is attributed to agents selecting them for deployment, data storage, or email. This changes the customer a service needs to address. Grinich recasts the startup advice 'make something people want' as also making something agents want, since agents can appear quickly, make decisions on people's behalf, and potentially outnumber people.
Human signup flows block legitimate automated users
Grinich calls agent registration a missing primitive. Web defenses were built after years of harmful automated traffic, including denial-of-service attacks and credential stuffing, so login and signup systems often treat automation as a threat. Existing flows assume a human can read a page, enter an email and password, solve a CAPTCHA, verify email through another link, choose a paid plan, and copy an API key into another system. Agents may not have email addresses or a way to operate a dashboard. A service needs a way to admit legitimate agents while still assessing risk and blocking abusive ones.
Agent-native registration needs identity, capability, and account controls
The registration experience Grinich describes would let an agent discover whether a service accepts agents and what it can do. It would declare registration intent, assess risk, accept an appropriate identity proof, and handle user or organization identity when available. The service also needs to express scopes, entitlements, permissions, credential issuance, auditability, and limits on free usage. Identity may come from a system such as Claude, or an agent may be verified out of band. A human or organization should be able to claim custody later. Grinich says moving from human registration to agent registration affects most parts of the system.
MCP connects agents after authentication but does not solve registration
Grinich supports MCP for providing tools, skills, and context, but says it does not cover the first step of becoming a service user. In a typical MCP authentication flow, a person adds a server to an agent and signs in with their own credentials. The auth.md proposal is aimed at registration without that person initially being involved. It focuses on this narrow step rather than attempting to solve all questions about agent identity, permissions, long-lived connections, and connected services. Once registration is complete, the agent can continue using normal APIs and MCP.
auth.md gives services a standard description of how agents can register
Grinich introduces auth.md as a set of instructions that tells an agent how to become a legitimate user of a service. The file can describe what the service does, which identity proofs it accepts, which OAuth flows are available, and whether registration supports SSO, email, or MFA. It can also describe scopes, entitlements, capabilities, and free-tier constraints. The format is built on existing OAuth-related standards rather than a new authentication system. Grinich presents it as a narrow registration layer, so providers can keep their normal API and documentation after the agent receives access.
The Cloudflare demo completes signup and deployment without a human form
In the demo, an agent notices that a locally running app cannot be shared and looks for a deployment provider that advertises agent registration. It finds Cloudflare's auth.md file and asks to use it. The agent creates an identity assertion and sends it to Cloudflare. Cloudflare verifies it and grants a temporary account, with Grinich describing a possible 72-hour deployment period. The flow uses ID-JAG, which he expands as identity JSON access grant, to return an access token. The agent then uses Wrangler, makes the requested changes, and deploys the app. Grinich says he only approved the agent's actions and did not fill out a signup flow.
Providers can let agents try a service before payment
Grinich says auth.md can let agents use a provider's service immediately, which could help an engineer get back to a running prototype instead of manually signing up for every vendor. The amount of free access should depend on the application. A database service might give a small amount of free traffic, while an email service or a service connected to the physical world might choose to give nothing away. He argues that payment should come after usage. Agents can register, start using a service, and then pay according to the provider's pricing model. He points to x402 and payment-provider work as examples of related efforts.