How to Give Your AI Agent a Multi-Chain Crypto Wallet in 5 Minutes

The problem: agents without wallets are spectators

Most agent frameworks ship with no native financial capability. Developers end up stitching together separate SDKs for each chain, managing private keys manually, and writing custom swap logic for every DEX. A single cross-chain operation can require three or four different libraries, each with its own authentication model.

Coinbase recognized this gap and launched its Agentic Wallets product in late 2025, providing wallets with programmable guardrails. EmblemAI takes a different approach: a CLI-first tool that any agent framework can shell out to, with 200+ pre-built trading tools across 14 categories and support for Solana, Ethereum, Base, BSC, Polygon, Hedera, and Bitcoin out of the box.

Step 1: Install the CLI

EmblemAI ships as a global npm package. One command, no configuration files.

``` npm install -g @emblemvault/agentwallet ```

This installs the `emblemai` binary. It requires Node.js 18 or later. Verify the install:

``` emblemai --help ```

The package is open source and auditable. You can compare the published npm contents against the [GitHub repository](https://github.com/EmblemCompany/EmblemAi-AgentWallet) at any time using `npm pack --dry-run`.

Step 2: Authenticate your agent

EmblemAI supports two authentication modes. For interactive development, browser auth opens a login modal. For agents running in production, password auth works without a browser.

``` # Interactive mode -- opens browser for login emblemai # Agent mode -- zero-config, auto-generates a wallet emblemai --agent -m "What are my wallet addresses?" ```

Each password deterministically generates the same wallet every time. Different passwords produce different wallets. This means you can give each agent its own isolated wallet simply by assigning a unique password:

``` # Agent Alice gets her own wallet emblemai --agent -p "agent-alice-wallet-001" -m "What are my balances?" # Agent Bob gets a completely separate wallet emblemai --agent -p "agent-bob-wallet-002" -m "What are my balances?" ```

Credentials are encrypted at rest using AES-256-GCM via dotenvx. The encryption key never leaves the local machine.

Step 3: Query balances across all chains

Once authenticated, the agent has wallet addresses on every supported chain. A single natural-language query returns balances across all 7 blockchains simultaneously.

``` emblemai --agent -m "Show my balances across all chains" ```

The agent wallet provides addresses across these chain types:

| Chain | Address Type |

|-------|-------------|

| Solana | Native SPL wallet |

| Ethereum, Base, BSC, Polygon | Shared EVM address |

| Hedera | Account ID (0.0.XXXXXXX) |

| Bitcoin | Taproot, SegWit, and Legacy |

This is one wallet identity spanning 7 chains. No separate setup per chain. No bridge configuration.

Step 4: Execute your first swap

EmblemAI interprets natural language, so your agent does not need to construct raw transaction parameters. The tool handles routing, slippage, and gas estimation.

``` emblemai --agent -m "Swap 20 dollars worth of SOL to USDC on Solana" ```

The agent operates in safe mode by default. All wallet-modifying actions, including swaps, sends, transfers, and order placement, require explicit confirmation before execution. Read-only operations like balance checks and market data queries execute immediately.

For scripted pipelines, output can be piped to other tools:

``` emblemai --agent -m "What is my SOL balance?" | jq . ```

Step 5: Multi-chain operations

The real power is cross-chain. EmblemAI supports bridge operations via ChangeNow, DeFi position management, limit orders, and market data aggregation from CoinGlass, DeFiLlama, Birdeye, and LunarCrush.

``` # Cross-chain bridge emblemai --agent -m "Bridge 50 USDC from Ethereum to Solana" # DeFi operations emblemai --agent -m "What are the best yield opportunities for USDC right now?" # Market intelligence emblemai --agent -m "What tokens are trending on Solana today?" ```

The 200+ tools are organized into 14 categories: trading, DeFi, market data, NFTs, bridges, memecoins, predictions, and more. The AI dynamically selects the right tools based on the query. No manual tool configuration required.

Integration with any agent framework

Because `emblemai` is a CLI binary, any system that can shell out to a command can use it. This works with CrewAI, AutoGPT, LangChain agents, Claude with tool use, or custom Python scripts:

``` import subprocess import json def agent_wallet_query(message: str) -> str: result = subprocess.run( ["emblemai", "--agent", "-m", message], capture_output=True, text=True ) return result.stdout # Any agent can now trade balances = agent_wallet_query("Show my portfolio summary") ```

EmblemAI also provides an MCP (Model Context Protocol) server, which means Claude Code, GitHub Copilot, Gemini CLI, and other MCP-compatible tools can access wallet operations natively without shelling out. The platform additionally supports Google's A2A (Agent-to-Agent) protocol for direct agent interoperability.

What you get

EmblemAI provides 200+ autonomous trading tools across 7 blockchains in 14 categories, accessible through a single npm install. The deterministic wallet model means one password equals one persistent identity across all chains.

The package is open source, the credentials are encrypted at rest, and every transaction requires explicit human approval. Full documentation is available at [emblemvault.dev](https://emblemvault.dev), and the npm package is at [@emblemvault/agentwallet](https://www.npmjs.com/package/@emblemvault/agentwallet).