---
title: "Build a neobank with AI agents: BlindPay's CLI, MCP server, and Agent Skills"
seoTitle: "Build a neobank with AI agents: CLI, MCP, Agent Skills"
description: "Use AI coding agents to build and run a neobank's payment flows: BlindPay's CLI, MCP server, Agent Skills, prompts, a task map, and guardrails."
date: "2026-10-25"
updated: "2026-10-25"
category: "payments"
author: "BlindPay Team"
howto:
  name: "How to set up an AI coding agent to build neobank payment flows on BlindPay"
  steps:
    - name: "Create a development instance"
      text: "In the BlindPay dashboard, create a development instance. Its payments settle with USDB, a test stablecoin on testnets, so no real money moves while the agent works."
    - name: "Connect the hosted MCP server"
      text: "Add https://mcp.blindpay.com/mcp to your agent, sign in with your BlindPay account, and pick the development instance. No API key is pasted into the client."
    - name: "Load Agent Skills"
      text: "Run npx skills add blindpaylabs/skills so the agent knows BlindPay's rails, corridors, fees, and API patterns before it writes code."
    - name: "Start from a prebuilt prompt"
      text: "Paste the payin or payout quickstart prompt from the Build with AI docs, then describe your app's screens and stack."
    - name: "Review and test the generated code"
      text: "Read every money-moving route the agent writes, run the full loop on the development instance, and test failed and refunded payouts."
    - name: "Switch production access to read-only first"
      text: "For production operations, start agents on https://mcp.blindpay.com/mcp/readonly and keep human confirmation on every payout."
faq:
  - q: "Can an AI agent build a neobank?"
    a: "An AI coding agent can write most of the payments integration: backend routes, webhook handlers, ledger entries, and test scripts. It can't do the regulated or human steps, such as choosing a licensing path, signing partner contracts, creating instances and API keys, onboarding your company, or a user accepting terms. Treat the agent as a fast engineer on a development instance, with a person reviewing every money-moving change."
  - q: "What is an MCP server in payments?"
    a: "An MCP server exposes an API as tools that an AI agent can call through the Model Context Protocol. BlindPay's MCP server lets agents such as Claude, ChatGPT, Codex, Cursor, and VS Code create quotes, execute payouts, manage customers, generate virtual accounts, configure webhooks, and check transaction status in response to natural-language requests."
  - q: "What are Agent Skills?"
    a: "Agent Skills are a lightweight open format for packaging knowledge and workflows an agent can load. BlindPay's Agent Skills teach an agent its rails, corridors, fees, and API patterns, so generated integrations are correct on the first pass. Install them with npx skills add blindpaylabs/skills and use them next to the MCP server."
  - q: "Is it safe to let an AI agent send payouts?"
    a: "Only with guardrails. Start on a development instance, use the read-only MCP endpoint for production exploration, and require explicit human confirmation before any payout. BlindPay's tools carry read-only and destructive annotations so clients can ask before running anything that is not a read, but the server does not block a call on its own, so the confirmation step belongs in your prompt or app flow."
  - q: "Do I need an API key to connect an agent to BlindPay?"
    a: "Not for the hosted server. With https://mcp.blindpay.com/mcp you sign in with your BlindPay account and choose which instance the agent may use, so no key sits in the client config. For hosts that only run local servers, or for CI, the npm package @blindpay/mcp runs with an API key and instance id set as environment variables."
  - q: "Which AI app builders work with BlindPay without MCP?"
    a: "Builders that generate code but don't host MCP tools, such as Lovable, v0, Bolt, and Replit, call the BlindPay REST API from a backend route or server action. You paste a prompt describing the function, store the API key and instance id as secrets, and keep every BlindPay call on the server, never in client code."
---

AI coding agents can build most of a neobank's payment flows today: they write the backend routes, webhook handlers, and tests, and they can run payments against a test instance while they work. BlindPay gives agents four surfaces for this: an MCP server, a CLI, Agent Skills, and prebuilt quickstart prompts, plus the REST API for app builders that don't host tools.

What agents can't do is the regulated and human part of a neobank. This guide shows how to split the work, which surface fits which task, and the guardrails that keep an agent away from real money until you want it there. It belongs to the series on [how to build a neobank](/resources/more/how-to-build-a-neobank).

**Key takeaways**

