Launch AI Agents on Base - Base Documentation

AI Agents become exponentially more powerful when they’re onchain! By deploying AI agents on Base, you unlock access to stablecoins, tokens, NFTs, and a vast ecosystem of DeFi protocols. This significantly increases their autonomy and the universe of tasks they can perform, from automated trading to complex multi-step financial operations.

What You’ll Build

By the end of this guide, you’ll have deployed a fully functional AI agent that can:

Execute onchain transactions autonomously
Interact with DeFi protocols for trading and liquidity
Manage digital assets including tokens and NFTs
Respond to market conditions with intelligent automation

Onchain Autonomy

Agents can execute transactions, trade tokens, and interact with smart contracts

DeFi Integration

Access to DEXs, lending protocols, and yield farming opportunities

Asset Management

Manage portfolios, NFT collections, and cross-chain assets

Market Intelligence

Real-time market analysis and automated trading strategies

Prerequisites

Before launching your AI agent, ensure you have the following setup:

Development Environment

Choose your preferred development environment and ensure you have the necessary tools installed.

For Local Development:

Node.js 18+ or Python 3.10+
Git for repository management
Code editor (VS Code recommended)

For Replit (Browser-based):

Replit account for cloud development
No local installation required

Replit is perfect for quick prototyping, while local development gives you more control and flexibility.

API Keys and Credentials

Gather the required API keys for your AI agent:

Coinbase Developer Platform (CDP) API Key: Get your CDP credentials
OpenAI API Key: Create an OpenAI account for AI capabilities
Base Network Access: Your agent will operate on Base Sepolia testnet initially

Store all API keys securely and never commit them to version control. Use environment variables for all sensitive credentials.

Understanding Agent Frameworks

Choose the framework that best fits your needs:

LangChain: Full-featured framework with extensive integrations
Eliza: Lightweight, fast setup for simple agents

Each framework has different strengths. LangChain offers more customization, while Eliza provides rapid deployment.

Choose Your Agent Framework

Select the framework and environment that best matches your development preferences and project requirements:

LangChain provides a comprehensive framework for building sophisticated AI agents with extensive tooling and integrations.

Best for: Complex agents requiring custom tools, advanced reasoning, and extensive integrations with external services.

Development Environment

Perfect for getting started quickly without local setup requirements.

LangChain Replit Setup

Set Up Your Development Environment

Fork the template from our NodeJS or Python Replit templates.
Modify your forked project as needed.

Configure Environment Variables

Click on “Tools” in the left sidebar and select “Secrets”.
Add the following secrets:

CDP_API_KEY_NAME=your_cdp_key_name
CDP_API_KEY_PRIVATE_KEY=your_cdp_private_key
OPENAI_API_KEY=your_openai_key # Or XAI_API_KEY if using NodeJS
NETWORK_ID="base-sepolia" # Optional, defaults to base-sepolia
MNEMONIC_PHRASE=your_mnemonic_phrase # Optional

Run the Agent

Click the “Run” button to start the chatbot.

Security of wallets on Replit

Every agent comes with an associated wallet. Wallet data is read from wallet_data.txt, and if that file does not exist, this repl will create a new wallet and persist it in a new file. Please note that this contains your wallet’s private key and should not be used in production environments. Refer to the CDP docs on how to secure your wallets.

Replit Advantages:

No local environment setup required
Built-in collaboration features
Automatic deployment and hosting
Great for learning and prototyping

Perfect for getting started quickly without local setup requirements.

LangChain Replit Setup

Set Up Your Development Environment

Fork the template from our NodeJS or Python Replit templates.
Modify your forked project as needed.

Configure Environment Variables

Click on “Tools” in the left sidebar and select “Secrets”.
Add the following secrets:

CDP_API_KEY_NAME=your_cdp_key_name
CDP_API_KEY_PRIVATE_KEY=your_cdp_private_key
OPENAI_API_KEY=your_openai_key # Or XAI_API_KEY if using NodeJS
NETWORK_ID="base-sepolia" # Optional, defaults to base-sepolia
MNEMONIC_PHRASE=your_mnemonic_phrase # Optional

Run the Agent

Click the “Run” button to start the chatbot.

Security of wallets on Replit

Replit Advantages:

No local environment setup required
Built-in collaboration features
Automatic deployment and hosting
Great for learning and prototyping

