Hahnbee Lee and Lincoln Murr on Documentation and Payments for AI Agents

Hahnbee Lee, co-founder and CTO of documentation platform Mintlify, and Lincoln Murr, head of AI product at Coinbase, discuss what changes when AI agents use a company's products and documentation. They focus on agent-readable docs, APIs, payments and the continuing role of human judgment.

Murr offers a concrete scenario: a person asks an agent to set up Coinbase for agents, and the agent finds the documentation and carries out the work. What matters in documentation when the reader is software acting on someone's behalf?

Lee says documentation used to place more emphasis on visual design and the front end. She still values design, but an agent may not see the branding at all. Page size and the amount of context consumed can become more consequential when software is reading and navigating the material.

Accuracy matters too. Lee says that if an agent hits a point of friction while following documentation, it may stop, repeatedly try unproductive approaches, or move to another product. She sees keeping documentation current as an important opportunity for automation, even as she is still working out how to judge the quality of AI-written material.

Murr describes the simultaneous rise of AI agents and stablecoin payment infrastructure as both an opportunity and a competitive risk. Coinbase is considering products built specifically for agents as well as ways to make its existing trading and money-management services accessible to them.

For Murr, the common layer is the API: expose functionality in a way an agent can use, rather than relying only on browser interaction. Financial access also requires authentication, limits and other safeguards. He explicitly says users should not give an agent unrestricted access to an account.

He compares the shift to the earlier move from web services to mobile apps. His prediction is that agents will eventually handle far more financial interaction on a person's behalf, but the analogy also makes clear that the required safety controls have to be built for this new mode of use.

Asked what crypto adds, Murr points to digital-dollar payments and x402, which he describes as an internet-native payment standard governed through a separate foundation. He argues that small, one-off payments could help agents purchase access to APIs or services without a separate funded account for each one.

Murr says there have been around 100 million on-chain agentic transactions in the past year, largely involving API access. That is his reported figure, not an independently verified measure in the conversation. He presents it as evidence of early adoption among people experimenting with agent payments.

In the existing workflow, a user often signs up for a service, funds an account, obtains an API key and gives it to an agent. Murr compares this to having to buy a store-specific gift card and join a loyalty program before shopping. An agent with an appropriately authorized payment method could instead pay a service for a single use.

His proposed benefit is autonomy: an agent asked to generate an image, for example, might discover and pay for an appropriate service even if it did not already have an integration. The same discussion makes the limits important: more ability to spend also makes the scope of the user's authorization and financial safeguards consequential.

On API versus MCP versus CLI, Murr treats the API as the underlying access layer. MCP can add context for a natural-language interaction; a command-line interface offers another route but needs a terminal. He sees these as different interfaces over service capabilities and expects the tradeoffs to keep evolving.

Looking ahead, Murr suggests that an agent authorized to pay for information could conduct deeper research over a longer period. He also imagines an agent helping set up a company by paying a lawyer or accountant when human expertise is needed. These are proposed future workflows, not a claim that such tasks are already reliably autonomous.

Murr relates this vision to the earlier idea of decentralized autonomous organizations: automation at the center with people at the edges. Lee says she is curious about how ideas developed in crypto might be applied as AI capabilities improve, while noting that she does not consider herself a crypto expert.

Lee agrees that APIs are increasingly important. Developers are early adopters, she says, and today's coding agents are comfortable with code, shell commands and command-line tools. For software companies, investing in programmatic access can make services available to those agents as well as to human developers.

Lee reports that the share of agent traffic across Mintlify documentation sites grew from roughly 10% at the start of the year to around 80% at the time of the conversation. She says human readership was not falling; the shift reflected much faster growth in agent traffic. The figures are Mintlify's reported observations in the talk.

She suggests one reason for the increase: agents can ingest much larger volumes of content than a person typically has time to read. The change affects how businesses think about the people—and software—using their products, although the speakers are still working out what the long-term balance will be.

Murr asks whether documentation will always need a human touch or whether more of its production can be automated. Lee distinguishes creative or narrative prose, where she values human writing, from some of the mechanical work involved in technical documentation.

Lee also warns against replacing conversations with people just because an agent can summarize information. In product work, she says, teams still need to speak to users and understand their actual pain points. Murr agrees that relying only on an agent for product insights can introduce hallucinations and lead a team to prioritize the wrong things.

For technical documentation, Lee sees room to automate the collection of relevant pull requests, discussion context and decisions, then produce a concise update and identify where it belongs in the existing documentation. That proposal separates gathering and organizing information from the human work of discovering what users need.

Asked about a common pitfall, Lee turns to the build-versus-buy decision. She argues that teams should account for ongoing maintenance, not only the initial effort of building a tool. A hackathon project may work as a prototype but still need an owner who will keep it current as standards and user needs change.

Her recommendation is to focus on a company's main value proposition and decide deliberately which supporting systems the team wants to maintain itself. Murr adds that agent interfaces and crawling practices are moving quickly, making continuous maintenance a real part of the choice. Both speakers present this as a tradeoff, not a rule that every team must buy software.