From AgentKit to Agentic Wallets: The Evolution of Coinbase's AI Infrastructure

AgentKit is Coinbase's November 2024 toolkit for building wallet capabilities into AI agents during development, while Agentic Wallets (launched February 2026) provide plug-and-play wallet infrastructure that gives any existing agent autonomous financial capabilities in under 2 minutes. The key difference lies in integration timing: AgentKit requires embedding wallet functionality during agent creation for custom implementations, while Agentic Wallets attach to already-built agents as an external service, reflecting the shift from developers building agents from scratch to rapid agent deployment through no-code and low-code platforms.

What You'll Learn

  • AgentKit's role in building wallets directly into agents
  • How Agentic Wallets differ with instant plug-and-play deployment
  • Key differences in development time, complexity, and use cases
  • Choosing the right tool for your agent development needs
  • Using AgentKit and Agentic Wallets together for hybrid architectures

AgentKit: Build Wallets Into Agents

AgentKit launched in November 2024 as Coinbase Developer Platform's first AI agent infrastructure product. The toolkit enables developers to build wallet capabilities directly into their agents during the development process.

What Is AgentKit?

AgentKit is a framework-agnostic SDK providing building blocks for AI agents to interact with crypto wallets and blockchain networks. Developers import AgentKit libraries into their agent codebases and construct custom wallet integration.

Core AgentKit capabilities:

  • Wallet creation and management: Generate wallets programmatically during agent initialization
  • Transaction construction: Build and sign blockchain transactions using agent-controlled keys
  • Smart contract interaction: Call DeFi protocol functions, deploy contracts, interact with NFTs
  • Multi-chain support: Works across Ethereum, Base, Solana, and other networks
  • Framework flexibility: Integrates with LangChain, CrewAI, AutoGen, custom frameworks

Architecture approach: AgentKit embeds wallet logic as part of the agent's core functionality. The wallet is not a separate service; it's a component within the agent's codebase.

How AgentKit Works

Development workflow:

Step 1: Install AgentKit SDK

npm install @coinbase/agentkit

or

pip install coinbase-agentkit

Step 2: Initialize wallet in agent code

from coinbase_agentkit import Wallet

Agent initializes its own wallet during startup

agent_wallet = Wallet.create(
network="base",
seed_phrase=generate_secure_seed() # Developer manages seed generation
)

Wallet is now part of agent's state

agent.wallet = agent_wallet

Step 3: Implement custom transaction logic

Developer writes transaction construction code

def execute_trade(from_token, to_token, amount):
# Construct swap transaction
tx = build_dex_swap(
from_token=from_token,
to_token=to_token,
amount=amount,
slippage=0.5
) 

# Sign with agent's wallet  
signed_tx \= agent.wallet.sign_transaction(tx)  
  
# Broadcast to network  
tx_hash \= agent.wallet.broadcast(signed_tx)  
  
return tx_hash

Step 4: Handle key management Developers are responsible for:

  • Secure seed phrase generation and storage
  • Private key encryption
  • Backup and recovery mechanisms
  • Key rotation policies

AgentKit Use Cases

AgentKit excels for developers building sophisticated, customized agent infrastructure:

Custom DeFi strategies: Building agents with complex trading logic, multi-protocol strategies, or proprietary algorithms. Example: Arbitrage bot that simultaneously monitors 15 DEXs and executes atomic cross-chain trades.

Smart contract deployment: Agents that autonomously deploy and manage smart contracts. Example: DAO treasury management agent that deploys new vesting contracts based on governance proposals.

NFT marketplace automation: Agents interacting with NFT platforms for minting, trading, or collection management. Example: Generative art agent that mints NFTs automatically when it creates new pieces.

Protocol integration: Deep integration with specific DeFi protocols requiring custom ABI interactions. Example: Automated liquidity provider agent optimizing positions on Uniswap v4 with custom hooks.

Research and experimentation: Academic or research projects exploring agent behavior in crypto contexts. Example: Multi-agent simulation studying emergent economic behavior in on-chain games.

AgentKit Development Investment

Time to functional wallet: 2-4 hours for basic wallet integration, 20-40 hours for production-ready implementation with security, error handling, and monitoring.

Required expertise:

  • Blockchain fundamentals (transactions, gas, signing)
  • Smart contract interaction (ABIs, encoding)
  • Security best practices (key management, encryption)
  • Specific DeFi protocol knowledge (for protocol integrations)

Ongoing maintenance:

  • Protocol updates require code changes
  • Network upgrades need compatibility testing
  • Security patches for dependencies
  • Key rotation and access management

Agentic Wallets: Give Any Agent a Wallet

Agentic Wallets launched in February 2026 as a response to the democratization of agent development. By 2026, no-code platforms, AI model improvements, and agent frameworks made it possible for non-developers to create agents. These users needed wallet capabilities but lacked the technical skills to use AgentKit.

