AgentCard: Virtual Visa Cards for AI Agents (2026)

AgentCard gives AI agents prepaid virtual Visa cards via MCP. Free tier caps cards at $50. Works with Claude Code, Cursor, Cline, and 40+ MCP clients. YC S2026.

AgentCard is an MCP server that gives AI agents their own single-use virtual Visa cards. You approve each card, the agent creates it and pays with it, and it self-destructs after one use. Free plan: $50 per card. Basic plan: $500 per card. Made by Tomorrowland Beta (YC S2026). Works with Claude Code, Cursor, Cline, and any MCP-compatible agent.

AgentCard is an MCP server by Tomorrowland Beta (YC S2026) that lets AI agents issue single-use prepaid virtual Visa cards. Agents call create_card with an amount in cents, receive full card credentials, and pay anywhere Visa is accepted. The free tier caps cards at $50; Basic raises the limit to $500. Works with Claude Code, Cursor, Cline, Windsurf, and 40+ MCP clients.

Maker: Tomorrowland Beta · Protocol: MCP · Auth: token

Compatible agents: Claude Code, Claude Desktop, Cursor, Cline, Windsurf, OpenClaw, Any MCP HTTP client

Required runtime: Node.js >= 18 (for agent-cards CLI), Stripe-connected payment method (for card funding)

About AgentCard

AgentCard is an MCP (Model Context Protocol) server built by Tomorrowland Beta, a Y Combinator Summer 2026 company based in San Francisco, that gives AI agents the ability to issue and spend prepaid virtual Visa cards. Co-founded by Karen Serfaty, who previously led Atlas (an expense card acquired by Remote.com), and Felipe Abello, AgentCard launched publicly in early 2026 and demoed live at MCP Night 4 in May 2026, where an agent paid for an OpenAI subscription entirely from the terminal. The service exposes more than 20 MCP tools covering card creation, balance checks, transaction history, payment method management, checkout autofill, and a conversational buy tool for natural-language purchasing. AgentCard runs as a hosted HTTP MCP server at https://mcp.agentcard.sh/mcp. The Personal tier authenticates via OAuth magic-link email, storing a JWT as the AGENT_CARDS_JWT environment variable. The Companies tier uses sk_test_* and sk_live_* API keys for platforms issuing cards to multiple end-users at scale. All card credentials are encrypted at rest with AES-256-GCM and only decrypted when an agent explicitly calls get_card_details. A human approval checkpoint fires before any card is minted or any charge is authorized, so agents can propose spending but cannot execute it unilaterally. AgentCard works with any MCP-compatible agent, including Claude Code, Claude Desktop, Cursor, Cline, Windsurf, and OpenClaw, and the company claims compatibility with over 40 MCP clients in total. Developers add one JSON config block pointing at the MCP server URL, install the agent-cards npm package, and call get_instructions to have the agent load its own usage guide. Ideal workflows include automated SaaS subscription renewal, API credit top-ups, one-off tool purchases, and e-commerce checkout flows where the agent needs to pay with a card scoped to the exact transaction amount. AgentCard offers a free tier with a $50 maximum per card and a Basic tier with a $500 maximum per card. There are no monthly subscription fees on the free plan; card funding goes through Stripe holds so money is only captured when the card is used. Stripe's standard processing fees apply on top. The Companies tier pricing is available on request for platforms issuing cards at scale. AgentCard is in active development as of June 2026, with the product updates page showing weekly shipping of new features including hold-based funding, real-time authorization webhooks, automatic stale-card cleanup, and a built-in support chat tool. The CLI auto-upgrades itself on each run. The team is building toward fully autonomous agent purchasing workflows that can handle multi-item cart checkout, merchant linking, order tracking, and delivery address management entirely via MCP.

Key Features

