MPP Phase 2 Live – Ask Tom Goes Agentic

Posted on by

Long blog – First 2 Pages are economic implications, last 6 pages are tech deep dive

MPP is a big deal because value exchange enables specialization and market forces to operate (as discussed in last week’s MPP – Addressing the Internet’s “Original Sin”.MPP and X402 are BIG.. really big. A whole new market. This isn’t about cash replacement or taking share from xx this is about enabling a new Economy. Today’s blog is 4 paragraphs of the economic implications (for investors and CEOs), followed by 4 pages on tech detail covering what I built. Please note “Ask-Tom” is just a model of an x402 service…. of course it won’t generate much demand (service ID is at bottom).

First, let me try to explain why this is such a big deal from an economic perspective. The foundational driver for MPP’s success is the radical reduction of transaction costs through standardized commercial terms. As outlined in my 2016 blog Small Wins, the forces that once drove asset-heavy, integrated organizations are atrophying in favor of “refragmentation” and specialized networks. Historically, the economic cost of inking a bilateral contract for every micro-interaction was prohibitive (ex “Account Creation” bottleneck that stifled agentic autonomy). Following the principles of Ronald Coase’s Transaction Cost Economics, MPP and x402 provide the multilateral governance and common commercial rules necessary to bypass these friction points. By establishing trust and speed through a common interface, these protocols allow for the “Small Win” of a single transaction to scale into a global network effect, where the cost of connection approaches zero.

This standardization enables the “Value Assembly” of “super-specialists” who can target previously unreachable “shale deposits” of niche market demand (see Network Effects and Value Assembly). A successful network enables specialists like “Ask-Tom” to provide high-value, grounded intelligence without the overhead of building independent settlement or reconciliation infrastructure. This is far beyond mere “agentic commerce”; it is an evolution in how software and hardware interact with EVERYTHING ECONOMICALLY. For example, MPP’s session-based economics provides a virtual “bar tab” for agents to execute tasks within human-granted budgets, paying only for precise resource consumption. This creates a sustainable commercial model where the incentives for specialization and market forces to operate on software service at a hyper granular level. Market forces in turn encourage specialists to solve increasingly granular problems across diverse domains, and unlocks the “shale deposits” of data that doesn’t play. I’ll discuss what this could look like next week as a follow up to Value Assembly.

Jeff Weinstein give me a great quote for today’s blog:

Machine-to-machine payments open up new business models for the internet: agents paying for API calls, tokens, data queries, content, and any other service. Like the shift from in-store to online, or from desktop to mobile, Stripe is building the infrastucture and tooling businesses need to thrive in a world where agents are becoming economic actors.
– Jeff Weinstein, Product lead, Stripe

The best way to write about something is to actually do it. I took this approach in building my first MPP/X402 agentic service. Stripe’s Machine Payments Protocol was the driver of all this. I’m familiar with Stripe, which has operated flawlessly for me over the course of 4 years. MPP greatly simplified the agentic task at hand,

Phase 1 focused on building a service that an human could acces (see blog on Phase 1 on “Ask-Tom”.) While no agent (or human) may ever REALLY care to ask me a question, the structure of ask-tom is useful because it models any request for information (think products and prices). Search returns a list of matching results, whereas Ask Tom responds with the answer to your specific question. It operates on a Retrieval-Augmented Generation (RAG – like Google’s Notebook LLM). This RAG is the architectural “brain” that allows the AI to act as a personalized expert on my specific documents rather than just relying on its general training data.

Humans can use the service, but now with MPP and X402, machines could too. Everyone myst understand Stripe is not creating an alternative to X402 and Coinbase, it is not Coinbase/X402 vs Stripe/MPP. Stripe supports both protocols, and both are open standards. Their goal is to help businesses sell to human, business, and now agent customers without dealing with the hassle of understanding the lowest level payment systems. Stripe’s MPP does 3 things for me

  • Commercial Terms, Unified Service, Trust. Stripe resolves the buying machine’s “Account Creation” Bottleneck: MPP allows autonomous agents to pay for services (like API calls, data, or compute) instantly without needing to manually create accounts, manage API keys, or navigate human-centric checkout forms for every new provider they encounter.
  • Network and Efficacy. Standardizes Machine-to-Machine (M2M) Commerce leveraging Tempo and USDC to create the most efficient path to consistent operation. Stripe’s Share Payment Tokens are payment agnostic, but the efficacy of TEMPO and USDC set a pricing floor. HTTP 402 (Payment Required) provides the demand “standard” and universal “handshake” for software to request, authorize, and settle payments in real-time. I could settle with Crypto, but or with the X.402 foundation, but why would I?
  • Real-world accounting and reconciliation. Unified Compliance and Reporting bridges the gap between autonomous “agentic” commerce and traditional business operations. Payments made by agents flow directly into my existing Stripe dashboard. This is HUGE for real world businesses….

I built and deployed a pay-per-query payments intelligence API in a week (phase 1), and made it fully accessible to AI agents using MPP (in 1.5 days). No accounts. No API keys. No subscriptions. An agent sends $1.00 USDC, gets a grounded answer drawn from all of my posts, external references and payments research.

The rest of this post is the heavy tech covering how it works, and attempts to cover what Stripe’s Machine Payments Protocol (MPP) does, and why x402 matters for agent discoverability.

Techie Deep Dive – What Ask Tom Does

Ask Tom is a pay-per-query API. You ask a payments question, pay $1, and get an answer synthesized from my published research — grounded in source citations, not hallucinated. The backend is a RAG pipeline: OpenSearch BM25 retrieval across four indexes (blog posts, external references, knowledge base, industry sources), fed into Claude Sonnet for synthesis.

There are two separate interfaces, by design:

  • /v1/pay — the human interface. A WordPress page with Stripe Elements: enter your question and card, pay $1, answer appears inline. No registration, no token to copy, no redirect.
  • /v1/agent/ask — the agent interface. No UI, no card, no human in the loop. An AI agent sends a POST request, receives a 402 challenge with a USDC deposit address, sends $1.00 USDC on-chain, and retries to receive the answer. Pure machine-to-machine.

The separation is deliberate. These are different customer bases (machine vs human), different trust models, and different payment architectures. They share the same RAG pipeline on the backend but nothing else.

The Role of Stripe’s MPP Toolkit

Stripe’s Machine Payments Protocol (MPP) is the infrastructure layer that makes programmatic, agent-native payments possible without building custom settlement infrastructure. MPP is built around the HTTP 402 status code ( “Payment Required”) which has existed since HTTP/1.1 but was never widely implemented until now. MPP gives it real semantics: a standardized challenge/credential cycle that any MPP-aware agent can understand and respond to.

The MPP toolkit I used is mppx, an open-source server/client library that integrates directly with Stripe. On the server side, it provides middleware that intercepts incoming requests, issues MPP-compliant 402 challenges, verifies payment credentials, and passes through to the handler only after payment is confirmed. On the client side (for agent builders), it provides an Mppx.fetch() wrapper that automatically handles the entire 402 challenge/credential cycle.

Stripe’s role in the payment flow is significant and intentional. When an agent hits /v1/agent/ask without a credential, the server creates a Stripe PaymentIntent in deposit mode. Stripe generates a unique on-chain deposit address for the USDC transfer — one address on the Tempo network, one on Base. Stripe then monitors that address on-chain. When the agent sends exactly $1.00 USDC, Stripe detects the transaction, validates it, and automatically captures the PaymentIntent. When the agent retries with the PaymentIntent ID as a credential, the server calls the Stripe API to verify that status equals “succeeded” before running the RAG pipeline. Stripe then settles the stablecoin payment to the account through its payment rails.

What this means in practice is that there is no self-managed crypto wallet. No private keys to manage. No settlement logic to write. No reconciliation overhead. Stripe owns the entire stablecoin acceptance stack: deposit address generation, on-chain monitoring, capture, and settlement. My server code creates a PaymentIntent, includes the deposit address in the 402 challenge, and checks the PaymentIntent status on retry. That is the complete integration surface.

This is a deliberate architectural choice. The alternative (using x402 natively with a self-managed wallet and the Coinbase facilitator ) gives more control but introduces custody risk, key management complexity, and reconciliation overhead. For a production service accepting real payments, Stripe-managed stablecoin settlement is the right tradeoff: verifiable, reliable, and backed by Stripe’s fraud and compliance infrastructure.

One more practical note: Stripe responded to the MPP program enrollment email request in three minutes. The SDK is production-ready and well-documented. The integration barrier is genuinely low.

The Agent Payment Flow: Step by Step

Here is exactly what happens when an AI agent queries Ask Tom.

Round 1 — The 402 Challenge. The agent sends a POST to /v1/agent/ask with a JSON body containing the question and no authentication header. The server creates a Stripe deposit-mode PaymentIntent and responds with HTTP 402 and a machine-readable JSON body. The challenge contains the PaymentIntent ID, the deposit addresses on Tempo and Base, the exact amount and asset required (1.00 USDC), and an expiry timestamp. The WWW-Authenticate header includes the PaymentIntent ID for MPP-compliant clients.

The on-chain payment. The agent constructs and signs a USDC transfer transaction sending exactly $1.00 — 1,000,000 USDC base units, because USDC uses six decimal places, to the deposit address on whichever network it holds funds on. Stripe detects the confirmed on-chain transaction, validates the amount and token contract address, and advances the PaymentIntent status from requires_action to succeeded. Depending on network confirmation time, this takes a few minutes.

A precision requirement worth flagging for agent builders: the amount of tokens transferred must exactly match the PaymentIntent amount. Stripe cannot match overpayments or underpayments. Because USD and USDC use different decimal precision the agent must calculate the exact USDC base units from the USD amount and construct the transaction accordingly.

Round 2 — The credential retry. Once settlement is confirmed, the agent retries the original POST with an added header: X-Payment-Credential set to the PaymentIntent ID from the challenge. The server calls the Stripe API, confirms the PaymentIntent status is succeeded, and runs the RAG pipeline — OpenSearch retrieval, Claude synthesis, source attribution. The response contains the answer and an X-Payment-Receipt header confirming settlement. The payment appears in Stripe’s dashboard as a standard captured transaction.

Why USDC Only — And Why That Is a Feature

The agent endpoint accepts only USDC. No ETH. No SOL. No other tokens. This is deliberate.

Stablecoins are the natural unit of account for machine micro payments (cards don’t play here). An AI agent managing a payment budget does not want price volatility — it needs predictable, programmatic cost accounting. A $1.00 query needs to cost $1.00 tomorrow and next month. USDC, pegged to USD and issued by Circle with full reserve backing, is the right instrument for this use case.

Stripe’s deposit-mode validation enforces the exact token contract address, so there is no ambiguity about which USDC and chain it must be the canonical contract on Base or Tempo. This specificity is a feature, not a constraint. It removes an entire class of payment failure from the integration.

The two-network approach reflects where agent-native USDC liquidity is concentrated. Tempo is purpose-built for machine payments and is natively integrated with the MPP stack. Base is the broadest USDC ecosystem by volume and agent tooling support. Advertising both networks in the 402 challenge maximises the range of agents that can pay without needing a bridge or swap.

x402 and How Agents Discover the Service

Building the payment flow is one thing. Getting agents to find the service is another. This is where x402 matters.

x402 is an open standard — Apache 2.0, originally developed with Coinbase — that formalises the HTTP 402 payment pattern and provides a discovery infrastructure for paid API services. x402.org and the 402index.io registry are where AI agents, agent frameworks, and developers look for services that accept programmatic payments. The directory is searchable by protocol (L402, x402, MPP), category, price, and health status.

Ask Tom is registered on 402index under the MPP protocol, in the ai/research category, at $1.00 per query. Any agent that queries the directory for MPP-compatible research APIs will find it. The service then advertises its full payment requirements in the 402 challenge itself — deposit addresses, amount, accepted asset, expiry — so a well-built MPP agent can complete the payment and retry without any human configuration or pre-registration.

This is the discovery model the x402 ecosystem enables: permissionless, indexed, protocol-agnostic. No API key request forms. No waitlists. No sales calls. No developer portal sign-ups. An agent finds the service in the directory, reads the 402 challenge, sends USDC, and gets the answer. The entire onboarding cycle is automated.

What This Reveals About the Agentic Commerce Stack

Building this end-to-end clarifies something important that gets lost in the abstract discussion of agentic payments: the trust boundary between human and agent is real, and it determines the payment architecture.

For human buyers, the payment model is card-based, synchronous, and UI-driven. Stripe Elements handles card collection. The PaymentIntent confirms in milliseconds. The answer returns in the same HTTP response. The human never interacts with blockchain infrastructure.

For agent buyers, the payment model is credential-based, asynchronous, and protocol-driven. The agent receives a challenge, executes an on-chain transaction, waits for settlement — a matter of minutes, not milliseconds — and retries with proof of payment. There is no UI. There is no card. There is no account. The agent needs a USDC wallet, the ability to sign transactions, and the ability to parse and act on a 402 response.

These are not the same payment model with a different UX. They are structurally different. Shared Payment Tokens (SPTs) — Stripe’s mechanism for agents acting on behalf of humans using fiat cards — bridge part of this gap for the delegated-authority case. But stablecoin deposit-mode is what enables truly autonomous agent payments where no human card or wallet is in the loop at all. The agent is the buyer, independently, using its own funds.

Stripe’s MPP program — fast enrollment, a production-ready SDK, and fully managed stablecoin settlement — means this infrastructure is available to any developer today. The agentic commerce stack is not theoretical. It is available now, it works end-to-end, and the barrier to building on it is design thinking, not infrastructure.

Ask Tom is live at blog.starpointllp.com/ask-tom. The human interface ($1 per query, card payment) is available now. The agent interface (USDC on Tempo and Base via Stripe MPP) is live and registered on 402index for agent discovery.

Postscript

As an engineer I like to build things. In the late 80s before there was the internet we had ARPANET, it was just a tool for how we communicated to other NASA centers. I was fortunate to have a Sun Sparcstation on my desk on 1989, having only to deal with mainframes and fortran for 18 months. Our first task was to rebuild all the Shuttle simulations running on Fortran to be in C on Unix. Simulations were necessary as it was a tad costly (and risky) to fly the shuttle to test major change. I didn’t like writing software, it was just part of the job. I still can’t believe my Unix and programming skills began in 1988 was 38 yrs ago. 

Having completed my MBA, the big banks were looking at the internet as a channel for banking, banks were throwing money at the problem and my MBA instincts led me away from government work, to where money was flowing. I became “senior technical advisor” to First Union National Bank (FUNB which became Wachova.. Now part of Wells). FUNB had no UNIX, no C, No Oracle, no TCP/IP on their network, no PCs.. and this was 1994. My projects brought all of these in. Not only did we need to build the apps (Smalltalk) but we had to train users how to use a PC and a mouse. 

The speed at which we built applications made the mainframe world look like an ice berg.. Even with all the front loaded challenges of rolling out new network protocols and infrastructure. As my team helped build Cyberbanking (the read only internet bank to see your balance), daily updates and new features and object oriented re-use completely broke the waterfall pattern of mainframe software development. 

After a few successful projects I moved onto Oracle to run new technology for financial services (globally). My team built the first Java apps for Oracle then rolled them out to customers and trained our local teams. The dot com days where like getting wet under a waterfall. The tech of how things connected was making a big shift from RPCs to asynchronous queue (ex IBM MQ) and Java based SOAP to SAML and now to JSON based jwt. 

We are in the midst of a tectonic shift. In all of the above, there was no value exchange within the software components, they were manually designed to operate within a defined UC. We now have a confluence of 3 powerful forces that will completely change software and markets: AI led Software Creation, Value Exchange at a granular level, and Agent Led orchestration and specialization (with minimal human guidance). 

While Google indexed the world’s public data, and anthropic modeled it, there is a vast world of unconnected private data and insights. The value of data (and services that surround it) is based upon use. I’m not going to tell the world I’m on vacation next week, and that signal could be worth $1 to Marriott or $0.001 to McDonalds. To unlock the data we need to understand use and then we need infrastructure to scale the interaction. Stripe just provided the infrastructure. More to come here in my next blog.

MPP Service Details

• Endpoint: https://api.starpointllp.com/prod/v1/agent/ask
• Protocol: MPP (Machine Payments Protocol) via Stripe crypto deposit mode
• Network: Tempo (the only network that supports Stripe deposit mode)
• Payment: $1.00 USDC on Tempo per query — no account, no API key, no signup
• How it works: Agent sends a POST with a question → gets a 402 with a USDC deposit address → pays 1 USDC → resends with X-Payment-Credential: <paymentIntentId> → gets the answer
• Discovery: Listed in https://mpp.dev/services (pending Tempo approval) and discoverable via https://mpp.dev/services/llms.txt

Please Login to Comment.