The Agentic Stack Just Got Its Payment Layer

A week that changed everything

Last week I wrote about the agentic infrastructure stack forming — Cal.com for scheduling, AgentMail for email, Signbee for signatures. It was a thesis. Three pieces of a puzzle that felt like it was heading somewhere.

Then Stripe dropped MPP.

The Machine Payments Protocol is an open standard that lets AI agents pay for services autonomously. No API keys. No sign-up flows. No billing dashboards. An agent calls an API, the server responds with a price, the agent pays, and the resource is delivered. One HTTP round-trip.

The thesis got its fourth piece — and suddenly it stopped being a thesis.

An AI agent can now research a prospect, send personalised outreach, book a meeting, draft and sign a contract, and process payment. No human. No GUI. End to end.

What MPP actually is: The Return of HTTP 402

I spent yesterday evening reading through the MPP docs and the pattern is elegant. It uses HTTP 402 — the “Payment Required” status code that's been sitting in the HTTP spec since 1997, waiting for its moment.

In traditional web architectures, programmatic access requires accounts, corporate credit cards, API tokens, webhook endpoint registration, and monthly invoice reconciliation. For an autonomous agent spinning up in an ephemeral sandbox to perform a 30-second task, this onboarding friction is a fatal blocker.

The Machine Payments Protocol standardizes the machine-to-machine exchange through a clean five-step loop:

1. Agent issues API call: POST /api/v1/documents/send with contract payload and metadata.
2. Server responds with 402: Returns an X-Payment-Required challenge specifying amount (e.g. 0.50 USDC), recipient address, network, and quote expiry timestamp.
3. Agent verifies quote & settles: The agent signs a settlement voucher using its embedded Tempo wallet (ERC-4337 smart account on Base or Arbitrum).
4. Agent retries request: Dispatches identical payload accompanied by the Authorization: MPP <payment_credential> header.
5. Server validates & executes: Payment gateway atomically clears funds, generates the document signing ceremony, and returns the contract tracking record.

No API keys. No OAuth redirect dances. No account creation forms. The agent pays per action and moves to its next objective.

Inside the Code: Implementing an Autonomous MPP Signing Client

To understand how streamlined this looks in production code, consider an autonomous procurement agent built in TypeScript. When hiring an independent contractor or locking in vendor service terms, the agent handles the 402 challenge dynamically:

import { TempoWallet } from "@tempo/agent-wallet";

interface SignbeeDocumentPayload {
  title: string;
  markdown: string;
  signers: Array<{ name: string; email: string }>;
  metadata?: Record<string, unknown>;
}

export async function dispatchContractWithMPP(
  payload: SignbeeDocumentPayload,
  wallet: TempoWallet
): Promise<{ documentId: string; status: string }> {
  const endpoint = "https://api.signb.ee/v1/documents/send";
  const idempotencyKey = crypto.randomUUID();

  // Step 1: Initial call without upfront payment credentials
  const initialResponse = await fetch(endpoint, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "Idempotency-Key": idempotencyKey,
    },
    body: JSON.stringify(payload),
  });

  if (initialResponse.status === 200) {
    return initialResponse.json();
  }

  // Step 2: Intercept HTTP 402 Payment Required
  if (initialResponse.status === 402) {
    const paymentChallenge = initialResponse.headers.get("x-payment-challenge");
    if (!paymentChallenge) {
      throw new Error("Missing X-Payment-Challenge header in 402 response");
    }

    const { quoteId, amountUSDC, recipientAddress, expiry } = JSON.parse(paymentChallenge);

    // Enforce hard-coded safety guardrails: never allow agent to exceed $2.00 per contract dispatch
    if (amountUSDC > 2.00 || Date.now() > expiry) {
      throw new Error(`Payment challenge outside safety parameters: ${amountUSDC} USDC`);
    }

    console.log(`[Agent] Settling ${amountUSDC} USDC via Tempo wallet for Quote: ${quoteId}`);
    
    // Step 3: Sign on-chain transaction voucher
    const paymentCredential = await wallet.signMicroSettlement({
      quoteId,
      amountUSDC,
      recipient: recipientAddress,
    });

    // Step 4: Retry the request with the payment voucher
    const retryResponse = await fetch(endpoint, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Idempotency-Key": idempotencyKey,
        "Authorization": `MPP ${paymentCredential}`,
      },
      body: JSON.stringify(payload),
    });

    if (!retryResponse.ok) {
      throw new Error(`MPP Execution failed: ${retryResponse.statusText}`);
    }

    const result = await retryResponse.json();
    console.log(`[Agent] Agreement dispatched successfully. Document ID: ${result.id}`);
    return result;
  }

  throw new Error(`Unexpected API response: ${initialResponse.status}`);
}

