Agentic Wallet Docs

The Bounty That Started It All

This library was born from the Superteam DAO Solana Agentic Wallet Bounty. The challenge was clear: create a prototype AI agent wallet that could autonomously manage crypto assets on Solana.

But we didn't just want to build another wallet. We saw a problem: every AI agent project was rewriting the same tools over and over for different chains and protocols. We built Agentic Wallet to solve that.

Why We Built This Library

The Problem: Rewriting Tools Over and Over

When we started exploring AI agents for Solana, we noticed something frustrating:

Every trading bot needed its own Jupiter integration
Every token launch tool reinvented Pump.fun interactions
Each agent framework (Vercel AI SDK, TanStack AI, MCP) needed custom implementations

The same DeFi operations: swaps, liquidity provision, token purchases—were being reimplemented countless times across different projects.

Our Solution: A Universal Tool Framework

We built Agentic Wallet to be the abstraction layer between AI agents and blockchain protocols:

AI Agent (any framework) → Agentic Wallet → Solana Protocols (Jupiter, Pump.fun, Raydium)

This means:

Write DeFi tools once - they're framework-agnostic
Swap AI frameworks easily - the wallet adapters handle it
Add new protocols - just create a new plugin

Key Design Decisions

Why We Don't Handle Keys

Security is paramount for autonomous agents. Rather than building our own key management (which would be a security liability), we designed the library to be key-agnostic and integrate with existing solutions.

The saw-cli example demonstrates this approach:

Uses environment variables for key injection
Supports hardware wallets via external signers
Allows custom signer implementations

This separation follows the principle of separation of concerns:

Wallet library handles protocol interactions
Key management is handled by dedicated solutions (external to the library)

Multi-Agent Support

One agent managing one wallet is simple. Ten agents each managing their own wallets requires proper isolation. We designed for multi-tenant scenarios:

Each wallet instance is independent
Tools are namespaced per wallet
RPC connections can be shared or isolated

Scoring Points on the Bounty Criteria

Here's how we addressed each judging criterion:

✅ Functional Demonstration

The saw-cli and trading-agent examples demonstrate:

Wallet creation programmatically
Automatic transaction signing (via key provider)
SOL and SPL token handling
Interaction with test DeFi protocols on devnet

✅ Security & Proper Key Management

No key storage in library - keys are provided at runtime by external key managers
Signer abstraction - allows hardware wallet integration
Environment-based secrets - follows 12-factor app principles
Sandboxed execution - agents operate in isolated contexts

✅ Clear Documentation

This entire docs site demonstrates:

Quick start guides
API references
Architecture explanation
Working examples

✅ Scalability: Multiple Agents

The library supports multiple agents through:

Stateless wallet instances
Connection pooling
Tool namespacing per wallet
Adapter pattern for different agent frameworks

Technical Highlights

Plugin System

Protocol integrations are packaged as plugins:

import { pumpfunPlugin, jupiterPlugin } from '@agentic-wallet/solana/plugin';

const wallet = new SolanaAgentWallet({...})
  .use(pumpfunPlugin())
  .use(jupiterPlugin());

Framework Adapters

Agents can use their preferred framework:

Vercel AI SDK - @agentic-wallet/adapters-vercel
TanStack AI - @agentic-wallet/adapters-tanstack
MCP - @agentic-wallet/adapters-mcp

Auto-Generated Tools

Every plugin automatically generates AI-friendly tools:

const tools = wallet.getTools();
// Returns: [{ name: "jupiter_swap", description: "...", parameters: {...} }]

What's Next

This is just the beginning. The architecture supports:

EVM chains - via chain-agnostic core
More DeFi protocols - new plugins
Smart contract interactions - generic program interfaces
Cross-chain swaps - multi-chain orchestration

Resources

CLI Example - Full autonomous agent example
MCP Example - Claude Desktop integration
Architecture - Deep dive
Plugin API - Building new integrations

Inspiration & Story