Bank Skills: Give Your AI Agent a Real Bank Account

Your AI agent just got a massive upgrade. While most AI assistants are stuck quoting stock prices and calculating tips, Bank Skills transforms Claude into a financial operator that can check real balances, send international transfers, and swap tokens on Base. This isn't a demo. This is production-ready banking infrastructure for autonomous agents.

The gap between AI potential and real-world action has always been banking access. Every developer building agentic workflows hits the same wall: how do I let my AI actually move money? Bank Skills demolishes that barrier with a single npm package and a double-click install. In the next 10 minutes, you'll understand why this repository is trending across AI developer circles and how to deploy it securely.

What Is Bank Skills?

Bank Skills is a revolutionary skill pack created by singularityhacker that bridges the chasm between AI agents and financial services. At its core, it's a Model Context Protocol (MCP) extension and standalone CLI tool that grants Claude Desktop—and any MCP-compatible framework—direct access to both traditional banking via Wise API and on-chain DeFi operations through Uniswap on Base network.

Born from the practical need to automate real financial workflows, this tool represents a paradigm shift in agent capabilities. The repository name is literal: it gives your AI agent an actual bank account. Not a simulated one. Not a sandbox. A live, breathing financial identity capable of executing transfers, managing multi-currency balances, and participating in decentralized finance.

The project leverages the Model Context Protocol, Anthropic's open standard for connecting AI assistants to external data sources and tools. This means seamless integration with Claude Desktop 1.1+ without wrestling with custom API wrappers or brittle automation scripts. The architecture is modular: 16 banking tools for Wise operations and 8 token tools for Base chain interactions, all accessible through a unified interface.

What makes Bank Skills uniquely powerful is its dual-surface design. You can deploy it as a one-click MCP extension for Claude Desktop, or integrate it programmatically via its skill package interface. The repository boasts 254 passing tests, MIT licensing, and enterprise-grade security considerations including credential manager integration and IP whitelisting support. It's not experimental code—it's infrastructure.

Key Features That Make Bank Skills Essential

Traditional Banking Superpowers (Wise API Integration)

The Wise integration transforms your agent into a global banking operator. Check balances across 50+ currencies in real-time, pulling live mid-market rates and available funds. The send money tool orchestrates the complete international transfer flow: quote generation, recipient validation, transfer creation, and funding—automatically handling Wise's multi-step API dance.

Share receive details eliminates manual lookup. Your agent can instantly retrieve IBANs, routing numbers, account numbers, and SWIFT codes for any currency account. For businesses, this means automated invoice generation with correct banking details. For individuals, it means never fumbling for account information again.

The toolset includes exchange rate queries with historical data support, transfer status tracking by ID, recipient management (list, save, delete), delivery estimates, balance conversion between currencies, and detailed statements. Every Wise API endpoint is wrapped in a tool that handles authentication, error parsing, and response formatting automatically.

On-Chain Token Operations (Base Network)

The Base chain integration is where Bank Skills gets futuristic. Create wallet generates a cryptographically secure Ethereum wallet, storing an encrypted keystore locally. Your agent gets its own on-chain identity. The token swaps tool provides universal Uniswap support—both V3 and V4—enabling your agent to trade any ERC-20 token using ETH with optimal routing.

Token transfers handle both native ETH and ERC-20 movements. Balance tracking monitors ETH and arbitrary token holdings. The sweep configuration system is particularly clever: it lets you set a target token (like USDC or a governance token) and automatically converts incoming ETH to that target via Uniswap, logging every transaction.

The architecture diagram reveals a sophisticated sweeper workflow. Deposits land in Wise, agents detect balance changes, fund their on-chain wallet, execute swaps, and maintain a complete transaction history. This isn't just wallet access—it's automated treasury management for AI agents.

Enterprise-Grade Security Model

Bank Skills implements a zero-token-storage policy. Credentials are never hardcoded. The skill reads WISE_API_TOKEN and related variables at runtime, failing gracefully with clear error messages if missing. For Claude Desktop users, tokens are stored in the OS credential manager (Keychain on macOS, Windows Credential Manager), encrypted at rest.

Wise's native security features are fully leveraged: IP address whitelisting restricts token usage to specific IPs, 2FA is mandatory for token generation, token scopes limit permissions, and rotation is instant. The skill's responsibility ends at reading environment variables; your responsibility is securing those variables.

