Pilot

Pilot is the agentic DeFi terminal for the XRP Ledger: one harness for discovering and executing across every XRPL venue. It works with any model, and its memory learns how you trade.

AI can already read the XRP Ledger. Pilot lets it act safely. Today that is hard for two groups of people.

Developers rebuild the same risky infrastructure for every app. Each team has to fetch prices and balances, write the transaction, check the user's limits, get it approved and signed, then send it and confirm it. Each step has its own failure: stale prices, the wrong amount or token, a skipped limit, the wrong trade signed, a trade sent twice or a result lost. XRPL makes this harder because its DEX, AMM, escrow, checks and vaults are native ledger features, so there are no smart-contract wallets to hold an agent's spending rules.

Traders juggle four disconnected tools for every trade. They check prices on a charts site, ask a chatbot what to do, retype the trade into a wallet, then look it up on an explorer. Prices get copied by hand, the chatbot can't see their limits, trades get mistyped, and nothing records what was done or why.

Pilot solves both with one product.

For developers and agents, Pilot is an MCP server and a REST API that cover the full flow. Claude, Codex, Cursor or a custom bot connects to the MCP, which has two tools, search and execute. The agent finds what it needs in a catalog of 64 operations and 23 venues, then runs a short script in a sandbox with no internet access. Apps call the same operations at POST /api/ops/{op}. There are 27 read operations (balances, order books, quotes, AMM pools, token risk flags, yield, XRPL docs, XRP perps context and the venue catalog), 16 transaction builders (swaps, offers, payments, trust lines, AMM, vaults, escrow, checks and simulation) and 21 execution operations (submit, track, permissions, limits and agent payments). Every write follows the same path. Prices are read live from the ledger. The exact trade is built and simulated. The user's limits are checked and the spend is reserved, so a retry can't trade twice. Approval is tied to that exact trade, and the signature is checked again before sending. The result is confirmed on the ledger and recovered if it drops. The code is open source, so the next XRPL app starts with these limits and approvals already built in.

For traders, Pilot is a workspace built on that same API. You ask in plain language, for example "Swap 100 XRP to RLUSD at the best rate." The agent reads the live market, notices that the AMM pool pays more than the order book, and proposes the swap within your daily limit. You approve the exact details, and the trade is confirmed and recorded. The model never holds a signing key. Owner keys stay in your wallet, and routine trades go through a limited delegate built on XRPL Permission Delegation, which went live on Mainnet on 8 October 2026. You can revoke it on the ledger at any time.

Pilot also remembers and improves. Every validated trade goes through a loop: Pilot compares the expected and actual fill, saves the result to your journal and trade notes, and proposes a better preference. Nothing is saved until you approve it, and the next trade reads it. Memory lives in an Obsidian vault you own, as linked Markdown notes versioned in Git. Because memory is separate from the model, you can switch models through OpenRouter and keep the same context. The design draws on Google's Harness², Nous Research's Hermes Agent and Obsidian.

Our partner integrations each cover one part of the same trade. QuickNode connects Pilot to the ledger: it reads balances and order books, submits signed trades, uses Streams to confirm each trade before it is recorded, and runs a watchdog that flags any trade Pilot didn't make. AWS runs and protects the AI. Bedrock runs the model, Guardrails screens untrusted inputs before the model sees them, AgentCore does research without wallet access, and KMS protects the signing key. When a step needs paid data, Pilot pays x402 APIs in RLUSD within the user's budget. With Mastercard Agent Pay for Machines, the owner sets merchants, caps and an expiry once, agents carry an on-ledger credential, and payments settle with receipts. Anything outside the delegate's limits goes to the owner, who signs it on a Ledger device, so signing keys stay out of the AI's hands. Pilot's limits stay the final authority on what is allowed.

Pilot runs end-to-end trades on XRPL Testnet today, and Mainnet execution is disabled. Next steps are a security audit, a Mainnet launch, a closed beta with traders who already use AI, a public trade journal that can be verified on the ledger, and the first developer partners on the MCP and API. Later come a hosted MCP and API, strategy templates (DCA, rebalancing, ladders), and lending and staking as they launch on XRPL.