Recommended for production applications and advanced customization.

LangChain Local Environment Setup

TypeScript

Set Up Your Development Environment

Terminal

node --version  # Should be 18+
npm --version   # Should be 9.7.2+

Clone and Set Up the Repository

Terminal

git clone https://github.com/coinbase/agentkit.git
cd agentkit
npm install
npm run build
cd typescript/examples/langchain-cdp-chatbot

Configure Environment Variables

Terminal

cp .env.local .env

Run the Agent

Terminal

npm run start

Python

Set Up Your Development Environment

Terminal

python --version  # Should be 3.10+
poetry --version # Verify Poetry installation

Clone and Set Up the Repository

Terminal

git clone https://github.com/coinbase/agentkit.git
cd agentkit/python/examples/cdp-langchain-chatbot

Configure Environment Variables

Terminal

cp .env.local .env
# Edit .env with your credentials

Run the Agent

Terminal

poetry install
poetry run python main.py

Local Development Advantages:

Full control over your environment
Better performance for intensive operations
Easier integration with existing toolchains
Enhanced security for production applications

Advanced LangChain Features

Once your basic agent is running, you can enhance it with:

Custom Tools and Actions

# Example: Custom DeFi interaction tool
from cdp_langchain.tools import CdpTool

class CustomDeFiTool(CdpTool):
    def __init__(self):
        super().__init__(
            name="defi_analyzer",
            description="Analyze DeFi opportunities on Base"
        )

Memory and Persistence

# Add memory to your agent
from langchain.memory import ConversationBufferWindowMemory

memory = ConversationBufferWindowMemory(
    k=10,  # Remember last 10 interactions
    return_messages=True
)

Multi-Agent Coordination

# Coordinate multiple specialized agents
trading_agent = create_trading_agent()
portfolio_agent = create_portfolio_agent()

# Orchestrate agents for complex strategies
coordinator = AgentCoordinator([trading_agent, portfolio_agent])

LangChain provides a comprehensive framework for building sophisticated AI agents with extensive tooling and integrations.

Best for: Complex agents requiring custom tools, advanced reasoning, and extensive integrations with external services.

Development Environment

Perfect for getting started quickly without local setup requirements.

LangChain Replit Setup

Set Up Your Development Environment

Fork the template from our NodeJS or Python Replit templates.
Modify your forked project as needed.

Configure Environment Variables

Click on “Tools” in the left sidebar and select “Secrets”.
Add the following secrets:

CDP_API_KEY_NAME=your_cdp_key_name
CDP_API_KEY_PRIVATE_KEY=your_cdp_private_key
OPENAI_API_KEY=your_openai_key # Or XAI_API_KEY if using NodeJS
NETWORK_ID="base-sepolia" # Optional, defaults to base-sepolia
MNEMONIC_PHRASE=your_mnemonic_phrase # Optional

Run the Agent

Click the “Run” button to start the chatbot.

Security of wallets on Replit

Replit Advantages:

No local environment setup required
Built-in collaboration features
Automatic deployment and hosting
Great for learning and prototyping

Perfect for getting started quickly without local setup requirements.

LangChain Replit Setup

Set Up Your Development Environment

Fork the template from our NodeJS or Python Replit templates.
Modify your forked project as needed.

Configure Environment Variables

Click on “Tools” in the left sidebar and select “Secrets”.
Add the following secrets:

CDP_API_KEY_NAME=your_cdp_key_name
CDP_API_KEY_PRIVATE_KEY=your_cdp_private_key
OPENAI_API_KEY=your_openai_key # Or XAI_API_KEY if using NodeJS
NETWORK_ID="base-sepolia" # Optional, defaults to base-sepolia
MNEMONIC_PHRASE=your_mnemonic_phrase # Optional

Run the Agent

Click the “Run” button to start the chatbot.

Security of wallets on Replit

Replit Advantages:

No local environment setup required
Built-in collaboration features
Automatic deployment and hosting
Great for learning and prototyping

Recommended for production applications and advanced customization.

LangChain Local Environment Setup

TypeScript

Set Up Your Development Environment

Terminal

node --version  # Should be 18+
npm --version   # Should be 9.7.2+

Clone and Set Up the Repository

Terminal

git clone https://github.com/coinbase/agentkit.git
cd agentkit
npm install
npm run build
cd typescript/examples/langchain-cdp-chatbot