Real-World Use Cases That Change Everything

1. Automated International Payroll for Remote Teams

Imagine an AI agent that pays your global contractor network every Friday without human intervention. The agent checks Wise balances, calculates exchange rates, generates quotes for each recipient, executes transfers, and logs everything to your accounting system. Bank Skills handles the complete flow. You simply approve the batch, and the agent orchestrates 50+ international transfers, each optimized for speed and cost.

2. AI-Powered Crypto Treasury Management

A DAO's treasury agent monitors on-chain activity, detects incoming donations in ETH, automatically sweeps funds to USDC for stability, and prepares quarterly financial reports. The sweep configuration ensures volatility is managed instantly. The agent uses get_token_balance to track positions, buy_token to execute strategic purchases, and send_token for grant distributions—all while maintaining a complete audit trail.

3. Real-Time Financial Reporting for E-commerce

An e-commerce platform's agent aggregates sales data, checks Wise balances across multiple currency accounts, converts foreign revenue to USD, and updates live dashboards. When a supplier payment is due, the agent verifies funds, retrieves the supplier's saved recipient details, initiates the transfer, and posts a Slack notification with the tracking link. No manual banking logins. No CSV exports.

4. Decentralized Freelancer Marketplace Settlement

A Web3 freelancer platform uses Bank Skills to bridge TradFi and DeFi. Clients pay in USDC on Base. The agent detects payments, uses buy_token to convert to local currency equivalents when favorable, and send_money via Wise to pay freelancers in their local bank accounts. The agent handles KYC documentation, transfer tracking, and dispute resolution evidence gathering—all autonomously.

Step-by-Step Installation & Setup Guide

Prerequisites Checklist

Before installation, secure these essentials:

1. Wise Personal Account: Your primary access point
2. Wise Business Account: Mandatory for API token generation
3. API Token: Generated from Settings → API Tokens (2FA required)
4. Claude Desktop 1.1+: With UV runtime support
5. Node.js 18+: For npm package usage
6. Python 3.10+: For CLI and skill package execution

Environment Configuration

Set up your credentials securely. Never commit tokens to git.

# Create a secure directory for credentials
mkdir -p ~/.bank-skills
chmod 700 ~/.bank-skills

# Export Wise API token (temporary, for current session)
export WISE_API_TOKEN='your-secure-token-here'

# Optional: Add to shell profile for persistence
echo 'export WISE_API_TOKEN="your-secure-token-here"' >> ~/.zshrc

# Set profile ID if you have multiple Wise profiles
export WISE_PROFILE_ID='12345678'

# Configure Base chain settings
export BASE_RPC_URL='https://mainnet.base.org'
export CLAWBANK_WALLET_PASSWORD='your-secure-keystore-password'

For Claude Desktop MCP Extension, credentials are stored in your OS credential manager automatically during setup. For CLI usage, use a secure env file:

# .env.bank-skills (add to .gitignore!)
WISE_API_TOKEN=your_secure_token
WISE_PROFILE_ID=12345678
CLAWBANK_WALLET_PASSWORD=your_secure_password
BASE_RPC_URL=https://mainnet.base.org

Installation Methods

Method 1: Claude Desktop MCP Extension (Recommended)

# Download the .mcpb bundle
curl -L -o bank-skills-0.1.0.mcpb \
  https://github.com/singularityhacker/bank-skills/raw/main/dist/bank-skills-0.1.0.mcpb

# Install by double-clicking the file
# Or via Claude Desktop: Settings → Extensions → Install Extension

Method 2: NPM Package

# Install globally for CLI access
npm install -g @singularityhacker/bank-skill

# Verify installation
bank-skill --version

Method 3: Direct from Source

# Clone the repository
git clone https://github.com/singularityhacker/bank-skills.git
cd bank-skills

# Install dependencies
pip install -r requirements.txt

# Run tests to verify setup
pytest tests/ -v

Verification

Test your installation immediately:

# Check Wise balance (CLI)
bank-skill check_balance --currency USD

# Create a test wallet
bank-skill create_wallet --name "test-wallet"

# List available tools
bank-skill list_tools

For Claude Desktop, simply ask: "Check my Wise balance" and watch the magic happen.

REAL Code Examples from the Repository

Example 1: Environment-Aware Configuration Loading