- Agents are good at integration code, tests, and ops lookups. People keep licensing, contracts, approvals, and production payouts.
- Connect the hosted MCP server at mcp.blindpay.com/mcp: you sign in and pick an instance, no API key in the client.
- Use the BlindPay CLI when the agent works in a shell: every command takes --json, and blindpay schema lists every field.
- Load Agent Skills so the agent knows rails, fees, and API patterns before it writes code.
- Build on a development instance, where payments settle in a test stablecoin and no real money moves.
- Keep a human confirmation on every payout. The server marks destructive tools; your flow has to enforce the stop.

## What can an AI agent actually do in a neobank build?

It can write and test the payments layer, and answer operational questions about it. It can't make the business decisions.

| Work | Agent | Person |
| --- | --- | --- |
| Backend routes for customers, virtual accounts, quotes, payouts | Writes and tests | Reviews |
| Webhook handler with signature checks and idempotent ledger posts | Writes and tests | Reviews |
| Test runs on a development instance | Runs end to end | Reads results |
| Support lookups ("where is this payout?") | Answers through read tools | Replies to the user |
| Licensing path, sponsor bank, card provider | Researches | Decides |
| Creating instances and API keys, company onboarding | None | Does it in the dashboard |
| End user accepting terms | None | The user, on a hosted page |
| Production payouts | Prepares a quote | Confirms |

That last row is the one teams get wrong. An agent that can quote should not also be the only thing between a prompt and a payout.

## How do you connect an agent to BlindPay?

Add the hosted MCP server, sign in, and pick the instance.

