The Agent Payments Market Just Split in Two: Here's Why Architecture Matters

This month, the agent payments space stopped being theoretical.

Visa integrated its payment network into ChatGPT. Mastercard announced agent spending capabilities. Catena Labs closed a $30M Series A to build what they're calling an "AI-native bank" and filed for a national trust bank charter.

Three $30M+ funding rounds. Multiple Big Tech integrations. The market just became the main event.

But here's what's interesting: the market is splitting into two camps with fundamentally different architectural bets.

The Two Camps

Camp One: Big Tech Retrofitting Card Rails

Visa and Mastercard are extending existing card infrastructure to agents. Give ChatGPT a virtual card. Let it shop and pay on your behalf. Use existing fraud protection, chargeback systems, and compliance rails.

It works. It's pragmatic. It gets agents transacting today.

Camp Two: Crypto-Native Key Custody

MetaMask launched an agent wallet with built-in security controls. Catena is building banking infrastructure from scratch for agentic finance. Sui released a wallet security prototype. These players are tackling the key custody problem head-on.

The architectural bet: agents need their own wallets, not access to human payment rails.

The Problem Both Camps Are Dancing Around

A CryptoRank poll this week asked users if they trust AI agents with wallet keys. The results were split almost evenly.

That's not noise. That's the market bottleneck surfacing publicly.

The custody problem IS the agent payments problem.

Cards solve this by keeping agents out of the loop entirely. The human authorizes, the card processes, the agent just triggers the flow. No keys needed because the agent never actually controls money.

Crypto wallets solve this by giving agents keys and hoping security controls are enough. The agent holds the private key, and we layer on spending limits, allowlists, and policy engines.

Both approaches compromise.

MPC Makes It a False Dilemma

Multi-party computation changes the equation entirely.

With 2-of-3 threshold signing, an agent can authorize and execute a payment without ever holding the full private key. One shard lives with the agent. One with the user's device. One with the infrastructure provider.

The agent acts autonomously. But it cannot act alone.

This isn't a security feature layered on top of a wallet. It's a different trust architecture.

// Agent initiates payment
const payment = await agentWallet.initiatePayment({
  recipient: "merchant.eth",
  amount: "10.00",
  currency: "USDC"
});

// MPC threshold signing
// Agent's shard + policy engine shard = authorized
// No full private key ever assembled
// Authorization completes in <150ms

await payment.execute();

Cards were designed for humans with fraud protection and chargebacks. MPC wallets were designed for agents with threshold cryptography and policy enforcement.

Where the Architectural Bets Differ

Catena is solving custody at the banking layer. They're building a regulated trust bank that can hold agent funds under a charter. The bet: agents need banking infrastructure, not wallet infrastructure.

Visa and Mastercard are solving it at the card layer. The bet: existing payment rails can be extended, and agents don't need to own money—they just need to move it.

We're solving it at the wallet layer. The bet: agents need to own their payment instruments, and MPC makes that possible without key exposure.

Different layers. Different trust boundaries. Different trade-offs.

Why This Matters for Builders

If you're building an AI agent that needs to pay for API calls, book services, or transact autonomously, your architecture choice has second-order effects.

Card-based solutions introduce latency (network authorization), compliance overhead (the agent acts on behalf of a human), and limited programmability (card rails weren't built for sub-dollar micropayments).

Key-custody solutions introduce security risk (key exposure), regulatory complexity (who's liable?), and trust problems (users are split on this for good reason).

MPC-native solutions introduce technical complexity (threshold signing isn't simple) but unlock authorization in under 150ms, native micropayment support, and agent ownership without key exposure.

The Market Is Validating the Problem

The fact that Big Tech, crypto infrastructure players, and well-funded startups are all racing into this space validates the core insight: agents need to pay, and existing infrastructure wasn't built for them.

That's good. Competition clarifies architecture.

The question isn't whether agents will transact. They will. The question is what trust model we build that transaction layer on.

Cards were built for humans. MPC wallets were built for agents.

Not as a slogan. As an architectural fact.

AgentWallex is the payment gateway for AI agents, powered by MPC. 3,600+ teams on the waitlist. Sandbox live at app.agentwallex.com.