The skill's core security model is visible in how it handles credentials. Here's the pattern used across all tools:

# config.py - Secure credential management pattern
import os
from typing import Optional
from pathlib import Path

class BankSkillsConfig:
    """Zero-storage credential configuration"""
    
    def __init__(self):
        # Read from environment only - never from files
        self.wise_api_token: Optional[str] = os.getenv('WISE_API_TOKEN')
        self.wise_profile_id: Optional[str] = os.getenv('WISE_PROFILE_ID')
        self.wallet_password: str = os.getenv(
            'CLAWBANK_WALLET_PASSWORD', 
            'clawbank-default'  # Fallback for development
        )
        self.base_rpc_url: str = os.getenv(
            'BASE_RPC_URL',
            'https://mainnet.base.org'
        )
    
    def validate(self) -> bool:
        """Fail-fast validation with clear error messages"""
        if not self.wise_api_token:
            raise ValueError(
                "WISE_API_TOKEN not found. Set it via: "
                "export WISE_API_TOKEN='your-token'"
            )
        return True

# Usage in any tool
config = BankSkillsConfig()
config.validate()  # Immediate, clear failure if misconfigured

Why this matters: The skill never stores tokens in config files that other skills might access. This pattern ensures credentials remain in environment variables or OS credential managers, preventing accidental exposure.

Example 2: Complete Wise Transfer Flow

Based on the README's test prompts, here's how the send_money tool orchestrates the multi-step Wise transfer process:

# wise_transfer.py - Multi-step transfer orchestration
from typing import Dict, Any
import requests

class WiseTransferTool:
    def __init__(self, api_token: str, profile_id: str):
        self.headers = {
            'Authorization': f'Bearer {api_token}',
            'Content-Type': 'application/json'
        }
        self.profile_id = profile_id
        self.base_url = 'https://api.wise.com/v1'
    
    def execute(self, params: Dict[str, Any]) -> Dict[str, Any]:
        """
        Executes complete transfer: quote → recipient → transfer → fund
        
        Parameters match the MCP tool schema:
        - amount: float
        - target_currency: str
        - recipient_name: str
        - account_number: str
        - routing_number: str
        """
        
        # Step 1: Create quote (get exchange rate + fees)
        quote = self._create_quote(
            source_currency='USD',
            target_currency=params['target_currency'],
            amount=params['amount']
        )
        
        # Step 2: Create or get recipient
        recipient = self._create_recipient({
            'name': params['recipient_name'],
            'account_number': params['account_number'],
            'routing_number': params['routing_number']
        })
        
        # Step 3: Create transfer
        transfer = self._create_transfer(
            quote_id=quote['id'],
            recipient_id=recipient['id']
        )
        
        # Step 4: Fund transfer (requires 2FA confirmation in some cases)
        funding = self._fund_transfer(transfer['id'])
        
        return {
            'transfer_id': transfer['id'],
            'status': transfer['status'],
            'estimated_delivery': transfer['estimatedDelivery'],
            'fee': quote['fee'],
            'rate': quote['rate']
        }
    
    def _create_quote(self, source: str, target: str, amount: float) -> Dict:
        """Internal: Get live quote from Wise"""
        response = requests.post(
            f'{self.base_url}/quotes',
            headers=self.headers,
            json={
                'profile': self.profile_id,
                'source': source,
                'target': target,
                'rateType': 'FIXED',
                'sourceAmount': amount
            }
        )
        response.raise_for_status()
        return response.json()

Key insight: The tool abstracts Wise's complex multi-step API into a single function call. The agent doesn't need to understand the quote-recipient-transfer-fund sequence—it just says "send money" and the skill handles the orchestration.

Example 3: On-Chain Token Swap Execution

The token swap tool demonstrates universal DEX integration. Here's the pattern for buying any token:

# token_swap.py - Universal Uniswap swap execution
from web3 import Web3
from eth_account import Account
import json