• MCP-native card issuance: Agents call create_card with an amount in cents and receive a live Visa card number, CVV, and expiry within seconds, with no custom HTTP integration code required.
• Human approval checkpoint: Every card creation and every charge requires explicit human sign-off before funds move, so agents can propose spending but cannot execute it unilaterally.
• AES-256-GCM credential encryption: Full card credentials (PAN, CVV, expiry) are encrypted at rest and only decrypted when an agent explicitly calls get_card_details, reducing credential exposure in logs or memory.
• 20+ specialized MCP tools: The server exposes tools for card lifecycle management, balance checks, transaction history, payment method management, plan upgrades, checkout autofill, and natural-language purchasing via the buy tool.
• Visa acceptance worldwide: Each issued card is a prepaid Visa accepted at any online merchant worldwide that takes Visa, with no geographic or merchant category restrictions beyond the card's fixed spend cap.
• Test and live mode switching: Developers switch between sandbox and production environments via the set_mode MCP tool, enabling full end-to-end testing before committing real money.

Use Cases

• Automated SaaS subscription renewal: An agent monitors a subscription expiry date, calls create_card with the exact renewal price, then fills the card at the merchant checkout so the developer never shares their real payment credentials.
• API credit replenishment: A coding agent tracks its own remaining API credits, issues a $20 card when the balance drops below a threshold, and tops up its provider account without any human touchpoint beyond the initial approval.
• Natural-language e-commerce checkout: A shopping agent calls the buy MCP tool with a plain-English description such as 'buy a 6-month gym membership', browses linked merchants, builds a cart, and completes checkout with a freshly issued card scoped to the exact cart total.
• One-off software license procurement: A developer agent identifies a missing dependency or tool, purchases a $10 license, and installs it in one terminal session without the developer ever entering payment details manually.

Install

npx agent-cards setup-mcp

Requirements

• Node.js 18 or later installed (npm comes with Node)
• Run agent-cards login to authenticate via magic-link email and generate your AGENT_CARDS_JWT
• Add a payment method via the setup_payment_method MCP tool or Stripe Checkout before creating any cards
• Add the MCP server to your agent config: URL https://mcp.agentcard.sh/mcp, transport HTTP, Authorization: Bearer <AGENT_CARDS_JWT>

Actions

Create Card

Issues a new single-use prepaid virtual Visa card with a fixed spend limit, holding the amount on your saved payment method.

{
  "name": "create_card",
  "arguments": {
    "amount_cents": 2500
  }
}

• amount_cents (number) — required: The card's spend limit in US cents. For example, 2500 = $25.00. Free plan maximum is 5000 (=$50); Basic plan maximum is 50000 (=$500).

List Cards

Returns all virtual cards on the account with their IDs, last four digits, expiry dates, balances, and statuses.

{
  "name": "list_cards",
  "arguments": {}
}

Check Balance

Retrieves the current balance of a specific card without exposing the full card credentials.

{
  "name": "check_balance",
  "arguments": {
    "card_id": "card_abc123"
  }
}

• card_id (string) — required: The unique ID of the card to check, as returned by create_card or list_cards.

Get Card Details

Decrypts and returns the full card number (PAN), CVV, and expiry date needed to complete a payment. May require human approval before returning credentials.

{
  "name": "get_card_details",
  "arguments": {
    "card_id": "card_abc123"
  }
}

• card_id (string) — required: The unique ID of the card whose credentials to retrieve.

Close Card

Permanently closes a virtual card. This action is irreversible and any remaining balance is released back to the payment method hold.

{
  "name": "close_card",
  "arguments": {
    "card_id": "card_abc123"
  }
}

• card_id (string) — required: The unique ID of the card to permanently close.

List Transactions

Retrieves the full transaction history for a specific card, showing merchant name, amount, status, and timestamps.

{
  "name": "list_transactions",
  "arguments": {
    "card_id": "card_abc123"
  }
}

• card_id (string) — required: The unique ID of the card whose transactions to retrieve.

Setup Payment Method

Opens a Stripe Checkout session to save a new payment method (credit or debit card) to the account, which is used to fund future virtual cards.

{
  "name": "setup_payment_method",
  "arguments": {}
}

List Payment Methods

