We just shipped GoldRush CLI. It’s a terminal-first tool for blockchain data: 17 commands, 100+ chains, real-time streaming, and native MCP support for AI agents. One install, and you’ve got live onchain data in your terminal or piped directly into Claude.

Here’s what it is, why we built it, and where it’s going.

Why

The GoldRush API and SDK are powerful. But they assume you’re building something. Setting up a project, writing code, deploying. Sometimes you just need an answer. What’s in this wallet? What pairs just launched on Base? What’s gas doing on Ethereum right now?

We kept reaching for curl and jq. That felt wrong.

But the bigger reason is this: AI agents are the new consumers of blockchain data. Twenty percent of GoldRush API traffic already comes from LLMs and AI agents discovering our docs and endpoints. Agents don’t use dashboards. They don’t click through UIs. They need structured, streaming data through protocols like MCP, and they need it now, not after someone builds a wrapper.

The question we kept coming back to: what if the primary user of your API isn’t a person?

GoldRush CLI is our answer. One tool that serves both. Humans get a rich terminal with live charts, interactive tables, and formatted output. Agents get MCP tools with structured, streaming data. Same data. Two modes.

Removing Barriers, Layer by Layer

This isn’t a standalone launch. It’s the latest step in something we’ve been working toward for a while: systematically removing every barrier between builders and onchain data.

Step one: make it affordable for humans. Earlier this year we launched the $10/month Vibe Coding Plan. Not a discount tier. A low-friction entry point designed for solo founders, indie hackers, hackathon teams, and AI-native builders who need to iterate fast without overthinking infrastructure costs. The bottleneck shifted from writing code to iterating at speed. We priced accordingly.

Step two: make it permissionless for agents. We shipped x402 micropayments. No API keys. No accounts. No billing. Just a wallet. Agents discover endpoints at runtime, evaluate pricing, pay per request from their own wallets on Base. One request-response cycle. The infrastructure for economically autonomous AI.

Step three: give both an interface. That’s GoldRush CLI. The tool that connects the two worlds. Humans type commands and get rich terminal output. Agents call MCP tools and get structured responses. The data layer is the same. The interface adapts to who’s asking.

What It Does

Seventeen commands across portfolio management, market discovery, trading intelligence, and agent integration.

Portfolio & Wallets

goldrush balances <chain> <address> Full token portfolio across 100+ chains. ERC20s, native tokens, NFTs. USD values, 24h changes, everything in a formatted table.

goldrush transfers <address> <chain> Transfer history for any wallet. Inbound, outbound, token details.

goldrush watch <address> <chain> Real-time wallet activity streaming. Swaps, transfers, deposits, as they happen. This is the one you leave running in a tmux pane.

Market Discovery

goldrush new_pairs <chain> [protocols...] Live stream of new DEX liquidity pairs as they’re created. Supports 35+ protocol integrations across 9 chains: Uniswap V2/V3, PancakeSwap, Raydium, Pump.fun, Moonshot, Meteora, Orca, Shadow, Clanker, Virtuals, nad.fun, and more. Filter by protocol, navigate with arrow keys, copy addresses to clipboard.

goldrush ohlcv_pairs <pair> <chain> Live OHLCV candlestick charts rendered in ASCII. Configurable intervals from 1 second to 1 day. Yes, we put candlestick charts in a terminal. Yes, they update in real time.

Trading Intelligence

goldrush traders <token_address> <chain> Top traders for any token, ranked by unrealized PnL. See who’s accumulating, who’s dumping.

goldrush gas [chain] Real-time gas price estimates by transaction type. Quick check before you send.

goldrush search <query> Find any token by name, symbol, or contract address.

Utilities

The Agentic Core: MCP and the Three Loops

Here’s where it gets interesting.

GoldRush CLI is an MCP server. MCP (Model Context Protocol) is the open standard introduced by Anthropic that lets AI agents use external tools natively. When you run goldrush install, it registers GoldRush as a tool provider for Claude. The agent can then call GoldRush commands the same way it calls any other tool. No wrappers, no glue code.

But we didn’t just expose a bag of endpoints. We designed around three core loops that define how agents actually use blockchain data.

Loop 1: Continuous Market Monitoring

An agent subscribes to new_pairs. Every time a new liquidity pair launches on a chain, the agent receives it in real time: token details, liquidity, protocol, pair address. The agent evaluates, filters, scores, and decides whether to act. This runs continuously. Not a cron job. Not a polling interval. A live stream.

Loop 2: Wallet Surveillance

An agent watches specific wallets using watch. Whale wallets, smart money, protocol treasuries, MEV bots. Every swap, transfer, and deposit surfaces in real time. The agent identifies patterns: accumulation behavior, unusual outflows, cross-protocol movement. It can execute strategies like copy trading or generate alerts.

Loop 3: Portfolio Intelligence

An agent pulls balances on a schedule. It analyzes portfolio composition across chains, evaluates concentration risk, checks yield opportunities surfaced through new_pairs, and recommends or executes rebalancing.

The key insight: these aren’t one-shot queries. They’re persistent loops. Subscribe, process, act, repeat. That’s what makes GoldRush CLI a tool for agents, not just a CLI with an API.

What You Can Build

The pattern is consistent. GoldRush CLI provides the continuous data feed, the agent provides the intelligence and action. Here’s what builders are doing with it:

Agentic Risk Monitors. Transaction risk assessment agents that monitor wallets and flag suspicious activity in real time. Combine watch with anomaly detection models to catch scams, rug pulls, and exploits before they fully execute. Feed transaction patterns into ML classifiers that learn what “normal” looks like for a given wallet or protocol.

Wallet Risk Scoring. Agents that evaluate wallet activity history and assign risk scores. Useful for DeFi insurance underwriting, lending protocol eligibility, and compliance workflows. balancesand transfers feed into classification models that output a trust profile. How long has this wallet been active? What protocols does it interact with? What’s its transaction pattern?

DeFi Portfolio Optimization. Autonomous agents that reallocate assets across lending and yield protocols to maximize returns. balances for current state, new_pairs for new yield opportunities, ohlcv_pairs for price context. The agent continuously evaluates and rebalances without human intervention.

Onchain Identity and Reputation. Analyze wallet behavioral patterns across chains: transaction history, staking activity, protocol interactions, portfolio composition. Build reputation profiles useful for governance, credit scoring, and trust networks in decentralized systems.

These aren’t hypothetical. The infrastructure is live. The agents just need the data feed.

Agentic Workflows are Here

API for developers. SDK to make it easier to build. $10/month plan to remove the cost barrier. x402 micropayments to remove the account barrier. Now GoldRush CLI to remove the interface barrier.

AI agents that can discover data sources, evaluate pricing, pay from their own wallets, consume structured data, and act on it. No human in the loop. GoldRush CLI, the x402 proxy, and the MCP bridge are the working pieces of that system.

Get Started

Three commands:

For AI agents:

That’s it. Claude can now use GoldRush as a native tool.

Docs: goldrush.dev/docs

What’s Next

We’re not done. Here’s what’s coming:

• More MCP tools. Every CLI command becomes an agent-callable tool. The full surface area, not just a subset.

• Deeper streaming coverage. More chains, more DEXes, more event types. If it happens onchain, you should be able to subscribe to it.

• Agent-native workflows. Composable action chains where agents connect data retrieval to execution. Observe, decide, act, in one flow.

• x402 in the CLI. Agents pay for what they use directly. No API keys needed at all.

• Community commands. Open the CLI to community-contributed commands and plugins.

The terminal is the first interface. It won’t be the last.