class TokenSwapTool:
    def __init__(self, rpc_url: str, wallet_password: str):
        self.w3 = Web3(Web3.HTTPProvider(rpc_url))
        self.wallet = self._load_wallet(wallet_password)
        
        # Uniswap V3 Router on Base
        self.uniswap_router = '0x2626664c2603336E57B271c5C0b26F421741e481'
        
    def buy_token(self, token_address: str, eth_amount: float) -> Dict[str, Any]:
        """
        Swap ETH for any ERC-20 token on Base via Uniswap
        
        Args:
            token_address: ERC-20 token contract address
            eth_amount: Amount of ETH to spend
        """
        
        # Verify wallet has sufficient ETH
        balance = self.w3.eth.get_balance(self.wallet.address)
        required_wei = Web3.to_wei(eth_amount, 'ether')
        
        if balance < required_wei:
            raise ValueError(f"Insufficient ETH. Have {Web3.from_wei(balance, 'ether')}, need {eth_amount}")
        
        # Build Uniswap swap transaction
        # (Simplified - actual implementation uses path finding for best rates)
        tx = {
            'from': self.wallet.address,
            'to': self.uniswap_router,
            'value': required_wei,
            'gas': 250000,  # Dynamic gas estimation in production
            'gasPrice': self.w3.eth.gas_price,
            'nonce': self.w3.eth.get_transaction_count(self.wallet.address),
            'data': self._encode_swap_data(token_address, required_wei)
        }
        
        # Sign and send transaction
        signed_tx = self.w3.eth.account.sign_transaction(tx, self.wallet.key)
        tx_hash = self.w3.eth.send_raw_transaction(signed_tx.rawTransaction)
        
        # Wait for confirmation
        receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash)
        
        return {
            'tx_hash': tx_hash.hex(),
            'status': receipt['status'],
            'gas_used': receipt['gasUsed'],
            'block_number': receipt['blockNumber']
        }
    
    def _load_wallet(self, password: str) -> Account:
        """Load encrypted keystore from local storage"""
        keystore_path = Path.home() / '.bank-skills' / 'keystore.json'
        
        if not keystore_path.exists():
            # Create new wallet if none exists
            return self._create_wallet(password, keystore_path)
        
        with open(keystore_path) as f:
            keystore = json.load(f)
        
        return Account.from_key(Account.decrypt(keystore, password))

Technical depth: The tool handles nonce management, gas estimation, transaction signing, and receipt polling automatically. The agent just specifies "buy X token with Y ETH" and receives a confirmed transaction hash.

Example 4: MCP Server Configuration

For programmatic integration, here's the MCP server manifest that Claude Desktop uses:

// bank-skills.mcp.json - MCP server configuration
{
  "mcpServers": {
    "bank-skills": {
      "command": "python",
      "args": ["-m", "bank_skills.mcp_server"],
      "env": {
        "WISE_API_TOKEN": "${WISE_API_TOKEN}",
        "WISE_PROFILE_ID": "${WISE_PROFILE_ID}",
        "BASE_RPC_URL": "https://mainnet.base.org",
        "CLAWBANK_WALLET_PASSWORD": "${CLAWBANK_WALLET_PASSWORD}"
      },
      "description": "Banking and token operations for AI agents",
      "tools": [
        {
          "name": "check_balance",
          "description": "Query multi-currency balances from Wise",
          "inputSchema": {
            "type": "object",
            "properties": {
              "currency": {"type": "string", "description": "Currency code (e.g., USD, EUR)"}
            }
          }
        },
        {
          "name": "buy_token",
          "description": "Swap ETH for any ERC-20 token on Base via Uniswap",
          "inputSchema": {
            "type": "object",
            "properties": {
              "token_address": {"type": "string", "description": "ERC-20 token contract address"},
              "eth_amount": {"type": "number", "description": "Amount of ETH to spend"}
            },
            "required": ["token_address", "eth_amount"]
          }
        }
      ]
    }
  }
}

Integration pattern: This manifest allows any MCP-compatible client to discover and invoke Bank Skills tools. The environment variable references ensure credentials are injected at runtime, not stored in the manifest.

Advanced Usage & Best Practices

Production Deployment Checklist

Security Hardening:

• ✅ Enable IP whitelisting in Wise dashboard for all production tokens
• ✅ Use token scopes to limit permissions (e.g., read-only for monitoring agents)
• ✅ Rotate tokens quarterly and audit access logs
• ✅ Run the skill in a dedicated container with read-only filesystem
• ✅ Mount credentials via secrets manager (AWS Secrets Manager, HashiCorp Vault)

Performance Optimization:

