Most of Your Docs Readers Are Now AI Agents - Hahnbee Lee, Mintlify & Lincoln Murr, Coinbase

Ask an agent to set up Coinbase for Agents. In the example Lincoln Murr, Coinbase’s head of AI product, puts to Hahnbee Lee, the agent finds the docs and follows them on the user’s behalf. Lee is the co-founder and CTO of Mintlify, which powers Coinbase’s developer documentation. She loves design, and there’s a little sadness in realizing that the reader doing the setup may never see the site her team designed.

Page size has a direct cost. Every page the agent brings into its context window takes up some of the space it has to work through the setup. Accuracy matters at the moment of use. If an instruction leads to a dead end, the agent might retry, stop altogether or move on to another product. A small documentation error can lose the integration before anyone asks for help.

Coding agents make it easier for engineering to ship changes faster than the rest of the organization can explain them. Lee still finds the quality of AI-written prose hard to judge. Keeping setup instructions current as the product changes gives automation a more concrete job.

For Coinbase, agents and stablecoins arrived together much as smartphones and 4G LTE did. One gives a user software that can act on a request. The other gives that software a way to move digital dollars. Murr sees an opportunity to build services specifically for agents and a risk to the existing business. If a customer delegates trading or money management, Coinbase needs to give the agent a way to use those services.

Coinbase’s ambition is to make its whole business accessible through APIs. An agent could operate the same browser interface a person uses, but handing it a logged-in financial account raises a separate question. Which operations has the customer authorized? Murr wants programmatic access with authentication and enforceable limits on what the agent can do. His comparison is to mobile banking. He expects people eventually to delegate tasks they now insist on doing themselves, provided the service can enforce those limits.

x402 is the open standard Coinbase developed for making payments as part of an HTTP exchange. Coinbase contributed it to a separate foundation, and the standard accommodates both cards and stablecoins. The particular case Murr makes for crypto is that a business can accept digital dollars across borders, quickly and cheaply, even for very small units of use. His illustrative prices go as low as one-thousandth or even one-millionth of a cent for access to an API, a service or a paywalled page. x402 Foundation launch announcement

Murr reports around 100 million on-chain agent transactions over the preceding year, primarily for API access. The transfers are publicly auditable. Lee asks who is buying what. The agent is the customer. It spends from a wallet to purchase a service when its task calls for one.

Where does a person have to step in when an agent encounters a new paid API? In the familiar setup, someone visits the provider, funds an account, obtains an API key and hands it to the agent. Murr likens this to a grocery store that makes you buy its gift card and join its loyalty program before you can buy groceries. The inconvenience starts over at the next store.

Suppose someone asks Claude to generate an image and it has no existing connection to an image service. With an authorized wallet, it could pay a provider that accepts one-off payments, spending, say, 25 cents for that generation. The user still decides whether the agent may spend money. What changes is whether the user has to be present when the agent discovers which provider it needs.

Paying for a service still leaves the question of how to call it. Lee asks whether to invest in an API, the Model Context Protocol (MCP) or a command-line interface (CLI). In Murr’s design, the API exposes the underlying operation. Two interfaces can then make that operation easier to use in different settings.

• MCP for a natural-language interaction. An MCP wrapper can supply context about the operation so the agent can connect a request in ordinary language to a service call.
• A CLI for a terminal. A command lets the agent invoke the operation from a shell, provided its environment includes a terminal.

Murr favors offering all three. AI-assisted development has made wrappers easier to build, and he considers the choice of agent interface unsettled. The investment they can share is the API that performs the work.

The 25-cent image is a short task. Murr’s longer-term bet is that permission to spend changes how long a task can run unattended. An agent researching overnight might find that the next relevant source sits behind a paywall. If it can buy access, it can use that source while the requester sleeps. Otherwise, the research has to proceed with what is publicly available or wait for the requester.

Forming an LLC is a more speculative example. An agent unable to handle the whole assignment could hire a lawyer and an accountant for the parts that need their expertise. That possibility recalls the original ambition of a decentralized autonomous organization, or DAO. In Murr’s view, earlier DAOs often left a handful of people making the decisions. In the LLC example, software coordinates the work and pays people to take on specific jobs. A crypto wallet supplies a way to establish which funds the software controls.

Back at Mintlify, the case for familiar developer tools comes from both sides of the audience. Developers are early adopters of agents, and agents already work well with Bash and CLI commands. An API gives both a way to use a product even when the person who requested the work never opens its front end.

How much of Mintlify’s audience was already reading this way? Its internal tracker put agents at about 10% of viewership across Mintlify sites at the beginning of the year and closer to 80% by the time of the conversation. The team took bets on where the percentage would go. Even their guesses fell behind.

Lee attributes the shift to agent reading growing much faster while human viewership held up. An agent can spend more time consuming pages than a person can. That helps explain how agents could come to dominate traffic while people still read the docs. It also leaves room for the earlier concern about page size. An agent can read many pages over time and still have limited space for the one it needs during setup.

Does an agent readership imply that agents should write the docs, too? Lee has seen engineers discuss online how they delegate their coding and still write prose for colleagues by hand. She values a human voice in narrative writing. She also remembers being tempted to do product discovery entirely by querying her MCP tools. Talking to people still tells her where they get stuck and what they are trying to accomplish.

A technical update starts with a different set of inputs. A change may span several pull requests, with the reasoning and final decision scattered through Slack. Someone has to find the related pieces, work out what a reader needs to know, write it succinctly and locate the passage in the existing docs where it belongs. Lee sees room to automate that whole job, including the easily overlooked last step of putting the explanation where the next reader will look.

An agent summarizing a decision can draw on the discussion in which people made it. Ask an agent alone what pain point the team should address, and it can invent a plausible one. Murr has found that those answers can send a product team after the wrong priority.

Lee acknowledges that her answer to the build-versus-buy question doubles as a pitch for Mintlify. In enterprise sales she encounters teams that built tooling at a hackathon, proved they could do it and then discovered nobody wanted to maintain it. AI makes the first part easier. The decision for a team buying or building documentation software is who will keep doing the second part, and what else those people could be working on.

Murr points to a specific part of that maintenance bill. Agents change how they crawl sites, and the standards teams use to serve them keep evolving. A specialist can spend its time following those changes across customers. An internal team takes them on alongside its own product. Lee applies the same test inside Mintlify when a new tool looks easy to build. After the hackathon, whose job should it be to keep it working?