What Are Agentic Wallets?

Agentic Wallets are managed wallet infrastructure external to the agent. Instead of building wallet code into the agent, developers provision a pre-configured wallet and give the agent API credentials to access it.

Core characteristics:

  • Plug-and-play deployment: Wallet operational in under 2 minutes via CLI
  • No code integration: Agent accesses wallet through simple API calls or MCP
  • Managed key security: Coinbase infrastructure handles all key management
  • Pre-built skills: Trade, earn, send capabilities ready to use
  • Spending guardrails: Session caps and transaction limits configurable without code

Architecture approach: Agentic Wallets operate as external services. The wallet exists independently of the agent's code. The agent connects to the wallet service and invokes operations through APIs.

How Agentic Wallets Work

Deployment workflow:

Step 1: Provision wallet via CLI (30 seconds)

cdp agent create --email agent@example.com

Returns: Agent ID and wallet address

Step 2: Fund wallet (30 seconds)

Transfer USDC to provided address

Check balance

cdp agent balance

Step 3: Configure guardrails (30 seconds)

cdp agent config set-limits \
--session-cap 500 \
--transaction-limit 100

Step 4: Agent invokes wallet operations (from agent code)

Agent uses simple API calls - no transaction construction needed

from coinbase_cdp import AgenticWallet

wallet = AgenticWallet.from_credentials("~/.cdp/credentials.json")

Pre-built skill abstracts all complexity

wallet.send(
to="0x1234...abcd",
amount=10,
currency="USDC"
)

Key management: Fully handled by Coinbase infrastructure. Developer never sees private keys, manages seed phrases, or implements encryption. Keys reside in Trusted Execution Environments.

Agentic Wallet Use Cases

Agentic Wallets excel for rapid deployment and standard financial operations:

AI assistant with payments: ChatGPT-style agent that needs to pay for APIs or services on behalf of users. Example: Personal AI assistant that pays for premium data feeds when researching investment opportunities.

No-code agent builders: Non-developers creating agents through platforms like Make, Zapier, or custom chat interfaces. Example: Marketing manager creating social media agent that pays for image generation APIs.

Autonomous DeFi yield farming: Agents rebalancing between lending protocols for optimal returns. Example: Set-it-and-forget-it yield optimizer monitoring Aave, Compound, Morpho and rebalancing daily.

M2M payment automation: Agents paying other agents for services. Example: Data analysis agent purchasing datasets from data provider agents.

Rapid prototyping: Testing agent concepts quickly without building full wallet infrastructure. Example: Weekend hackathon project testing agent-driven prediction market strategies.

Agentic Wallet Development Investment

Time to functional wallet: Under 2 minutes for basic operations, under 30 minutes for production configuration with monitoring.

Required expertise:

  • Basic CLI familiarity
  • Understanding of spending limits and guardrails
  • No blockchain expertise required
  • No smart contract knowledge needed

Ongoing maintenance:

  • Minimal (Coinbase manages infrastructure)
  • Spending limit adjustments via CLI
  • Monitoring through CDP Portal dashboard

Key Differences Between AgentKit and Agentic Wallets

Aspect AgentKit Agentic Wallets
Launch date November 2024 February 2026
Integration point During agent development After agent exists
Setup time 2-40 hours Under 2 minutes
Code required Extensive (wallet logic in agent code) Minimal (API calls only)
Key management Developer responsibility Coinbase managed (TEEs)
Customization Unlimited (full control) Limited to pre-built skills
Security model Developer implements Infrastructure enforced
Spending controls Developer codes logic Config-based guardrails
Protocol support Any (developer builds) Pre-integrated protocols
Smart contract deployment Yes No
Custom ABIs Yes No (standard operations only)
Multi-chain Yes (developer implements) Yes (Base, EVM, Solana)
Gasless transactions No (unless developer codes) Yes on Base
Maintenance burden High (developer maintains) Low (Coinbase maintains)
Best for Custom strategies, research Standard operations, rapid deployment
Target user Experienced blockchain developers All developers, non-developers
Pricing model Free SDK Free (infrastructure costs absorbed)

Choosing the Right Tool

The decision between AgentKit and Agentic Wallets depends on your specific requirements, timeline, and expertise.

Choose AgentKit When:

1. You need custom smart contract interactions Building agents that deploy contracts, interact with custom ABIs, or perform complex on-chain operations not available as pre-built skills.

Example: Agent that deploys and manages multi-signature wallets for DAO treasury management with custom proposal logic.

2. You require full control over transaction construction Implementing proprietary trading strategies, MEV protection, or specialized transaction bundling.

Example: High-frequency trading bot that constructs atomic arbitrage transactions across multiple DEXs with precise gas optimization.