The [Model Context Protocol](https://modelcontextprotocol.io/specification/2025-06-18/server/tools) lets an agent call an API's tools in response to plain-language requests. BlindPay's server works with Claude, ChatGPT, Codex, Claude Code, Cursor, VS Code, Windsurf, and other MCP clients.

1. **Hosted server, recommended.** Add https://mcp.blindpay.com/mcp. In Claude Code that is one claude mcp add command with the HTTP transport, as the [Claude Code MCP guide](https://code.claude.com/docs/en/mcp) describes. In Claude or ChatGPT, add it as a custom connector (ChatGPT needs Developer mode and OAuth). You sign in with your BlindPay account and choose which instance the agent may use.
2. **Read-only server.** Connect https://mcp.blindpay.com/mcp/readonly to let an agent explore without changing anything. It serves only read tools.
3. **Local server.** For hosts that only run local servers, or for CI, run the npm package @blindpay/mcp with an API key and instance id as environment variables.

On connect, the server sends the agent instructions: call order, amount units (cents for quotes and payouts, whole tokens for wallet balances), the steps a person must do in the dashboard, and how to test on a development instance. It also exposes every webhook event and payload schema as resources. Full setup per host is on [Build with AI](/docs/build-with-ai).

## When should an agent use the CLI instead of MCP?

When it already works in a terminal, in a script, or in CI. The [BlindPay CLI](/blog/cli) covers customers, bank accounts, blockchain wallets, quotes, payouts, payins, virtual accounts, offramp wallets, webhook endpoints, API keys, partner fees, and reference data such as available rails and the bank detail fields each rail needs.

Three things make it agent friendly. Every command accepts --json for structured output. blindpay schema returns field definitions, types, defaults, and enums, so an agent can build a valid command without reading docs. Exit codes are predictable, so a script knows when a call failed.

1. Install it with npm install -g @blindpay/cli, or run it through npx @blindpay/cli.
2. Configure it once with blindpay config set and your development instance's API key and instance id.
3. Let the agent run blindpay schema, then commands such as blindpay available bank_details --rail pix before it writes the bank account form.

The CLI uses an API key, so the key rules below apply: development keys only, stored as a secret, never pasted into a prompt.

## What do Agent Skills and prompts add?

Knowledge and a starting plan. The MCP server lets an agent act; skills and prompts make it act correctly.

[Agent Skills](https://agentskills.io) are an open format for packaging what an agent should know. BlindPay's skills teach rails, corridors, fees, and API patterns. Install them with npx skills add blindpaylabs/skills.

The prebuilt prompts on the Build with AI page walk an agent through a full payin or payout quickstart with the API gotchas already encoded, ending with one handoff to you. Paste one, then add your app's specifics: stack, screens, and where the ledger lives.

For a neobank, a good first prompt reads like this:

```text
Using the BlindPay MCP tools and Agent Skills, on my development instance:
1. Build a backend route that creates a payout quote for a saved bank account
   and returns receiver amount, fees, and expiry.
2. Build the execute route with an Idempotency-Key per request.
3. Build a webhook handler that verifies Svix signatures and posts ledger
   entries keyed on the payout id.
4. Test with amounts 66600 (fails) and 77700 (refunds) and show me the results.
Do not execute anything without asking me first.
```

## Which neobank tasks map to which surface?

Most build tasks run through MCP plus skills. Builders without an MCP host use the REST API.

| Task | Surface | Notes |
| --- | --- | --- |
| Scaffold the payout flow | MCP + Agent Skills + payout prompt | Agent writes routes, then tests them on the development instance |
| Scaffold deposits into US accounts | MCP + Agent Skills + payin prompt | Virtual accounts and payin webhooks |
| Create test customers | MCP tools | KYC auto-approves on development instances |
| Generate a virtual account | MCP tools | Created approved on development, with test routing numbers |
| Configure webhooks | MCP tools | Then verify signatures in your handler |
| Check a payout's status for support | Read-only MCP | Safe for support and ops agents |
| Look up required bank fields per rail | CLI: blindpay available bank_details | Feed the result into your form validation |
| Scripted test runs in CI | CLI with --json | Development instance key stored as a CI secret |
| Preview fees and FX for a corridor | MCP quote tools | Quote only, no execute |
| Lovable, v0, Bolt, Replit apps | REST API from a backend route | Key in secrets, never in client code |

For the screens these tasks sit behind, see the [neobank API quickstart](/resources/more/neobank-api-quickstart-first-deposit-first-payout). For agents that quote and pay out on request, [AI agents with live FX quotes over MCP](/resources/more/ai-agents-live-fx-quotes-mcp) covers expiry and confirmation in detail.

## Which guardrails should wrap agent-run payments?

Assume the agent will one day do the wrong thing confidently, and make sure it can't do it with real money.

[OWASP lists Excessive Agency](https://genai.owasp.org/llm-top-10/) among the top risks for LLM applications: an agent with more permissions or autonomy than the task needs. The MCP specification says there should always be a human in the loop who can deny tool invocations. Translated for a neobank:

- **Development first.** Every new flow runs on a development instance until a person signs off.
- **Least privilege.** Ops and support agents use the read-only endpoint. Only build agents on development get write tools.
- **Human confirmation on every payout.** BlindPay tools carry read-only and destructive annotations so clients can ask before non-read calls, but the server does not block a call by itself. Put the stop in your prompt and your app.
- **Amount thresholds.** Above a limit you set, require a second person, the maker-checker pattern from [payout approval controls](/resources/more/stablecoin-payout-approval-controls).
- **No keys in prompts or repos.** Prefer the hosted server's sign-in. Where a key is needed, store it as a secret.
- **Idempotency on every money-moving call,** so an agent retry can't send twice.
- **Logs you can audit.** Keep who asked, what the agent proposed, who confirmed, and the resulting ids.

## What are the common mistakes?

- Pointing a new agent at production "just to look," with write tools enabled.
- Letting the agent decide the confirmation copy and skip the receiver amount.
- Accepting generated code that sends dollars where the API expects cents.
- Testing only the happy path. 66600 and 77700 exist so you can test failure and refund screens.
- Pasting an API key into a prompt, then into a shared transcript.

Illustrative example: a four-person team asks an agent to build payouts on Monday. By Tuesday the agent has routes, a webhook handler, and passing tests for completed, failed, and refunded payouts on a development instance. A developer reviews the diff, a compliance lead reviews the confirmation screen, and production access opens with read-only tools for support. The agent never touched real money.

## How BlindPay fits

BlindPay describes itself as AI-native stablecoin infrastructure, and the surfaces back that up: a hosted MCP server with sign-in and instance selection, a read-only endpoint, a local npm server for CI, the BlindPay CLI with JSON output and schema introspection, Agent Skills, prebuilt quickstart prompts, and a REST API with an OpenAPI 3.1 spec and official SDKs in Node.js, Python, Go, PHP, and Swift.

Under those tools is the same money movement a neobank needs: KYC and KYB in the API, US virtual accounts in the customer's own name, payins, and payouts over ACH, wire, RTP, Pix, SPEI, ACH Colombia, Transfers 3.0, SEPA, Faster Payments, and SWIFT (POBO/COBO), each priced by a quote that locks rate and fees before execution. Development instances let agents run the whole loop with a test stablecoin.

## What to do next

Create a development instance, connect https://mcp.blindpay.com/mcp to your coding agent, install the skills, and paste the payout prompt from [Build with AI](/docs/build-with-ai). Review what it writes before anything leaves development.