How Autonomous Agents Operates

An engineer's technical walkthrough explains how autonomous agents combine three protocols—MCP for tool discovery, A2A for agent-to-agent delegation, and MPP for transactions—as layers of a single stack. The piece details MCP's JSON-RPC handshake and dynamic discovery, A2A's Agent Cards and stateful task delegation, and illustrates the flow with a fintech example where REST endpoints become MCP tools and a support agent delegates fraud review via A2A.

Inside an Autonomous Agent: Discover via MCP, Coordinate via A2A, Transact via MPP An autonomous agent completing a real task rarely uses one protocol — it typically discovers a tool through MCP, hands off part of the work to another agent through A2A. It pays for a service through MPP, all within a single request chain. Tracing that flow end-to-end shows how these three protocols function together as layers of one stack rather than competing standards. Before an agent can act, it needs to know what tools exist and what they do — this is MCP's job. The handshake. Discovery doesn't start with a plain "list tools" call. The client sends a JSON-RPC 2.0 initialize request describing its own capabilities like supportsToolDiscovery and maxToolCount , and the server responds with its own capability set. Only after this mutual negotiation does actual tool enumeration begin. Static vs. dynamic discovery. Once connected, an agent can pull tools three ways: statically defining them in code ahead of time, dynamically fetching the current list at runtime, or using a search function that performs semantic matching over available tools based on the user's actual request. Dynamic discovery matters increasingly in production because it lets a platform update its available tools without repackaging or republishing the agent — the client diffs the current tool list against what it last knew and applies changes automatically. Discovery at scale. In enterprise deployments, an MCP Gateway sits between the agent and multiple MCP servers, filtering which tools an agent can even see based on its identity, workspace, and permission policies — discovery answers "what exists," while a separate authorization step governs "how it can be called". Some gateways go further with a two-step catalog pattern: the agent first calls a lightweight discover tools meta-tool to browse categories and names without full schemas, then calls select tools to scope its session to a specific subset before receiving the full parameter schemas — this keeps context windows small and improves tool-selection accuracy. For a fintech backend, this means your existing REST endpoints — balance checks, transaction lookups — become MCP tools with structured schemas, and any agent yours or a third party's can discover and call them without a bespoke integration per client. Once an agent has tools, complex tasks often require delegating part of the work to another, independently built agent — this is what A2A standardizes. Agent Cards. Every A2A-compliant agent publishes a JSON capability descriptor called an Agent Card at a well-known path: /.well-known/agent.json . This card gives a complete picture of what the agent can do, how to reach it, and what parameters it expects — the equivalent of a service's OpenAPI spec, but designed for another agent to read. Discovery and delegation flow. A client agent first fetches the target agent's card from that well-known URL and uses it to build a connection. When it needs that agent's help, it sends a message containing the task along with session metadata like a session ID and historical context. The receiving A2A server evaluates the incoming message as a Task to complete, rather than treating it as a simple stateless API call. Why this differs from a plain API call. A2A tasks carry state — the receiving agent can report back partial progress, ask clarifying questions, or return a task in an intermediate status, not just a final response. This matters for genuinely long-running or multi-step delegation, like one agent asking a separate logistics agent to "find the fastest delivery route" while a parent workflow waits on updates rather than blocking on one synchronous request. In a fintech scenario, this looks like a customer-facing support agent discovering a specialized fraud-review agent via its Agent Card, delegating a suspicious transaction for deeper analysis, and continuing the conversation once that sub-agent reports back — all without the two systems having been built by the same team or sharing a private API contract. Once the right tool is found and any needed coordination is done, the agent may need to pay for the resource itself — this is where MPP Machine Payments Protocol takes over. The core handshake is HTTP-native. MPP, co-authored by Stripe and Tempo and launched in March 2026, layers payment directly onto standard HTTP requests using the existing 402 Payment Required status code. The full flow runs in a single request cycle with no redirects or webhooks required: GET , for instance to a paid endpoint 402 Payment Required and a WWW-Authenticate: Payment header specifying price, accepted currencies, recipient details, and supported payment methods Authorization: Payment header Payment-Receipt header as proof Beyond one-shot payments. MPP layers four additional primitives on top of that base handshake: recurring subscriptions, streaming metered, continuous payments, cancellation events, and balance reconciliation — all addressed over the same HTTP surface rather than requiring separate billing infrastructure. MCP tools can be monetized directly. MPP explicitly supports paying per MCP tool call — an agent can call a monetized MCP server and pay per invocation without any OAuth flow or account setup, closing the loop between the discovery layer and the payment layer. Discovery of paid services. Just as MCP has tool discovery, MPP has service discovery: providers can advertise their API's payment terms through an OpenAPI-style discovery document, and agents can find paid APIs through directories like the mpp.dev catalog or via MCP servers built specifically for that purpose. Consider an autonomous procurement agent tasked with sourcing the cheapest available freight quote for a logistics shipment: 402 with the price and accepted payment methods; the procurement agent authorizes payment via its available credential, resends the request, and receives a confirmed booking with a payment receipt No human clicked a button anywhere in that sequence, and no single vendor owns the whole chain — MCP handled what tools existed, A2A handled who could help, and MPP handled how the final transaction settled. If you're exposing backend services for agents to consume, the practical build order mirrors this chain: wrap your APIs in an MCP server with clear tool schemas first, since that's the layer with the broadest existing tooling support. If your workflows genuinely require delegating tasks to other independently built agents rather than just calling your own tools, add an A2A-compliant Agent Card. Only add MPP support once you actually need agents to pay for access — it plugs directly into existing payment processors like Stripe's PaymentIntents API with a few lines of code, so it's a late addition rather than a prerequisite.