The Five Layers of the Autonomous Enterprise

When we analyze the agentic economy in late 2026, we see five foundational infrastructure primitives working in concert. Without any one of these layers, the loop breaks and requires human escalation:

Signbee + MPP: Why E-Signatures are the Critical Prerequisite for Payments

Money without a contract is reckless; a contract without money is toothless. In enterprise operations, no corporate CFO allows automated wire transfers without a signed Master Services Agreement (MSA), Statement of Work (SOW), or Non-Disclosure Agreement (NDA).

This is why combining Stripe MPP with Signbee is so transformative. An autonomous procurement agent doesn't just throw funds into a counterparty wallet. Instead, the agent enforces a strict contractual sequence:

• Pre-Execution Phase: Agent generates a vendor agreement in Markdown, specifying deliverables, payment milestones, and dispute jurisdiction.
• Cryptographic Binding: Signbee issues the signing ceremony. Once the vendor signs on their mobile browser or desktop, Signbee generates a tamper-evident SHA-256 digital certificate.
• Event Verification: The agent's runtime server receives the document.completed webhook, verifies the HMAC-SHA256 signature, and stores the audit certificate.
• Conditional Payment Release: With the cryptographic proof safely anchored, the agent authorizes the Stripe MPP payment voucher, releasing funds to the vendor.

If a dispute ever arises, the business holds an immutable court-admissible audit trail linking the IP address, timestamp, document hash, and transaction hash.

And Then DoorDash Happened: The Physical World Bridge

As if Stripe MPP wasn't enough for one week, DoorDash announced they're building infrastructure for AI agents to dispatch human workers for real-world tasks.

Read that again. Agents hiring humans.

The agentic stack just got a physical layer. Agents could already handle digital workflows — emails, scheduling, contracts, payments. Now they can dispatch someone to pick up a package, deliver physical wet-ink documents if a local jurisdiction requires it, or inspect physical equipment. DoorDash is becoming the API between AI and the physical world.

And here's the quiet genius: every completed task generates training data for the robotics foundations that will eventually assist or automate the human executing it. It's a self-funding data flywheel disguised as a gig economy API extension.

Mitigating Risk: Failure Modes in Autonomous Commerce

Allowing autonomous software to sign legal contracts and spend capital introduces obvious operational risks. Engineering teams deploying this stack must implement multi-layered defenses:

What's Next for Signbee: The Native Machine Protocol Roadmap

Short term: MPP integration. We want to be the premier e-signature service in the MPP directory. When an agent needs a document signed, it should find us the same way it finds OpenAI for inference or AgentMail for email — through open protocol discovery, not through a manual Google search and dashboard registration.

We're also shipping native Model Context Protocol (MCP) toolkits and automated llms.txt registries so any agent framework — whether built on LangGraph, AutoGen, CrewAI, or Claude Code — can inspect our capabilities and execute legal signing in a single tool call.

The agentic era isn't coming. It shipped this week. We're building the legal bedrock that lets autonomous systems operate with trust, safety, and velocity.