3. You have blockchain development expertise Team includes developers comfortable with Web3 concepts, transaction signing, and protocol integration.

Example: DeFi protocol team building agent-based liquidation protection for their lending platform.

4. You're building commercial products with unique requirements Creating differentiated agent products where wallet behavior is a key competitive advantage.

Example: Startup building AI wealth management platform with proprietary rebalancing algorithms.

5. You need protocol interactions not yet supported by Agentic Wallets Working with bleeding-edge protocols, testnet deployments, or chains not yet integrated.

Example: Research project testing agent behavior on experimental L2s or new DeFi primitives.

Choose Agentic Wallets When:

1. You want rapid deployment Need wallet capabilities in minutes, not hours or days.

Example: Hackathon project testing agent concept over a weekend.

2. Your use cases fit pre-built skills Agent needs standard operations: send, trade, earn (lending/staking), without custom logic.

Example: Yield optimization agent that rebalances between Aave, Compound, and Morpho based on APY differentials.

3. You lack blockchain development expertise Team focused on AI/ML, not Web3. Want to avoid learning transaction construction, gas mechanics, or key management.

Example: Machine learning researcher building agent for autonomous trading research without blockchain background.

4. Security is paramount and you want infrastructure-managed keys Prefer Coinbase's TEE-based key management over implementing your own secure key storage.

Example: Enterprise deploying agents for customer-facing financial services where key compromise would be catastrophic.

5. You're targeting non-developer users Building platforms where end users create agents without coding.

Example: No-code agent builder platform where marketing professionals create social media management agents that pay for image generation.

Using AgentKit and Agentic Wallets Together

Both tools can coexist in hybrid architectures, with each handling different aspects of agent operations.

Hybrid Architecture Pattern

AgentKit for specialized operations:

  • Custom smart contract deployments
  • Complex DeFi protocol interactions
  • Proprietary transaction logic

Agentic Wallets for standard operations:

  • Routine payments to service providers
  • Standard token swaps
  • Simple send transactions

Example implementation:

Agent has both AgentKit wallet and Agentic Wallet

from coinbase_agentkit import Wallet as CustomWallet
from coinbase_cdp import AgenticWallet

AgentKit wallet for custom operations

custom_wallet = CustomWallet.from_seed(seed_phrase)

Agentic Wallet for standard operations

managed_wallet = AgenticWallet.from_credentials(credentials_path)

Specialized operation: Deploy custom contract

def deploy_strategy_contract():
# Use AgentKit for custom smart contract deployment
contract = custom_wallet.deploy_contract(
bytecode=strategy_bytecode,
constructor_args=[param1, param2]
)
return contract.address

Standard operation: Pay for API access

def pay_for_api_call(amount):
# Use Agentic Wallet for simple payment
managed_wallet.send(
to=api_provider_address,
amount=amount,
currency="USDC"
)

Risk Segregation Pattern

Use separate wallets for different risk profiles:

High-risk experimental strategies → AgentKit wallet with small allocation Custom DeFi strategies, new protocol testing, research experiments.

Low-risk routine operations → Agentic Wallet with main allocation Standard yield farming, API payments, known-good protocols.

Benefit: If experimental AgentKit wallet is compromised or buggy, main funds in Agentic Wallet remain protected by infrastructure guardrails.

Development-to-Production Pattern

Development phase: Use AgentKit for rapid iteration and custom logic development

Production phase: Migrate standard operations to Agentic Wallets for infrastructure-managed security

Example workflow:

  1. Developer builds custom yield strategy using AgentKit
  2. Tests thoroughly in development environment
  3. Identifies which operations are standard (send, trade) vs custom (complex strategy execution)
  4. Migrates standard operations to Agentic Wallet in production
  5. Keeps custom strategy logic in AgentKit wallet with strict limits
  6. Benefits from infrastructure security for 80% of operations while retaining 20% custom capability

The Evolution: Why Agentic Wallets Emerged

Understanding the timeline helps explain why Coinbase built two different tools.

November 2024: AgentKit Launch

Market context: AI agents were primarily developer projects. Creating an agent required:

  • Python or JavaScript programming skills
  • Understanding of LLM APIs and prompting
  • System design expertise for multi-step workflows
  • Deployment and hosting knowledge

Target audience: Software engineers and researchers exploring agent capabilities.

AgentKit fit: Developers capable of integrating AgentKit could also handle wallet code complexity. The SDK approach matched developer expectations.

2025: Agent Democratization

Market shifts:

  • No-code agent platforms emerged (Make, Zapier, n8n with AI nodes)
  • LLM improvements made prompt-based agent creation viable for non-developers
  • Pre-built agent frameworks (AutoGen, CrewAI) lowered technical barriers
  • Consumer AI tools (ChatGPT plugins, Claude skills) enabled non-technical agent creation

