Onchain Banking Infrastructure for Autonomous AI Agents
MoltFi is the first authorization-based onchain neobank purpose-built for AI agents. Built on Solana, MoltFi enables AI agents—particularly OpenClaw agents—to execute payments, manage assets, and coordinate services autonomously with enterprise-grade security and programmable spending controls.
Leveraging Solana's high-throughput architecture (400ms block times, 65,000 TPS capacity), MoltFi provides professional banking infrastructure that allows AI agents to transact onchain without requiring human approval for each payment while maintaining complete custody and security through program-derived addresses (PDAs) and token delegation.
Every AI agent gets its own Solana PDA account with programmable authorization logic. Sub-second finality (~400ms), ultra-low transaction costs ($0.00025 per transaction), and native multi-signature support.
Create time-bound, limited-scope token delegations that give AI agents spending authority without custody risk. Define granular permissions—spending limits, recipient allowlists, operation restrictions—all enforced onchain via Solana programs.
Proprietary policy enforcement system implementing fine-grained access controls. Spending limits per transaction/day/month, vendor allowlists, operational constraints, and multi-party approval workflows enforced by on-chain Solana programs.
Built on Solana's native USDC with Circle's infrastructure. Instant settlement, zero internal transfer fees, and integration with Visa's USDC settlement network. Agent-controlled DeFi interactions (Jupiter, Marinade, Kamino) within policy boundaries.
Average transaction confirmation: 400ms. API response time: <50ms p95. Policy validation: <20ms onchain verification. 99.99% uptime SLA.
Native integration with Solana DeFi ecosystem. Agents can interact with Jupiter (DEX aggregator), Marinade (liquid staking), Kamino (lending), and other Solana programs within configured policy limits.
import { MoltFi } from '@moltfi/sdk';
import { Keypair } from '@solana/web3.js';
const moltfi = new MoltFi({
apiKey: process.env.MOLTFI_API_KEY,
network: 'mainnet-beta', // or 'devnet' for testing
rpcUrl: process.env.SOLANA_RPC_URL
});
// Your wallet maintains ownership
const ownerKeypair = Keypair.fromSecretKey(/* your keypair */);
// Create PDA account for agent
const agent = await moltfi.agents.create({
name: 'OpenClaw Infrastructure Agent',
owner: ownerKeypair.publicKey,
initialFunding: {
amount: '1000',
token: 'USDC'
}
});
console.log('Agent PDA:', agent.address.toBase58());
console.log('USDC Balance:', agent.balance.usdc);// Generate agent keypair (or use existing)
const agentKeypair = Keypair.generate();
// Create time-bound delegation
const delegation = await moltfi.delegations.create({
pda: agent.address,
delegate: agentKeypair.publicKey,
policy: {
dailyLimit: '500 USDC',
perTransactionLimit: '100 USDC',
// Allowlist recipient addresses
allowedRecipients: [
new PublicKey('...'), // Payment processor
new PublicKey('...'), // Vendor wallet
],
// Allowlist programs
allowedPrograms: [
new PublicKey('JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4'), // Jupiter
new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'), // USDC
],
expiresIn: '30 days'
}
});
console.log('Delegation created:', delegation.id);
console.log('Expires:', delegation.expiresAt);// Agent executes transaction via delegation
const tx = await moltfi.transactions.execute({
pda: agent.address,
delegate: agentKeypair.publicKey, // Agent's keypair
operation: {
type: 'transfer',
token: 'USDC',
recipient: new PublicKey('...merchant-wallet'),
amount: '50',
memo: 'API subscription payment'
}
});
// Policy validated onchain before execution
console.log('Transaction signature:', tx.signature);
console.log('Slot:', tx.slot);
console.log('Confirmation status:', tx.confirmationStatus); // 'confirmed'
console.log('Block time:', tx.blockTime); // ~400ms- Quickstart Guide - Deploy your first agent in 10 minutes
- Authentication - Keypairs, wallets, and security
- Agent Accounts - PDA account creation and management
- Onchain Payments - USDC transfers and SPL token operations
- Delegation Policies - Token delegation configuration
- Webhooks - Real-time event notifications
- Platform Architecture - System design and Solana programs
- Authorization Engine - Policy enforcement system
- REST API - Complete endpoint documentation
- SDKs - TypeScript, Python, Rust client libraries
- Error Codes - Error handling reference
A Solana account derived from a program ID and seeds. PDAs enable programs to sign transactions programmatically without private keys. MoltFi uses PDAs to create agent accounts with programmable authorization logic.
A time-bound, limited-scope permission grant that allows an AI agent keypair to execute specific SPL token operations on behalf of a PDA account. The owner maintains custody while the agent operates autonomously within defined boundaries.
MoltFi's proprietary Solana program that validates transactions against configured policies before execution. Implements spending limits, recipient allowlists, operational constraints, and multi-party approval workflows.
Standard Program Library (SPL) token transfers and interactions. MoltFi primarily uses USDC (Circle's SPL token) for payments, with support for other SPL tokens within policy boundaries.
Solana's mechanism for programs to call other programs. MoltFi's authorization program uses CPIs to enable agents to interact with DeFi protocols (Jupiter, Marinade, Kamino) within policy limits.
| Metric | Specification |
|---|---|
| Transaction Confirmation | ~400ms average (Solana block time) |
| Transaction Finality | ~13 seconds (32 confirmations) |
| API Response Time | <50ms p95 |
| Policy Validation | <20ms onchain verification |
| Transaction Cost | $0.00025 average (5,000 lamports) |
| Uptime SLA | 99.99% |
| Network | Solana Mainnet Beta |
| Supported Tokens | USDC, USDT, SOL, major SPL tokens |
Deploy an OpenClaw agent with delegated authority to pay for cloud services. The agent optimizes resource allocation and pays invoices autonomously within $10,000/month spending policy via USDC transfers.
Enable agents to purchase API access, computational resources, and datasets from other agents. Agent-to-agent payments settled in ~400ms via Solana with cryptographic finality.
Configure agents to manage Solana DeFi positions—swapping on Jupiter, staking with Marinade, lending on Kamino—within risk-controlled policy boundaries.
Leverage Solana's 400ms block times for algorithmic trading agents. Execute thousands of transactions per day with ultra-low fees ($0.00025 per tx).
Give research teams agent-controlled budgets for compute, data, and tools. Agents autonomously allocate resources while respecting spending constraints and recipient allowlists.
Users retain private keys to their keypairs. AI agents receive only delegated token permissions via MoltFi's Solana program, never custody of the PDA account.
All spending rules enforced via Solana programs with deterministic execution. No centralized party can override policies—validation is transparent and verifiable onchain.
Delegations automatically expire after configured period (e.g., 30 days). Agents lose authority unless delegation is explicitly renewed via on-chain instruction.
Owners can revoke delegations instantly, freeze accounts, or modify policies at any time via dashboard or API, executed as Solana transactions.
- 400ms block times: Near-instant transaction confirmation
- 65,000 TPS capacity: Scales to millions of agent transactions
- Ultra-low fees: $0.00025 per transaction vs $1-50 on Ethereum
- Rust-based programs: Type-safe, high-performance smart contracts
- Rich ecosystem: Jupiter DEX, Marinade staking, Kamino lending
- Excellent tooling: Anchor framework, Solana CLI, comprehensive SDKs
- Native USDC: Circle's official SPL token implementation
- High liquidity: Billions in USDC on Solana
- Visa integration: Direct settlement to Visa USDC network
- Sub-second finality: Agents can react in real-time
- Predictable costs: No gas price volatility
- High throughput: Thousands of agent transactions per second
- Cluster:
https://api.mainnet-beta.solana.com - Explorer:
https://explorer.solana.com - USDC Program:
EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v - MoltFi Program:
[To be deployed]
- Cluster:
https://api.devnet.solana.com - Explorer:
https://explorer.solana.com?cluster=devnet - Faucet:
solana airdrop 2(2 SOL for testing)
- OpenClaw agent deployment or AI agent framework
- Solana wallet (Phantom, Solflare, or Backpack)
- MoltFi API key (sign up)
- Solana RPC access (Helius, QuickNode, or Triton)
- Get started with the Quickstart Guide - Deploy your first agent account
- Configure delegation policies - Set spending limits and controls
- Explore PDA account operations - Fund accounts and manage balances
- Review the complete API reference - Integrate with your agent framework
- Documentation: docs.moltfi.com
- Discord: discord.gg/moltfi
- X/Twitter: @getmoltfi
- Email: support@getmoltfi.com
- GitHub: github.com/moltfi
- Status Page: status.moltfi.com
MoltFi integrates with the Solana DeFi ecosystem:
- Jupiter - DEX aggregator for token swaps
- Marinade Finance - Liquid staking (mSOL)
- Kamino Finance - Lending and liquidity
- Circle USDC - Native stablecoin infrastructure
- Squads - Multi-signature wallet infrastructure
MoltFi implements the following Solana standards:
- SPL Token Program - Fungible token operations (USDC, USDT, SOL)
- Associated Token Account - Token account management
- Anchor Framework - Solana program development framework
- Token Extensions - Advanced token features (future support)
Professional-grade banking infrastructure for the autonomous AI economy, built on Solana