Configure Environment Variables

Terminal

cp .env.local .env

Run the Agent

Terminal

npm run start

Python

Set Up Your Development Environment

Terminal

python --version  # Should be 3.10+
poetry --version # Verify Poetry installation

Clone and Set Up the Repository

Terminal

git clone https://github.com/coinbase/agentkit.git
cd agentkit/python/examples/cdp-langchain-chatbot

Configure Environment Variables

Terminal

cp .env.local .env
# Edit .env with your credentials

Run the Agent

Terminal

poetry install
poetry run python main.py

Local Development Advantages:

Full control over your environment
Better performance for intensive operations
Easier integration with existing toolchains
Enhanced security for production applications

Advanced LangChain Features

Once your basic agent is running, you can enhance it with:

Custom Tools and Actions

# Example: Custom DeFi interaction tool
from cdp_langchain.tools import CdpTool

class CustomDeFiTool(CdpTool):
    def __init__(self):
        super().__init__(
            name="defi_analyzer",
            description="Analyze DeFi opportunities on Base"
        )

Memory and Persistence

# Add memory to your agent
from langchain.memory import ConversationBufferWindowMemory

memory = ConversationBufferWindowMemory(
    k=10,  # Remember last 10 interactions
    return_messages=True
)

Multi-Agent Coordination

# Coordinate multiple specialized agents
trading_agent = create_trading_agent()
portfolio_agent = create_portfolio_agent()

# Orchestrate agents for complex strategies
coordinator = AgentCoordinator([trading_agent, portfolio_agent])

Eliza offers the fastest path to deploying AI agents with minimal configuration and maximum speed.

Best for: Quick deployments, simple autonomous agents, and rapid prototyping with immediate results.

Eliza Framework Setup

The fastest way to get started with Eliza is by using the create-agentkit-app CLI:

Terminal

npx create-agentkit-app my-agent
cd my-agent
cp .env.example .env
pnpm install
pnpm start

For additional support, check out the video tutorial.

Eliza Framework Benefits

Rapid Deployment

Get your agent running in under 5 minutes with the CLI tool

Minimal Configuration

Pre-configured templates for common agent patterns

Built-in Integrations

Native support for popular onchain actions and APIs

Community Templates

Access to pre-built agent templates from the community

Extending Your Eliza Agent

Add Custom Actions

Extend your agent’s capabilities by adding custom onchain actions:

// Add to your agent's action registry
export const customActions = [
  {
    name: "YIELD_FARM",
    description: "Automatically farm yield on Base protocols",
    handler: async (params) => {
      // Your yield farming logic
    }
  }
];

Configure Trading Strategies

Implement automated trading strategies:

export const tradingConfig = {
  strategies: ["DCA", "MOMENTUM", "ARBITRAGE"],
  riskLevel: "MODERATE",
  maxSlippage: 0.01
};

Set Up Monitoring

Add monitoring and alerts for your agent:

export const monitoringConfig = {
  alerts: {
    lowBalance: true,
    failedTx: true,
    profitTarget: 0.05
  }
};

Testing Your AI Agent

Before deploying to mainnet, thoroughly test your agent’s capabilities:

Testnet Validation

Test all functions on Base Sepolia testnet:

Wallet Operations: Create wallets, check balances, transfer tokens
DeFi Interactions: Test swaps, liquidity provision, lending
NFT Operations: Mint, transfer, and trade NFTs
Error Handling: Ensure graceful handling of failed transactions

Your agent should handle all basic operations without errors before proceeding.

Performance Testing

Evaluate agent performance under various conditions:

Response time to market changes
Transaction success rates
Gas optimization effectiveness
Resource utilization

Monitor your agent’s performance metrics to identify optimization opportunities.

Security Audit

Verify security measures are in place:

API keys are properly secured
Wallet private keys are encrypted
Rate limiting is implemented
Transaction limits are configured

Never deploy to mainnet without proper security auditing. Consider professional security reviews for high-value operations.

Deployment and Monitoring

Production Deployment

Deploy your agent to a production environment:

# Deploy to cloud provider
npm run build
npm run deploy:production

# Set production environment variables
export CDP_API_KEY_NAME="your_production_key"
export NETWORK_ID="base-mainnet"

# Deploy to cloud provider
npm run build
npm run deploy:production

