Skip to main content

​
What is Agentic Wallet?

Agentic Wallet is a production-ready infrastructure platform that enables AI agents to autonomously manage wallets and execute blockchain transactions on Solana devnet. It provides secure custody, policy enforcement, and multi-protocol interactions without agents ever handling private keys directly.

Quickstart

Get up and running in 5 minutes

Architecture

Understand the system design

API Reference

Explore the REST API

Integration Guide

Integrate with the SDK

​
Key Features

Secure Custody

Programmatic wallet creation with encrypted key storage. Multiple signer backends: encrypted-file, KMS, HSM, and MPC.

Policy Enforcement

Configurable spending limits, address allowlists, protocol restrictions, and approval gates before transaction signing.

Multi-Protocol Support

Built-in adapters for Jupiter, Marinade, Solend, Metaplex, Orca, Raydium, and custom Anchor escrow contracts.

AI Agent Runtime

Autonomous and supervised execution modes with capability manifests, budget controls, and backtesting.

Durable Execution

RPC failover, adaptive priority fees, retry logic, and SQLite-backed outbox queue for reliable transaction delivery.

Audit & Observability

Complete audit trails, execution proofs, metrics, and replay endpoints for compliance and debugging.

​
How It Works

Agentic Wallet separates concerns across multiple services to enforce security boundaries:
1

Agents Express Intents

AI agents submit high-level intents (e.g., “swap SOL for USDC”) via the API Gateway, without handling private keys or raw transactions.
2

Policy Evaluation

The Policy Engine evaluates all spend-capable intents against configured rules: spending limits, allowlists, rate limits, and risk controls.
3

Transaction Construction

Protocol Adapters build chain-specific transactions using real Solana programs (Jupiter for swaps, Marinade for staking, etc.).
4

Signing Boundary

Only the Wallet Engine signs transactions. Agents never receive key material. Multiple signer backends supported for production use.
5

Submission & Confirmation

The Transaction Engine submits to Solana RPC with failover, monitors confirmation, and generates immutable proof artifacts.

​
Architecture Overview

Agent / CLI / SDK / MCP
          |
          v
   API Gateway (auth, rate limiting, error normalization)
          |
          v
Transaction Engine
  -> build/simulate
  -> policy evaluation
  -> sign boundary (Wallet Engine)
  -> submit/confirm
  -> proof + audit
          |
          v
Solana RPC / Protocol Programs

​
Trust Boundaries

  • Agent Boundary: Agents emit intents only, never touch keys
  • Signing Boundary: Only wallet-engine signs transactions
  • Policy Boundary: All spend-capable intents pass policy evaluation before signing
  • Protocol Boundary: Adapter registry handles chain/protocol-specific build logic

​
Use Cases

Build trading bots that execute swaps, provide liquidity, and manage portfolios with configurable risk controls and budget limits.
Coordinate multiple agents with independent wallets and budgets, each with capability allowlists and treasury allocations.
Deploy custom Anchor escrow contracts and automate milestone-based releases, disputes, and refunds.
Enable language models to interact with DeFi protocols (staking, lending, swapping) through natural language intents.
Generate cryptographic proofs of execution, replay transaction pipelines, and maintain complete audit trails for regulatory compliance.

​
Get Started

Quick Start

Install dependencies, start the stack, and execute your first transaction in under 5 minutes.

Installation

Detailed setup instructions for local development and production deployments.

Configuration

Environment variables, service ports, signer backends, and RPC pool configuration.

Security Model

Learn about key isolation, policy gates, and capability governance.