AI agents can now write code, browse the web, manage files, and run terminal commands. What remains difficult is interacting with financial systems reliably and safely.
Not because the models are incapable. Because most financial infrastructure was never designed for autonomous software.
Most fintech APIs were designed for developers and human operators. They assume someone is reviewing outputs, interpreting failures, and deciding what to do next.
AI agents can work with those APIs, but reliability becomes harder when outputs are inconsistent, errors are unstructured, or critical operations require manual intervention.
When real funds are involved, deterministic behavior matters more than clever interpretation. This is the gap we set out to close with Uphold.
What We Built
uphold-cli is a command-line tool and MCP server that gives AI agents programmatic access to key Uphold capabilities: market data, account management, portfolio aggregation, and transaction flows.
It is distributed as a single Rust binary with zero external dependencies.
Market dataPublic ticker and currency data, with no credentials required.
AccountsCards, addresses, and portfolio aggregation through one interface.
TransactionsThe full quote and commit flow, including review before funds move.
MCP serverBuilt-in over stdio. No subprocess wrappers or custom integrations.
uphold-cliCommand-line tool and MCP server for Uphold. Structured JSON by default. Safe by default. The repository is private for now. We expect to open it shortly.
Designed Agent-First, Not Agent-Compatible
Most CLIs are built for humans and then retrofitted for automation. uphold-cli was designed the other way around.
Every command outputs structured JSON by default. Not because agents cannot read human-readable output, but because structured output is easier to consume reliably in automated workflows.
Agents can work directly with typed fields instead of extracting information from formatted text.
Error handling follows the same pattern. Every failure returns a categorized envelope. An agent reading this knows exactly what happened and what to do next.
This matters in production. When a rate limit hits, the error envelope includes retryable, suggestion, and an optional docs_url. The agent can backoff and continue without human intervention.
| Envelope field | Why it matters |
|---|---|
| Category | The agent knows what kind of failure it is looking at |
| retryable | Whether autonomous retry is safe |
| suggestion | The next action, without operator guesswork |
| docs_url | Optional reference when the agent needs more context |
The MCP Server
uphold-cli includes a built-in Model Context Protocol server over stdio. No subprocess wrappers, no custom integrations needed.
uphold mcp -s allThis exposes Uphold capabilities as callable tools to any MCP-compatible agent. The agent discovers the available commands, their parameters, and their safety flags automatically from the tool schemas.
- Claude Desktop
- Cursor
- Codex
- Gemini CLI
- Goose
- OpenClaw
A single MCP configuration block is enough to expose the entire command surface:
{
"mcpServers": {
"uphold": {
"command": "uphold",
"args": ["mcp", "-s", "all"]
}
}
}From there, an agent can run prompts like:
Portfolio review"List my cards, total my portfolio in USD, and tell me what stands out."
Market watch"Watch BTCUSD, ETHUSD, and XRPUSD for 30 seconds. What are the pros and cons of each right now?"
Quote before commit"Create a quote from my USD card to BTC and explain the details before committing."
Same interfaceThese are examples of real workflows the tool was designed to handle.
The MCP layer automatically exposes command schemas, parameters, descriptions, and safety requirements.
Safe by Default
Financial operations need explicit safety layers. uphold-cli has two modes.
Guarded mode (default)Any command that can move funds requires acknowledged=true as an explicit parameter. The agent cannot accidentally commit a transaction without that confirmation. Dangerous tools are marked with [DANGEROUS: requires human confirmation] in their MCP descriptions so any agent reading the schema knows before calling.
Autonomous mode (--allow-dangerous)The confirmation requirement is lifted. This is the mode for pipelines where the human has already reviewed the logic and trusts the agent to execute without checkpoints.
The distinction is not cosmetic. It is the difference between a tool that is safe to connect to an agent running exploratory tasks, and one that is hardened for autonomous financial execution. The default mode optimizes for safety. Autonomous execution is an explicit choice.
Binaries are reproducible and verifiable. Secrets are never printed in CLI output. Config files are created with restricted permissions.
What the Command Surface Covers
Commands across six groups:
- ticker
- currencies
- configure
- account
- trade
- auth
The account group handles cards, addresses, and portfolio aggregation. The trade group covers the full quote and commit flow, including creating quotes, reviewing them, and committing only when ready. Public ticker and currency data requires no credentials. Authenticated flows use the same interface whether pointed at sandbox or live.
Sandbox mode is first-class. Point the CLI at Uphold's sandbox environment, fund a test account with test XRP, and run the full auth and transaction flow without touching real assets. The same commands, the same output format, no financial risk.
Why This Collaboration Made Sense
Uphold has the financial infrastructure. WakeUp Labs builds the systems layer that makes that infrastructure operable by machines.
This is not a generic integration. It took deliberate decisions about output formats, error taxonomy, safety flags, MCP tool schemas, and binary distribution to make something an AI agent can actually rely on in production. The kind of decisions that are invisible when they are right and catastrophic when they are wrong.
uphold-cli is the first milestone of a longer collaboration. The goal is bigger than a CLI: making Uphold natively accessible to the next generation of autonomous financial systems.
We look forward to sharing more details as the project evolves.
uphold-cli is an example of a broader shift: financial infrastructure designed not only for humans, but also for autonomous systems.
As AI agents become capable of executing increasingly complex workflows, the quality of the underlying interfaces becomes just as important as the capabilities of the models themselves. The next generation of financial infrastructure will need to be designed for both humans and machines.
WakeUp Labs designs, builds, and operates critical financial systems. From infrastructure to production operations, the focus is always the same: turn new capabilities into things that actually work.