# Set production environment variables
export CDP_API_KEY_NAME="your_production_key"
export NETWORK_ID="base-mainnet"

# Set up production server
pm2 start ecosystem.config.js
pm2 startup
pm2 save

# Configure monitoring
pm2 install pm2-logrotate

Ensure your deployment includes proper logging, monitoring, and backup systems.

Monitoring and Alerts

Set up comprehensive monitoring:

Transaction Monitoring: Track success rates and gas usage
Performance Metrics: Monitor response times and throughput
Financial Tracking: Watch portfolio performance and P&L
System Health: Monitor server resources and uptime

Use tools like Grafana, DataDog, or custom dashboards to visualize your agent’s performance.

Troubleshooting

Agent Not Responding

Transaction Failures

Performance Issues

Security Concerns

Advanced Use Cases

Explore advanced patterns for sophisticated AI agents:

Arbitrage Bot

Build agents that identify and execute arbitrage opportunities across DEXs

Portfolio Manager

Create agents that rebalance portfolios based on market conditions

Yield Optimizer

Deploy agents that automatically find and compound the best yields

NFT Trader

Develop agents that analyze and trade NFTs based on market trends

Next Steps

Expand your AI agent’s capabilities:

Integrate Additional Protocols

Connect your agent to more DeFi protocols:

Uniswap for advanced trading strategies
Aave for lending and borrowing
Compound for yield generation
1inch for optimal trade routing

Implement Advanced Strategies

Build sophisticated trading and management strategies:

Dollar-cost averaging (DCA) algorithms
Mean reversion trading
Momentum-based strategies
Risk-adjusted portfolio rebalancing

Add Cross-Chain Capabilities

Extend your agent across multiple chains:

Ethereum for additional DeFi access
Polygon for low-cost operations
Arbitrum for advanced trading
Cross-chain bridging automation

Resources and Community

CDP AgentKit Documentation

Complete documentation for building agents with CDP

Base Developer Discord

Connect with other developers building AI agents on Base

GitHub Repository

Access source code, examples, and contribute to the project

Video Tutorials

Watch step-by-step tutorials for agent development

Conclusion

Congratulations! You’ve successfully launched an AI agent on Base with full onchain capabilities. Your agent can now:

✅ Execute autonomous transactions with real-world financial impact
✅ Interact with DeFi protocols for advanced financial operations
✅ Manage digital assets including tokens and NFTs
✅ Respond intelligently to market conditions and opportunities

Ready for production? Consider implementing advanced monitoring, security audits, and gradual scaling as your agent proves its effectiveness in live markets.

Your AI agent is now part of the onchain economy, ready to operate 24/7 in the world of decentralized finance. Happy building on Base!

Use Cases

Build with AI

​What You’ll Build

Onchain Autonomy

DeFi Integration

Asset Management

Market Intelligence

​Prerequisites

​Choose Your Agent Framework

​Development Environment

​LangChain Replit Setup

​LangChain Replit Setup

​LangChain Local Environment Setup

​TypeScript

​Python

​Advanced LangChain Features

​Development Environment

​LangChain Replit Setup

​LangChain Replit Setup

​LangChain Local Environment Setup

​TypeScript

​Python

​Advanced LangChain Features

​Eliza Framework Setup

​Eliza Framework Benefits

Rapid Deployment

Minimal Configuration

Built-in Integrations

Community Templates

​Extending Your Eliza Agent

​Testing Your AI Agent

​Deployment and Monitoring

​Troubleshooting

​Advanced Use Cases

Arbitrage Bot

Portfolio Manager

Yield Optimizer

NFT Trader

​Next Steps

​Resources and Community

CDP AgentKit Documentation

Base Developer Discord

GitHub Repository

Video Tutorials

​Conclusion

What You’ll Build

Prerequisites

Choose Your Agent Framework

Development Environment

LangChain Replit Setup

LangChain Replit Setup

LangChain Local Environment Setup

TypeScript

Python

Advanced LangChain Features

Development Environment

LangChain Replit Setup

LangChain Replit Setup

LangChain Local Environment Setup

TypeScript

Python

Advanced LangChain Features

Eliza Framework Setup

Eliza Framework Benefits

Extending Your Eliza Agent

Testing Your AI Agent

Deployment and Monitoring

Troubleshooting

Advanced Use Cases

Next Steps

Resources and Community

Conclusion