New user profile: Marketers, analysts, business users creating agents without coding.

Gap identified: These users needed wallet capabilities but couldn't integrate AgentKit.

February 2026: Agentic Wallets Launch

Product insight: "Every agent needs a wallet" requires wallet infrastructure accessible to non-developers.

Design principle: Wallet as a service, not as embedded code. Agent connects to external wallet infrastructure rather than integrating wallet logic.

Target expansion: From blockchain developers (AgentKit) to all agent creators (Agentic Wallets).

Erik Reppel, head of engineering for CDP: "Now with agents being easier than ever to spin up, we're introducing Agentic Wallets to give any agent a wallet."

Migration Guide: AgentKit to Agentic Wallets

If you built agents with AgentKit and want to migrate standard operations to Agentic Wallets:

Step 1: Audit Current Wallet Usage

Identify which operations are:

  • Standard: Send, basic trades, protocol deposits/withdrawals
  • Custom: Smart contract deployments, complex ABIs, specialized logic

Step 2: Provision Agentic Wallet

cdp agent create --email production-agent@company.com
cdp agent config set-limits --session-cap 5000 --transaction-limit 1000

Step 3: Migrate Standard Operations

Before (AgentKit):

def send_payment(recipient, amount):
tx = agent_wallet.build_transfer(recipient, amount)
signed = agent_wallet.sign(tx)
return agent_wallet.broadcast(signed)

After (Agentic Wallet):

def send_payment(recipient, amount):
return managed_wallet.send(to=recipient, amount=amount, currency="USDC")

Step 4: Maintain AgentKit for Custom Operations

Keep AgentKit wallet for operations requiring custom logic. Reduce its funding to match custom operation needs only.

Step 5: Monitor Both Wallets

Use CDP Portal for Agentic Wallet monitoring. Maintain existing monitoring for AgentKit wallet.

Frequently Asked Questions

Q: Can I use both AgentKit and Agentic Wallets in the same agent? Yes. Agents can have multiple wallets. Use AgentKit for custom operations and Agentic Wallets for standard operations. This hybrid approach provides flexibility where needed and infrastructure security for routine tasks.

Q: If I start with Agentic Wallets, can I migrate to AgentKit later? Yes, though it requires development work. You'll need to implement custom wallet logic to replace Agentic Wallet operations. Transfer funds from Agentic Wallet to your AgentKit wallet. This migration makes sense if you outgrow pre-built skills and need custom capabilities.

Q: Are AgentKit and Agentic Wallets compatible with the same AI frameworks? Yes. Both work with LangChain, CrewAI, AutoGen, OpenAI function calling, and custom frameworks. The integration points differ (embedded code vs external API) but both support framework-agnostic implementation.

Q: Which approach is more secure? Depends on implementation quality. AgentKit requires developers to implement security correctly (key management, encryption, access control). Agentic Wallets provide infrastructure-managed security (TEEs, spending limits) but less control. For most developers, infrastructure-managed security (Agentic Wallets) is more secure because it removes implementation risk.

Q: Can Agentic Wallets deploy smart contracts? No. Smart contract deployment requires custom transaction construction not available in pre-built skills. Use AgentKit if your agent needs to deploy contracts.

Q: What's the pricing difference between AgentKit and Agentic Wallets? Both are free to use. AgentKit is an open-source SDK with no fees. Agentic Wallets are free infrastructure with Coinbase absorbing operational costs (including gasless transactions on Base). Revenue model for both is protocol-level transaction fees, not infrastructure access fees.

Q: If Agentic Wallets are easier, why would anyone use AgentKit? AgentKit provides capabilities Agentic Wallets don't: custom smart contract interaction, specialized transaction construction, protocol integrations not yet in pre-built skills, and full control over wallet behavior. Teams building differentiated products need these capabilities despite higher complexity.

Q: How does Coinbase decide what skills to add to Agentic Wallets? Based on common use cases observed in AgentKit implementations and developer feedback. Future skills will likely include: NFT minting/trading, governance voting, bridging, staking variations, and protocol-specific integrations as demand warrants.

{
"@context": "https://schema.org",
"@type": "Article",
"headline": "From AgentKit to Agentic Wallets: The Evolution of Coinbase's AI Infrastructure",
"description": "Comprehensive comparison of AgentKit and Agentic Wallets, explaining when to use each Coinbase tool for AI agent wallet integration.",
"author": {
"@type": "Organization",
"name": "Coinbase Developer Platform"
},
"publisher": {
"@type": "Organization",
"name": "Coinbase"
},
"datePublished": "2026-02-15",
"keywords": "AgentKit, Agentic Wallets, Coinbase, AI agents, crypto wallets"
}