Returns all saved payment methods on the account with their brand, last four digits, expiry, and which one is set as the default.

{
  "name": "list_payment_methods",
  "arguments": {}
}

Get Plan

Displays the current plan (Free or Basic), the per-card spending cap, monthly card usage count, and available upgrade options.

{
  "name": "get_plan",
  "arguments": {}
}

Buy

Conversational purchase tool that accepts a natural-language description of what to buy and handles merchant lookup, cart building, and checkout end-to-end.

{
  "name": "buy",
  "arguments": {
    "description": "Buy a 1-month ChatGPT Plus subscription for $20"
  }
}

• description (string) — required: Plain-English description of the purchase to complete, including the item, quantity, and optionally the target merchant.

Pay Checkout

Creates a new virtual card and immediately fills it into an active browser checkout form in a single atomic operation, minimising the window in which credentials are exposed.

{
  "name": "pay_checkout",
  "arguments": {
    "amount_cents": 4999
  }
}

• amount_cents (number) — required: The exact amount in cents to load onto the card and charge at the checkout form currently open in the browser.

Get Instructions

Returns the current usage guide for AgentCard MCP tools. Call this at the start of any agent session to ensure the agent uses the most up-to-date workflow.

{
  "name": "get_instructions",
  "arguments": {}
}

Get Funding Status

Polls the status of a card creation after the Stripe Checkout payment step, confirming when the card is funded and ready to use.

{
  "name": "get_funding_status",
  "arguments": {
    "card_id": "card_abc123"
  }
}

• card_id (string) — required: The card ID returned by create_card, used to poll whether the Stripe payment has settled and the card is active.

x402 Fetch

Performs an HTTP request and automatically handles HTTP 402 Payment Required responses by issuing a virtual card and paying the requested micropayment amount without human intervention.

{
  "name": "x402_fetch",
  "arguments": {
    "url": "https://api.example.com/premium-endpoint",
    "method": "GET"
  }
}

• url (string) — required: The URL to fetch. If the server returns HTTP 402, AgentCard automatically pays and retries.
• method (string): HTTP method: GET, POST, PUT, DELETE. Defaults to GET.
• body (string): Request body for POST/PUT requests, as a JSON string.
• headers (object): Additional HTTP headers to include in the request.

How to Invoke

Exposed as 20+ MCP tools (create_card, list_cards, check_balance, get_card_details, buy, and more) called by any MCP-compatible agent after registering the HTTP server at https://mcp.agentcard.sh/mcp with JWT Bearer auth.

Pricing

Free plan: $50 max per card, no monthly fee. Basic plan: $500 max per card, upgrade via Stripe Checkout. Companies tier pricing on request. Stripe transaction processing fees apply to all card funding.

Strengths

• Zero integration code required: any MCP-compatible agent (Claude Code, Cursor, Cline, Windsurf) can start issuing cards with one config block and npm install -g agent-cards.
• Spend-cap safety by design: cards are backed by Stripe payment-method holds, so the maximum possible loss from any runaway agent is the card's loaded amount with zero overdraft risk.
• Human-in-the-loop gates: approval checkpoints before each card mint mean developers retain full financial control even as agents operate autonomously across multi-step workflows.
• The only virtual card product in 2026 built natively on MCP, which means agents use standardized tool-calling instead of bespoke REST wrappers.

Weaknesses

• Free tier $50 per-card cap is low: a single $49/month SaaS subscription or a mid-range API credit top-up hits the ceiling and requires a Basic plan upgrade.
• Human approval adds workflow friction: the required approval step before each card creation breaks fully autonomous pipelines and cannot be pre-authorized for specific merchants or amount ranges.
• Beta status as of June 2026: documentation warns to expect rough edges and the API surface has been actively changing, including wallet removal and hold-based funding introduced mid-cycle.
• Self-hosted Docker setup requires managing JWT auth and the AGENT_CARDS_JWT environment variable yourself, adding operational overhead compared to the one-command hosted path.

View the official AgentCard skill page