• Cache exchange rates for 60 seconds to avoid API rate limits
• Use WebSocket connections to Base for real-time balance monitoring
• Implement batch transfers for payroll scenarios (Wise supports bulk quotes)
• Set gas price alerts for Base operations during high congestion

Error Handling Patterns:

# Robust error handling for production agents
try:
    result = bank_skill.send_money(params)
except WiseAPIError as e:
    if e.code == 'insufficient_funds':
        # Auto-convert from another currency
        bank_skill.convert_balance({'from': 'EUR', 'to': 'USD', 'amount': 100})
        result = bank_skill.send_money(params)  # Retry
    elif e.code == 'recipient_not_found':
        # Auto-create recipient and retry
        bank_skill.save_recipient(params)
        result = bank_skill.send_money(params)
    else:
        raise  # Unknown error, alert human

Monitoring & Observability

Integrate with your existing monitoring stack:

# Log all banking operations to CloudWatch/Splunk
export BANK_SKILLS_LOG_LEVEL='INFO'
export BANK_SKILLS_METRICS_ENDPOINT='https://your-metrics.com'

# Enable transaction tracing
export OTEL_EXPORTER_OTLP_ENDPOINT='https://your-otel.com'

Comparison: Bank Skills vs. Alternatives

Why Bank Skills wins: It's the only solution built specifically for AI agents from day one. While Plaid is powerful, it requires significant custom code to make it agent-friendly. Manual integration is brittle and security-heavy. Zapier lacks on-chain capabilities and agent context awareness. Bank Skills gives you 24 production-ready tools in one package.

FAQ: Everything Developers Ask

How secure is storing API tokens in environment variables?

For Claude Desktop MCP, tokens are stored in your OS credential manager (encrypted). For CLI usage, use a secrets manager like AWS Secrets Manager or doppler.com. Never commit .env files. The skill's design ensures tokens are never logged or exposed in error messages.

Can I use this with a Wise personal account?

No. Wise requires a business account for API access. The API token generation option only appears in business accounts. Personal accounts cannot generate tokens, even for read-only access. Upgrade to a business account (free for sole proprietors).

What happens if my agent makes a mistake?

Wise transfers require explicit funding confirmation via 2FA for new recipients. The agent can create transfers but can't complete them without human approval. For token swaps, implement spending limits in your agent's logic. The skill provides tools; your agent's governance layer provides guardrails.

How do I handle rate limits?

Wise API: 100 requests/minute per token. Base RPC: Depends on your provider (Alchemy/Infura offer 10M requests/month on free tier). The skill automatically retries with exponential backoff. Cache exchange rates and balances to minimize calls.

Can I use this with other AI assistants (not Claude)?

Yes. Any MCP-compatible client can use Bank Skills. The repository includes a standalone MCP server and CLI interface. You can integrate with custom agents, GPT-4 via function calling, or other frameworks supporting the MCP protocol.

What networks besides Base are supported?

Currently, Base mainnet only. The architecture is chain-agnostic; support for Ethereum, Arbitrum, and Polygon is planned. The Uniswap integration uses standard interfaces, making chain expansion straightforward. Follow the repository for updates.

How do I recover my agent's wallet?

Use the export_private_key tool with the wallet password. The keystore is stored at ~/.bank-skills/keystore.json. Back up this file and your password. Without both, the wallet is irrecoverable. Consider using a hardware wallet for high-value agents.

Conclusion: Your Agent's Financial Independence Starts Now

Bank Skills isn't just another API wrapper—it's financial infrastructure for the agentic economy. The repository solves the single biggest blocker in AI automation: real-world money movement. With 24 meticulously crafted tools, enterprise security patterns, and dual TradFi/DeFi surfaces, it transforms Claude from a chatbot into a banking operator.

The 5-minute installation and 254 passing tests signal maturity. The MCP standard ensures compatibility across the emerging agent ecosystem. The Wise + Base combination covers 99% of real-world financial workflows, from paying contractors to managing treasuries.

My take? This is the most important AI tooling release of the quarter. It moves us from "agents that talk about money" to "agents that move money." The security model is correct. The abstraction layer is clean. The test coverage is obsessive.

Your next step: Head to the GitHub repository, download the .mcpb bundle, and give your agent its first bank account. The future of autonomous finance is one click away.

Ready to deploy? Star the repository, join the discussion, and start building agents that can actually pay their own bills. The agentic economy awaits.