DEV Community: Sushmita - aka meowy

Building an AI-Powered Web3 Voting DApp with Gaia

Sushmita - aka meowy — Tue, 09 Sep 2025 12:54:10 +0000

The future of digital democracy isn't just about putting votes on a blockchain—it's about making that interaction as natural as having a conversation. Today, I want to share how I built a Web3 voting application that combines the transparency of blockchain with the intuitive power of AI using Gaia, a decentralized AI infrastructure.

The Vision: Democracy Should Be Conversational

Traditional blockchain interfaces can be intimidating. Users need to understand smart contracts, gas fees, and complex UIs just to cast a simple vote. What if instead, you could just say: "Create a vote about our next team lunch location with options: Pizza, Sushi, Mexican food, lasting for 1 day" and the AI would handle all the blockchain complexity?

That's exactly what this voting DApp does—it bridges the gap between complex blockchain operations and natural human conversation.

Why Gaia? Decentralized AI for Web3

Gaia isn't just another AI API—it's a decentralized computing infrastructure that lets you create, deploy, and scale AI agents. Here's why it was perfect for this project:

True Decentralization

Unlike centralized AI services, Gaia runs on distributed nodes, making it ideal for Web3 applications where decentralization matters. You can run your own node or use the network.

Tool-Calling Capabilities

Gaia's Llama-3-Groq-8B-Tool model excels at function calling, which is crucial for blockchain interactions. The AI can understand natural language commands and translate them into specific smart contract calls.

Blockchain-Native Design

Built with Web3 in mind, Gaia understands the unique requirements of blockchain applications—from handling wallet connections to managing transaction states.

Architecture: Where AI Meets Smart Contracts

The application follows a clean separation of concerns:

Frontend Layer

Built with Next.js and featuring a dual interface:

AI Chat Interface: Natural language interaction with the voting system
Manual Interface: Traditional web forms for users who prefer direct control

AI Integration Layer

The heart of the system is the AI route handler that processes natural language and translates it to blockchain actions:

// AI agent configuration
const openai = createOpenAI({
  baseURL: GAIA_API_ENDPOINT,
  apiKey: "" // Can be empty for local nodes
});

export async function POST(request: Request) {
  const { messages } = await request.json();

  const result = streamText({
    model: openai(GAIA_MODEL),
    system: systemPrompt,
    messages,
    maxSteps: 5,
    tools, // Blockchain interaction tools
  });

  return result.toDataStreamResponse();
}

Blockchain Layer

Smart contracts deployed on Linea Sepolia using a factory pattern:

VotingFactory: Creates new voting instances
VotingBase: Individual voting contracts with options and time limits

Natural Language Commands That Work

The AI agent understands various natural language patterns:

Creating Votes

"Create voting 'What should our next project be?' options: Web App, Mobile App, AI Tool duration: 2"

Viewing Results

"Show all active votings"
"List votings"
"What's the current status of all votes?"

Casting Votes

"Vote for 0x1234...5678 option 2"
"I want to vote for the second option in the contract 0x..."

The AI handles the complexity of:

Parsing natural language intent
Validating contract addresses
Managing transaction states
Providing user feedback

Technical Deep Dive: AI Tools for Blockchain

The magic happens in the AI tools configuration. Here's how the system translates natural language into blockchain actions:

// Example tool for creating votes
{
  name: "createVoting",
  description: "Create a new voting with options and duration",
  parameters: {
    description: "string",
    options: "array of strings", 
    durationType: "number (1=1hour, 2=1day, 3=1week)"
  }
}

When a user says "create a vote about lunch," the AI:

Parses the intent using the Llama-3-Groq-8B-Tool model
Extracts parameters (description, options, duration)
Calls the appropriate tool function
Executes the blockchain transaction via wagmi/viem
Provides natural language feedback to the user

Setting Up Your Own Gaia Node

One of the coolest aspects of this project is that you can run your own AI infrastructure. Here's how:

# Install GaiaNet node
curl -sSfL 'https://github.com/GaiaNet-AI/gaianet-node/releases/latest/download/install.sh' | bash

# Initialize with Llama-3-Groq-8B model (perfect for tool calling)
gaianet init --config https://raw.githubusercontent.com/GaiaNet-AI/node-configs/main/llama-3-groq-8b-tool/config.json

# Start your node
gaianet start

Now your voting DApp runs on completely decentralized infrastructure—no centralized AI service required!

Real-World Impact: Making Web3 Accessible

This project addresses a fundamental challenge in Web3 adoption: complexity barriers. By providing a conversational interface, we enable:

Non-Technical Users

People who find blockchain intimidating can participate naturally through conversation.

Rapid Prototyping

Teams can quickly create polls and votes without navigating complex interfaces.

Educational Value

Users learn about blockchain concepts through guided, conversational interactions.

Challenges Solved and Lessons Learned

State Management Complexity

Managing the relationship between AI conversation state, blockchain transaction state, and UI state required careful architecture. The solution was to keep each layer focused on its core responsibility.

Natural Language Ambiguity

Users don't always express intents clearly. The AI system includes validation and clarification flows to ensure accuracy.

Transaction Feedback

Blockchain transactions take time. The AI provides updates and manages user expectations throughout the process.

Performance and Scalability

The system performs remarkably well:

AI Response Time: ~2-3 seconds for complex operations
Blockchain Integration: Seamless transaction handling with proper error management
User Experience: Natural conversation flow with real-time updates

Future Enhancements

The foundation is strong, and there are exciting possibilities ahead:

Knowledge Base Integration

Gaia supports knowledge bases that could include:

Voting best practices and patterns
Blockchain education materials
Historical voting data and insights
Governance framework documentation

Multi-Chain Support

Expanding beyond Linea to support multiple blockchain networks through the same conversational interface.

Advanced AI Capabilities

Implementing more sophisticated features like:

Vote outcome prediction
Participation analytics
Automated governance suggestions

Open Source and Community

The entire project is open source and available for the community to build upon. Whether you're interested in:

AI and natural language processing
Blockchain development and smart contracts
UX design for Web3 applications
Decentralized infrastructure

There's something here for everyone to learn from and contribute to.

Try It Yourself

Ready to experience conversational blockchain voting? Here's how to get started:

Clone the repository and follow the setup instructions
Deploy your own contracts or use the existing testnet deployment
Configure your Gaia node or use the hosted API
Start voting through natural conversation!

Conclusion: The Future is Conversational

This project represents more than just a voting application—it's a glimpse into a future where interacting with blockchain technology is as natural as having a conversation. By combining Gaia's decentralized AI infrastructure with thoughtful smart contract design, we're not just building applications; we're building the foundation for a more accessible, democratic Web3.

The intersection of AI and blockchain isn't coming—it's here. And with tools like Gaia making decentralized AI infrastructure accessible to developers, the possibilities are limitless.

Want to dive deeper? Check out the full source code and start building your own AI-powered Web3 applications.

Links and Resources:

Getting Started with Gaia: A Developer's Guide to Building AI Agents with Gaia

Sushmita - aka meowy — Thu, 04 Sep 2025 13:05:00 +0000

Building AI-powered applications can be daunting. Between choosing the right models, setting up infrastructure, and handling API integrations, developers often spend more time on setup than on building their actual product. That's where the Gaia Agent Starter Kit comes in—a streamlined foundation that gets you from idea to working AI application in minutes, not hours.

Why Another AI Starter Kit?

The AI development landscape is cluttered with complex frameworks and heavyweight solutions. Most require extensive configuration, vendor lock-in, or compromise on performance and privacy. Gaia's approach is different:

Decentralized by design - No single point of failure or vendor dependency
Privacy-focused - Your data stays where you want it
Developer-friendly - Clean APIs and straightforward integration
Production-ready - Built on proven infrastructure

This starter kit distills years of AI application development experience into a simple, extensible foundation.

The Starter Kit Architecture

The Gaia Agent Starter Kit follows a clean, modular architecture built on Next.js:

Core Components

Frontend Layer: A clean React interface with streaming chat capabilities
API Integration: Streamlined connection to Gaia's AI infrastructure

Tool System: Extensible framework for adding custom AI capabilities
Configuration Management: Simple environment-based setup

Quick Start: From Clone to Chat in 5 Minutes

Step 1: Project Setup

git clone https://github.com/meowyx/gaia-agent-starter
cd gaia-agent-starter
pnpm install

The project uses pnpm for faster dependency installation, but works with npm or yarn as well.

Step 2: Get Your Gaia API Credentials

The setup process is straightforward:

Visit gaianet.ai and click Launch App
Connect your wallet - MetaMask or other Web3 wallets work
Access settings via the profile dropdown
Create an API key in the "Gaia API Keys" section
Choose your base URL from available public nodes

Step 3: Environment Configuration

Create your .env.local file:

NEXT_PUBLIC_GAIA_API_BASE_URL=
NEXT_PUBLIC_GAIA_API_KEY=your_api_key_here

Step 4: Launch Your AI Agent

pnpm dev

Open http://localhost:3000 and start chatting with your AI agent.

Under the Hood: How It Works

API Route Implementation

The core API route demonstrates clean integration with Gaia:

import { createOpenAI } from "@ai-sdk/openai";
import { streamText } from "ai";
import { tools } from "@/ai/tools";

export async function POST(request: Request) {
  const { messages } = await request.json();

  const openai = createOpenAI({
    baseURL: process.env.NEXT_PUBLIC_GAIA_API_BASE_URL,
    apiKey: process.env.NEXT_PUBLIC_GAIA_API_KEY 
  });

  try {
    const result = streamText({
      model: openai("llama"),
      system: "you are a friendly assistant",
      messages,
      maxSteps: 5,
      tools,
    });

    return result.toDataStreamResponse();
  } catch (error) {
    console.error(error);
    return new Response("Internal server error", { status: 500 });
  }
}

This approach provides:

Environment-based configuration - No hardcoded values
Error handling - Graceful failure management
Streaming responses - Real-time conversation flow
Tool integration - Extensible AI capabilities

Frontend Integration

The frontend uses a clean, welcoming interface:

export default function Home() {
  return (
    <div 
      className="h-screen w-full overflow-y-auto grid grid-rows-[20px_1fr_60px]"
      style={{ 
        background: "linear-gradient(135deg, #fcf8e8 0%, #d4e2d4 100%)",
      }}
    >
      <main className="gap-8 row-start-2 sm:items-start h-full w-full">
        <div className="flex flex-col gap-3 items-center justify-center h-full">
          <div className="text-center mb-6">
            <h1 className="text-3xl font-bold mb-2 text-green-800">
              Hi there, Let's Chat 👋
            </h1>
            <p className="text-sm text-green-600 italic">
              powered by <Link href="https://www.gaianet.ai/">gaia</Link> 🌱
            </p>
          </div>
          <Chat />
        </div>
      </main>
    </div>
  );
}

The design emphasizes:

Approachable aesthetics - Warm, natural color scheme
Clear branding - Gaia attribution and links
Responsive layout - Works across all device sizes
Accessibility - Proper semantic structure

Customization and Extension

Adding Custom Tools

The starter kit includes a tools system for extending AI capabilities:

// ai/tools.ts
export const tools = {
  getCurrentTime: {
    description: 'Get the current time',
    parameters: z.object({}),
    execute: async () => {
      return new Date().toISOString();
    },
  },

  // Add your custom tools here
  calculateTip: {
    description: 'Calculate tip amount',
    parameters: z.object({
      amount: z.number(),
      percentage: z.number()
    }),
    execute: async ({ amount, percentage }) => {
      return amount * (percentage / 100);
    },
  }
};

Customizing the AI Personality

Modify the system prompt to change your agent's behavior:

const result = streamText({
  model: openai("llama"),
  system: `You are a specialized assistant for [your domain].
           You should:
           - Be helpful and accurate
           - Focus on [your specific area]
           - Provide actionable advice
           - Ask clarifying questions when needed`,
  messages,
  maxSteps: 5,
  tools,
});

Styling and Branding

The starter kit uses Tailwind CSS for easy customization:

/* Custom color scheme */
:root {
  --primary-green: #16a34a;
  --accent-green: #22c55e;
  --background-start: #fcf8e8;
  --background-end: #d4e2d4;
}

Production Deployment

Environment Configuration

For production deployment, ensure your environment variables are properly set:

# Production environment
NEXT_PUBLIC_GAIA_API_BASE_URL=
NEXT_PUBLIC_GAIA_API_KEY=your_production_api_key

Performance Optimizations

The starter kit includes several built-in optimizations:

Automatic code splitting - Next.js handles this automatically
Image optimization - Built-in Next.js image optimization
Streaming responses - Reduces perceived latency
Error boundaries - Graceful error handling

Security Considerations

While the starter kit is secure by default, consider these additional measures for production:

// Add rate limiting
import { rateLimit } from '@/lib/rate-limit';

export async function POST(request: Request) {
  const identifier = request.headers.get('x-forwarded-for') || 'localhost';
  const { success } = await rateLimit.limit(identifier);

  if (!success) {
    return new Response('Too many requests', { status: 429 });
  }

  // ... rest of your handler
}

Common Use Cases and Extensions

Customer Support Agent

Transform the starter into a support agent:

const supportSystem = `You are a customer support agent for [Company Name].
You have access to:
- Product documentation
- Order lookup tools  
- Troubleshooting guides

Always be helpful, patient, and professional.`;

Educational Tutor

Create a specialized learning assistant:

const tutorSystem = `You are an educational tutor specializing in [Subject].
You should:
- Break down complex concepts
- Provide examples and practice problems
- Adapt to the student's level
- Encourage learning`;

Developer Assistant

Build a coding companion:

const devSystem = `You are a senior developer assistant.
You can help with:
- Code review and suggestions
- Debugging assistance
- Architecture recommendations
- Best practices guidance`;

Connecting to Your Own Gaia Node

For maximum control and privacy, you can run your own Gaia node:

Local Node Setup

# Install Gaia node
curl -sSfL 'https://github.com/GaiaNet-AI/gaianet-node/releases/latest/download/install.sh' | bash

# Initialize with your preferred model
gaianet init --config https://raw.githubusercontent.com/GaiaNet-AI/node-configs/main/llama-3-groq-8b-tool/config.json

# Start your node
gaianet start

Configuration Update

Update your environment variables to point to your local node:

NEXT_PUBLIC_GAIA_API_BASE_URL=http://localhost:8080/v1
NEXT_PUBLIC_GAIA_API_KEY=""  # Can be empty for local nodes

Troubleshooting Common Issues

API Connection Problems

If you're having trouble connecting to Gaia:

Verify your API key - Ensure it's correctly set in .env.local
Check the base URL - Confirm the node is accessible
Review network settings - Firewall or proxy issues
Check rate limits - Some nodes have usage restrictions

Streaming Response Issues

If messages aren't streaming properly:

Browser compatibility - Ensure modern browser support
Network configuration - Some proxies block streaming
Error handling - Check browser console for errors

Tool Integration Problems

If custom tools aren't working:

Parameter validation - Ensure Zod schemas are correct
Async handling - All tool functions should be async
Error boundaries - Add proper error handling

Advanced Patterns

Multi-Agent Conversations

Extend the starter to support multiple AI agents:

const agents = {
  researcher: {
    system: "You are a research specialist...",
    model: "llama"
  },
  writer: {
    system: "You are a creative writer...",
    model: "llama"
  }
};

// Route to different agents based on context
const selectedAgent = agents[agentType];

Context Persistence

Add conversation memory:

// Store conversation context
const conversation = {
  id: generateId(),
  messages: [],
  context: {},
  created: new Date()
};

// Retrieve and maintain context across sessions

Integration with External APIs

Add external data sources:

const tools = {
  getWeather: {
    description: 'Get current weather',
    parameters: z.object({
      location: z.string()
    }),
    execute: async ({ location }) => {
      const response = await fetch(`https://api.weather.com/${location}`);
      return await response.json();
    }
  }
};

Community and Ecosystem

The Gaia Agent Starter Kit is part of a growing ecosystem:

Community Resources

GitHub Discussions - Share experiences and get help
Discord Community - Real-time chat with other developers
Documentation - Comprehensive guides and tutorials
Example Projects - Inspiration and code samples

Contributing Back

Ways to contribute to the ecosystem:

Share your extensions - Tools, UI components, integrations
Submit bug reports - Help improve stability
Write tutorials - Help others learn
Contribute code - Direct improvements to the starter kit

The Future of AI Development

This starter kit represents a philosophy shift in AI development:

From Complexity to Simplicity

Instead of overwhelming developers with options, provide a clean foundation they can build upon.

From Centralized to Decentralized

Remove single points of failure and give developers control over their AI infrastructure.

From Proprietary to Open

Open-source tools and transparent infrastructure enable innovation and trust.

Conclusion: Getting started with your AI Agent Journey

The Gaia Agent Starter Kit removes the friction from AI application development. Whether you're building a customer service bot, an educational tutor, or a specialized domain assistant, this foundation gives you everything you need to start building immediately.

The real power comes from what you build on top of it. The starter kit is intentionally minimal—a clean canvas for your ideas rather than a prescriptive framework. This approach enables rapid prototyping while maintaining the flexibility to scale and customize as your application grows.

Ready to build your first AI agent? Clone the repository, follow the setup guide, and start experimenting.

Getting Started:

Building a Deep Research Agent with Gaia: Multi-Agent Planning and Execution

Sushmita - aka meowy — Mon, 01 Sep 2025 16:08:12 +0000

Research is no longer just about finding information—it's about intelligent synthesis, strategic planning, and adaptive depth exploration.

Today, I want to share how I built a sophisticated AI research agent using Gaia's decentralized infrastructure that doesn't just search the web, but thinks like a professional researcher.

// Detect dark theme var iframe = document.getElementById('tweet-1920080467069726994-131'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1920080467069726994&theme=dark" }

The Challenge: Beyond Simple Search

Traditional search tools give you results. Research agents give you insights. The difference lies in their ability to:

Plan strategically rather than search randomly
Evaluate quality rather than just rank by relevance
Synthesize findings rather than present raw data
Adapt their approach based on what they discover

Sounds complicated? Think of it in this way:

In this case the architecture would be something like this:

This research agent embodies all these capabilities through a multi-agent architecture that mirrors how human researchers actually work.

Architecture: A Symphony of Specialized Agents

The system consists of three core agents working in harmony, let's explore how everything works together.

Planning Agent: The Strategic Mind

Built with Gaia's Llama-3-Groq-8B-Tool model, this agent creates comprehensive research plans:

// Research planning with structured steps
const plan = await planner.createPlan(query);

// Each plan contains:
{
  query: "Original research question",
  steps: [
    {
      id: 1,
      description: "Search for recent developments",
      action: { type: 'search', params: { query: '...' }},
      status: 'pending'
    }
  ]
}

Execution Agent: The Workhorse

Handles the actual research tasks with multiple specialized tools:

switch (currentStep.action.type) {
  case 'search':
    result = await searchTool.search(query);
    break;
  case 'summarize':
    result = await summarizationTool.synthesize(findings);
    break;
  case 'fetch_webpage':
    result = await webTool.extractContent(url);
    break;
  // Additional tools for papers, GitHub repos, etc.
}

The Deep Thinker

The most sophisticated component—it decides when and how to dig deeper:

// Dynamic plan expansion based on findings
const additionalSteps = await generateText({
  model: openai('gpt-4'),
  messages: [
    {
      role: "system", 
      content: "Analyze research gaps and create deeper investigation steps..."
    }
  ]
});

Stateful Research Workflows

Unlike stateless APIs, this research agent maintains context throughout the entire research journey:

interface ResearchSession {
  id: string;
  plan: ResearchPlan;
  currentStepIndex: number;
  artifacts: ResearchArtifact[];
  createdAt: string;
}

// Persistent session storage
const sessions: Record<string, ResearchSession> = {};

This allows the agent to:

Remember previous findings when planning next steps
Build upon earlier research in subsequent queries
Track progress through complex multi-step investigations
Resume research if interrupted

The "Dig Deeper" Innovation

The breakthrough feature is the agent's ability to intelligently expand its own research plan. When you click "Dig Deeper," here's what happens:

1. Gap Analysis

The agent analyzes completed research to identify knowledge gaps:

// The agent examines all artifacts collected so far
const { plan, artifacts } = session;

// And asks: "What haven't we explored yet?"
const analysisPrompt = `
Based on the research conducted so far, identify areas that need deeper investigation.
Current findings: ${JSON.stringify(artifacts)}
What 2-3 additional research steps would provide deeper insights?
`;

2. Strategic Expansion

Rather than random additional searches, it creates targeted investigation steps:

[
  {
    "id": 4,
    "description": "Investigate the technical implementation challenges",
    "action": {
      "type": "search",
      "params": {
        "query": "technical challenges implementing quantum computing in healthcare"
      }
    },
    "dependencies": [1, 2]
  }
]

3. Contextual Execution

New steps build upon previous findings using the dependency system:

// Find relevant artifacts from previous steps
if (currentStep.dependencies) {
  for (const depId of currentStep.dependencies) {
    const depArtifact = artifacts.find(a => a.taskId === depId);
    if (depArtifact && depArtifact.taskType === 'search') {
      searchResults = depArtifact.artifact as ProcessedSearchResult[];
    }
  }
}

Real-Time Research Orchestration

The execution engine manages complex workflows with proper error handling and progress tracking:

export async function POST(request: Request) {
  const { sessionId } = await request.json();
  const session = sessions[sessionId];

  // Execute current step
  const currentStep = plan.steps[currentStepIndex];
  currentStep.status = 'in-progress';

  try {
    // Execute based on step type
    const result = await executeStep(currentStep);

    // Store results as artifacts
    artifacts.push({
      taskId: currentStep.id,
      taskType: currentStep.action.type,
      artifact: result
    });

    currentStep.status = 'completed';
    session.currentStepIndex++;

    return { result, isComplete: currentStepIndex >= plan.steps.length };
  } catch (error) {
    currentStep.status = 'failed';
    throw error;
  }
}

Advanced Features: Beyond Basic Research

Quality Assessment

The agent doesn't just collect information—it evaluates source credibility, recency, and relevance:

class WebSearchTool {
  processResults(rawResults: any[]): ProcessedSearchResult[] {
    return rawResults.map(result => ({
      title: result.title,
      url: result.url,
      summary: this.extractSummary(result.content),
      source: this.identifySource(result.url),
      date: this.extractDate(result),
      credibilityScore: this.assessCredibility(result),
      keyPoints: this.extractKeyPoints(result.content)
    }));
  }
}

Intelligent Synthesis

The summarization tool creates coherent narratives from disparate sources:

class SummarizationTool {
  async summarize(query: string, searchResults: ProcessedSearchResult[]): Promise<string> {
    // Combines findings from multiple sources
    // Identifies patterns and contradictions  
    // Creates structured summaries
    // Highlights key insights
  }
}

Adaptive Interface

The frontend provides real-time feedback on which agents are active:

// Visual indicators for active processes
const [activeFeatures, setActiveFeatures] = useState({
  search: false,    // Web search in progress
  planning: false,  // Creating research plan
  quality: false,   // Evaluating source quality
  synthesis: false, // Synthesizing findings
  depth: false      // Digging deeper
});

Why Gaia Makes This Possible

Decentralized Intelligence

Unlike centralized AI services, Gaia's distributed architecture ensures:

No single point of failure for critical research workflows
Data privacy - research stays within your infrastructure
Cost efficiency - run your own nodes instead of paying per API call
Customization - fine-tune models for specific research domains

Tool-Calling Excellence

Gaia's Llama-3-Groq-8B-Tool model excels at structured tool usage:

// The model understands complex tool interactions
const tools = {
  search: { /* Web search capabilities */ },
  summarize: { /* Content synthesis */ },
  fetch_webpage: { /* Content extraction */ },
  dig_deeper: { /* Plan expansion */ }
};

// And orchestrates them intelligently
const result = await streamText({
  model: openai(GAIA_MODEL),
  tools,
  maxSteps: 5, // Multi-step reasoning
});

Real-World Research Scenarios

Academic Research

Query: "Latest developments in quantum computing for healthcare applications"

Plan Generated:
1. Search recent academic papers on quantum healthcare
2. Fetch specific papers from top conferences  
3. Analyze implementation challenges
4. Summarize potential applications
5. [Dig Deeper] Investigate regulatory considerations
6. [Dig Deeper] Explore current pilot programs

Market Analysis

Query: "Competitive landscape for AI-powered customer service tools"

Plan Generated:
1. Search major players in AI customer service
2. Fetch company websites and product pages
3. Analyze pricing models and features
4. Summarize competitive positioning
5. [Dig Deeper] Investigate recent funding rounds
6. [Dig Deeper] Analyze customer reviews and case studies

Technical Investigation

Query: "Performance comparison of Next.js vs React for large-scale applications"

Plan Generated:
1. Search performance benchmarks
2. Fetch GitHub repositories with comparisons
3. Analyze real-world case studies
4. Summarize trade-offs and recommendations  
5. [Dig Deeper] Investigate deployment patterns
6. [Dig Deeper] Explore migration strategies

Performance and Scalability

The agent delivers impressive performance across key metrics:

Research Plan Generation: ~3-5 seconds for complex topics
Step Execution: ~2-4 seconds per research step
Deep Research Expansion: ~5-8 seconds for additional planning
Session Management: Handles multiple concurrent research workflows
Memory Efficiency: Stores only essential artifacts and findings

Error Handling and Resilience

The system includes comprehensive error handling for real-world reliability:

try {
  const result = await executeStep(currentStep);
  currentStep.status = 'completed';
} catch (error) {
  currentStep.status = 'failed';

  // Detailed error reporting
  return NextResponse.json({ 
    error: 'Step execution failed',
    details: error.message,
    stepId: currentStep.id,
    recoveryOptions: ['retry', 'skip', 'modify']
  });
}

Setting Up Your Research Agent

Quick Start with Gaia API

// Simple configuration
const GAIA_API_ENDPOINT = 'API_ENDPOINT';
const GAIA_MODEL = 'Llama-3-Groq-8B-Tool';

// Add your API key
process.env.GAIA_API_KEY = 'your_key_here';

Self-Hosted for Maximum Control

# Install and run your own Gaia node
curl -sSfL 'https://github.com/GaiaNet-AI/gaianet-node/releases/latest/download/install.sh' | bash
gaianet init --config https://raw.githubusercontent.com/GaiaNet-AI/node-configs/main/llama-3-groq-8b-tool/config.json
gaianet start

# Point your application to local node
const GAIA_API_ENDPOINT = 'http://localhost:8080/v1';

Future Enhancements: The Research Agent Evolution

Knowledge Base Integration

Gaia's knowledge base system could enhance the agent with:

Domain-specific expertise - Specialized knowledge for different fields
Historical context - Learning from previous successful research patterns
Quality heuristics - Improved source evaluation based on domain knowledge
Citation networks - Understanding relationships between sources

Multi-Modal Research

Expanding beyond text to include:

Image analysis for visual research
Video content processing for multimedia sources
Audio transcription for podcast and interview analysis
Document parsing for PDFs and technical papers

Collaborative Research

Multiple agents working together:

Specialist agents for different domains
Verification agents for fact-checking
Synthesis agents for cross-domain insights
Presentation agents for formatted output

Open Source Impact

The complete research agent is available as an open-source project, enabling:

Educational use - Understanding multi-agent AI systems
Research applications - Academic and professional research workflows
Commercial adaptation - Building specialized research tools
Community contribution - Collaborative improvements and extensions

Conclusion: The Future of AI-Powered Research

This research agent represents a fundamental shift from reactive search to proactive investigation. By combining Gaia's decentralized AI infrastructure with sophisticated multi-agent orchestration, we've created a system that doesn't just find information—it conducts research.

The implications extend far beyond individual productivity:

Academic researchers can explore complex topics more comprehensively
Business analysts can conduct thorough market investigations
Students can learn research methodologies through AI guidance
Organizations can build institutional knowledge through systematic investigation

As AI agents become more sophisticated, the boundary between human and artificial research capabilities continues to blur. The key insight from this project is that the future lies not in replacing human researchers, but in amplifying their capabilities through intelligent, strategic, and adaptive AI partners.

Resources:

Reimagining Web3 Interactions: How Gaia Powers Smart Token Creation on Linea with MetaMask Delegation Toolkit

Sushmita - aka meowy — Tue, 26 Aug 2025 13:31:59 +0000

It was only a matter of time before AI Agents and web3 joined forces, creating a more accessible and democratic user experience. For years there was a strong technical barrier that stood as a fortress wall for users, but now AI agents are acting as a skilled guide, interpreting complex protocols with simple chat conversations and intuitive responses. There’s always sophisticated web3 technology advancement happening, but how we engage with these protocols with a layer of intelligence that adapts with our natural communication pattern with AI, rather than forcing us to adapt with the technical barrier, is what makes artificial intelligence so important. In this blog post, we will go over how to implement MetaMask Delegation Toolkit with Gaia to perform smart contract operations like the token creation process.

Web3 UX: Still a challenge for users

Even though there’s a huge potential for blockchain technology, one challenge that still remains is user experience. Creating and deploying a token on any L1/L2/altVM blockchain requires specialized knowledge of writing smart contract in programming languages like solidity, Rust, Sway, Vyper and even new languages like Cairo and there’s also the complex deployment process. Even for experienced developers, the specified process can be time-consuming. We also have to consider the fact that smart contracts can also contain vulnerabilities which can result in potential fund loss.

Let’s take a look at what it typically takes to create a simple ERC20 token:

Write Smart Contract code for the token contract
Compile the code with the correct and specific compiler version
Deploy the smart contract to a testnet for verification.
Configure gas settings to make sure of the successful deployment
Deploy to the contract to mainnet while managing private keys securely
Verify the contract on block explorers (so that it’s not an unverified token contract)

For an average user, this barrier can be quite the challenge, which ultimately limits the participation in one of the most basic activities in the web3 ecosystem - creating tokens. This is where the combination of AI and smart wallet like delegation technology offers an amazing solution.

Understanding the MetaMask Delegation Toolkit

The MetaMask Delegation Toolkit (DTK) introduces a paradigm shift in how permissions can be granted on the blockchain through AI. At its heart, DTK enables a security model where one account (the delegator) can authorize another account (the delegate) to perform specific actions on its behalf, with fine-grained control over what those actions can be.

The DTK operates through several key components that work together to create a secure delegation system:

1. Smart Accounts

Smart accounts are contract-based accounts that can enforce rules and permissions beyond what traditional EOA (Externally Owned Accounts) can do. These accounts are the foundation of the delegation system.

In this implementation, two smart accounts are created:

// Creating a smart account for the user (delegator)
const delegatorSmartAccount = await toMetaMaskSmartAccount({
  client: publicClient,  // Connection to the blockchain
  implementation: Implementation.Hybrid,  // Account implementation type
  deployParams: [address, [], [], []],  // Parameters for account initialization
  deploySalt: createSalt(),  // Unique identifier for deterministic deployment
  signatory: { walletClient },  // Connection to user's wallet for signing
});

// Creating a smart account for Gaia (delegate)
const aiPrivateKey = generatePrivateKey();  // Generate a new private key for the AI
const aiAccount = privateKeyToAccount(aiPrivateKey);  // Create an EOA from the private key

const aiSmartAccount = await toMetaMaskSmartAccount({
  client: publicClient,
  implementation: Implementation.Hybrid,
  deployParams: [aiAccount.address, [], [], []],
  deploySalt: createSalt(),
  signatory: { account: aiAccount },  // AI's account will sign its transactions
});

These accounts are "counterfactual" - they exist with deterministic addresses before they're actually deployed on the blockchain. This allows for gas-efficient operation as the accounts only get deployed when they first perform a transaction.

2. Delegations with Caveats

A delegation is a cryptographically signed permission grant that specifies what actions are allowed. Caveats are restrictions that define the precise boundaries of what a delegate can do.
The implementation of caveats is where the real security magic happens:

// Define strict boundaries for what Gaia can do
const caveats = createCaveatBuilder(delegatorAccount.environment)
  // Only allow interaction with our factory contract
  .addCaveat("allowedTargets", [FACTORY_CONTRACT_ADDRESS])
  // Prevent ETH spending entirely
  .addCaveat("valueLte", BigInt(0))
  // Only allow calling the createToken function
  .addCaveat("allowedMethods", [CREATE_TOKEN_SELECTOR]);

// Create the delegation with these restrictions
const newDelegation = createRootDelegation(
  aiDelegateAccount.address,  // Who receives permission (Gaia)
  delegatorAccount.address,   // Who grants permission (User)
  caveats,                    // The restrictions
  BigInt(createSalt())        // Unique identifier
);

// Sign the delegation with the user's account
const signature = await delegatorAccount.signDelegation({
  delegation: newDelegation
});

This code creates a delegation that:

Restricts AI to interact only with the specified factory contract address
Prevents AI from spending any of the user's ETH (value limit set to zero)
Allows AI to call only the createToken function on that contract

These restrictions create a secure sandbox that protects the user's assets while enabling specific functionality. Think of it as giving someone a limited power of attorney to perform only one very specific action on your behalf, rather than handing over full control of your assets.

3. Delegation Storage and Persistence

For the delegation system to be useful across sessions, AI stores the delegation information securely using the DTK's delegation storage service:

// Store a delegation in the service
const delegationStorageClient = new DelegationStorageClient({
  apiKey: process.env.NEXT_PUBLIC_DELEGATION_STORAGE_API_KEY!,
  apiKeyId: process.env.NEXT_PUBLIC_DELEGATION_STORAGE_API_KEY_ID!,
  environment: DelegationStorageEnvironment.dev,
});

// Store the delegation in the delegation storage service
const storedDelegation = await delegationStorageClient.storeDelegation(signedDelegation);

This storage system allows delegations to persist beyond browser sessions, enabling users to return to the application and have AI retain its permissions without repeating the setup process.

Gaia: The Decentralized AI Infrastructure

Now that we understand the delegation framework, let's examine how Gaia’s Public Models utilizes these delegations to deploy tokens based on natural language requests using API.
AI is integrated into the application through a chat interface where users can describe the token they want to create. The agent processes these descriptions, extracts the key parameters, and then executes the token creation through the delegation system.

The AI Tool for Token Deployment

The bridge between agents natural language understanding and blockchain execution is implemented as a custom AI tool.
Tools are actions that an LLM can invoke. The results of these actions can be reported back to the LLM to be considered in the next response. I’ve used vercel’s AI sdk to get started with tools.

Let’s break down the code from here.

// Delegation Storage Singleton
let delegationStorageInstance: DelegationStorageClient | null = null;


// Helper function to log storage configuration
const logStorageConfig = (apiKey?: string, apiKeyId?: string) => {
 console.group("=== Delegation Storage Configuration ===");
 console.log("API Key format check:", {
   exists: !!apiKey,
   length: apiKey?.length,
   firstChars: apiKey?.substring(0, 4),
   lastChars: apiKey?.substring(apiKey.length - 4),
   hasSpecialChars: apiKey?.match(/[^a-zA-Z0-9]/) ? true : false,
 });
 console.log("API Key ID format check:", {
   exists: !!apiKeyId,
   length: apiKeyId?.length,
   firstChars: apiKeyId?.substring(0, 4),
   lastChars: apiKeyId?.substring(apiKeyId.length - 4),
   hasSpecialChars: apiKeyId?.match(/[^a-zA-Z0-9]/) ? true : false,
 });
 console.log("Environment:", DelegationStorageEnvironment.dev);
 console.log(
   "Running on:",
   typeof window !== "undefined" ? "client" : "server"
 );
 console.groupEnd();
};


/**
* Gets the delegation storage client, initializing it if necessary
* @returns A configured DelegationStorageClient instance
*/
export const getDelegationStorageClient = (): DelegationStorageClient => {
 if (!delegationStorageInstance) {
   const apiKey = process.env.NEXT_PUBLIC_DELEGATION_STORAGE_API_KEY;
   const apiKeyId = process.env.NEXT_PUBLIC_DELEGATION_STORAGE_API_KEY_ID;


   logStorageConfig(apiKey, apiKeyId);


   if (!apiKey || !apiKeyId) {
     throw new Error("Delegation storage API key and key ID are required");
   }


   try {
     delegationStorageInstance = new DelegationStorageClient({
       apiKey,
       apiKeyId,
       environment: DelegationStorageEnvironment.dev,
       fetcher:
         typeof window !== "undefined" ? window.fetch.bind(window) : undefined,
     });
     console.log("DelegationStorageClient initialized successfully");
   } catch (error) {
     console.error("Error creating DelegationStorageClient:", error);
     throw error;
   }
 }
 return delegationStorageInstance;
};


/**
* Stores a delegation in the delegation storage service
* @param delegation The delegation to store
* @returns The result of the store operation
*/
export const storeDelegation = async (delegation: DelegationStruct) => {
 try {
   console.group("=== Storing Delegation ===");
   console.log("Delegation details:", {
     delegate: delegation.delegate,
     delegator: delegation.delegator,
     hasSignature: !!delegation.signature,
     salt: delegation.salt.toString(),
   });


   const delegationStorageClient = getDelegationStorageClient();
   const result = await delegationStorageClient.storeDelegation(delegation);


   console.log("Delegation stored successfully:", result);
   console.groupEnd();
   return result;
 } catch (error: any) {
   console.error("Delegation storage error:", {
     name: error.name,
     message: error.message,
     status: error.status,
     details: error.details,
     stack: error.stack,
   });
   console.groupEnd();
   throw error;
 }
};


/**
* Retrieves a delegation chain by its hash
* @param hash The hash of the delegation chain to retrieve
* @returns The delegation chain
*/
export const getDelegationChain = async (hash: Hex) => {
 try {
   console.log("Fetching delegation chain for hash:", hash);
   const delegationStorageClient = getDelegationStorageClient();
   const result = await delegationStorageClient.getDelegationChain(hash);
   console.log("Delegation chain fetched:", result);
   return result;
 } catch (error) {
   console.error("Error fetching delegation chain:", error);
   throw error;
 }
};


/**
* Fetches delegations for a specific address
* @param address The address to fetch delegations for
* @param filter Whether to fetch given or received delegations
* @returns The delegations for the address
*/
export const fetchDelegations = async (
 address: Hex,
 filter: DelegationStoreFilter
) => {
 try {
   console.log(
     "Fetching delegations for address:",
     address,
     "filter:",
     filter
   );
   const delegationStorageClient = getDelegationStorageClient();
   const result = await delegationStorageClient.fetchDelegations(
     address,
     filter
   );
   console.log("Delegations fetched:", result);
   return result;
 } catch (error) {
   console.error("Error fetching delegations:", error);
   throw error;
 }
};


/**
* Gets delegation info from session storage (if available)
* @returns The delegation info or null if not found
*/
export const getDelegationInfoFromSession = () => {
 if (typeof window === "undefined") return null;


 try {
   const delegationInfoStr = sessionStorage.getItem("aiDelegateInfo");
   if (!delegationInfoStr) return null;


   return JSON.parse(delegationInfoStr);
 } catch (error) {
   console.error("Error retrieving delegation info from session:", error);
   return null;
 }
};


/**
* Gets the full delegation from session storage (if available)
* @returns The full delegation or null if not found
*/
export const getFullDelegationFromSession = () => {
 if (typeof window === "undefined") return null;


 try {
   const delegationStr = sessionStorage.getItem("delegation");
   if (!delegationStr) return null;


   const delegation = JSON.parse(delegationStr);


   // Convert string salt back to BigInt
   if (delegation && typeof delegation.salt === "string") {
     delegation.salt = BigInt(delegation.salt);
   }


   return delegation;
 } catch (error) {
   console.error("Error retrieving delegation from session:", error);
   return null;
 }
};


/**
* Clears delegation info from session storage
*/
export const clearDelegationSession = () => {
 if (typeof window === "undefined") return;


 sessionStorage.removeItem("aiDelegateInfo");
 sessionStorage.removeItem("delegation");
 sessionStorage.removeItem("aiDelegatePrivateKey");
};



const createTokenTool = createTool({""});


export const tools = {
 createToken: createTokenTool,
};

this tool encapsulates all the complexity of token deployment. When the AI determines that the user wants to create a token, it invokes this tool with the appropriate parameters extracted from the conversation.

The Token Factory Contract: Writing the smart contract for the Agent

The ERC20 Factory contract that Gaia interacts with is designed to create new token instances based on the provided parameters:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "./BaseERC20Token.sol";

contract ERC20Factory {
    address public owner;
    mapping(address => bool) public tokenExists;
    address[] public allTokens;

    event TokenCreated(
        address indexed tokenAddress,
        string name,
        string symbol,
        uint256 initialSupply,
        address owner
    );

    constructor() {
        owner = msg.sender;
    }

    function createToken(
        string memory name,
        string memory symbol,
        uint256 initialSupply
    ) external returns (address) {
        BaseERC20Token newToken = new BaseERC20Token(
            name,
            symbol,
            initialSupply,
            msg.sender
        );

        address tokenAddress = address(newToken);
        tokenExists[tokenAddress] = true;
        allTokens.push(tokenAddress);

        emit TokenCreated(
            tokenAddress,
            name,
            symbol,
            initialSupply,
            msg.sender
        );

        return tokenAddress;
    }

    function getAllTokens() external view returns (address[] memory) {
        return allTokens;
    }

    function getTokenCount() external view returns (uint256) {
        return allTokens.length;
    }
}

The base ERC20 token that gets created:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract BaseERC20Token is ERC20, Ownable {
    constructor(
        string memory name,
        string memory symbol,
        uint256 initialSupply,
        address owner
    ) ERC20(name, symbol) Ownable(owner) {
        _mint(owner, initialSupply * (10 ** decimals()));
    }
}

This factory pattern provides several benefits:

The base token implementation is fixed and secure
Each token is customized through constructor parameters
The factory maintains a registry of all created tokens
Deployment is gas-efficient

You can check the whole smart contract code here: https://github.com/meowyx/erc20-factory

The User Experience: From Conversation to Blockchain

What makes AI special is how it transforms a complex blockchain operation into a simple conversation. Let's explore the user experience of interacting with AI to create tokens.

The Chat Interface

The chat interface is where users interact with Gaia through natural language:

export const Chat = () => {
  const { address } = useAccount();
  const [delegationEnabled, setDelegationEnabled] = useState(false);

  // Check if delegation is set up
  useEffect(() => {
    const checkDelegation = () => {
      const delegateInfo = sessionStorage.getItem('aiDelegateInfo');
      setDelegationEnabled(!!delegateInfo);
    };

    checkDelegation();
    window.addEventListener('storage', checkDelegation);

    return () => {
      window.removeEventListener('storage', checkDelegation);
    };
  }, []);

  const { messages, input, handleInputChange, handleSubmit, isLoading } =
    useChat({
      initialMessages: [
        {
          role: "system",
          content: `You have connected your wallet successfully. Your wallet address is ${address}. ${
            delegationEnabled
              ? "You have delegated token creation permissions to me. I can deploy ERC20 tokens on your behalf through a factory contract. Just ask me to create a token and specify the name, symbol, and initial supply."
              : "You can delegate token creation permissions to me using the delegation manager above. Once set up, I'll be able to create custom ERC20 tokens for you with limited permissions."
          }`,
          id: "system",
        },
      ],
    });

  // Render chat interface and handle responses
  return (
    <div className="h-full w-full space-y-4 max-w-3xl">
      <div className="border h-full max-h-96 rounded-md p-4 space-y-6 justify-end overflow-y-scroll">
        {messages.map((message) => (
          <div key={message.id}>
            {/* Render user and AI messages */}
            {message.role === "user" ? (
              <div className="flex w-full justify-start">
                <div className="w-fit max-w-md bg-gray-800 text-gray-50 rounded-md p-2">
                  <strong>User:</strong> {message.content}
                </div>
              </div>
            ) : (
              <div className="flex w-full justify-end">
                <div className="w-fit max-w-md bg-gray-100 text-gray-900 rounded-md p-2">
                  <strong>AI:</strong> {message.content}
                </div>
              </div>
            )}

            {/* Handle tool invocation results */}
            <div>
              {message.toolInvocations?.map((toolInvocation) => {
                const { toolName, toolCallId, state } = toolInvocation;
                if (state === "result" && toolName === "deployERC20") {
                  const { result } = toolInvocation;
                  return (
                    <div key={toolCallId} className="p-3 my-2 rounded">
                      {result.success ? (
                        <div className="bg-green-50 border border-green-200 p-3 rounded">
                          <h3 className="font-bold text-green-800">Token Deployed Successfully!</h3>
                          <div className="mt-2 space-y-1">
                            <p><strong>Name:</strong> {result.tokenName}</p>
                            <p><strong>Symbol:</strong> {result.tokenSymbol}</p>
                            <p><strong>Address:</strong> {result.tokenAddress}</p>
                            <p className="mt-2">
                              <a
                                href={`https://sepolia.etherscan.io/tx/${result.transactionHash}`}
                                target="_blank"
                                className="text-blue-600 underline"
                              >
                                View transaction on Etherscan
                              </a>
                            </p>
                          </div>
                        </div>
                      ) : (
                        <div className="bg-red-50 border border-red-200 p-3 rounded">
                          <h3 className="font-bold text-red-800">Token Deployment Failed</h3>
                          <p className="text-red-700 mt-1">
                            {result.error}
                          </p>
                        </div>
                      );
                    </div>
                  );
                }
              })}
            </div>
          </div>
        ))}
      </div>

      <form className="flex gap-3" onSubmit={handleSubmit}>
        <Input
          value={input}
          onChange={handleInputChange}
          placeholder="Type a message..."
        />
        <Button type="submit">Send</Button>
      </form>
    </div>
  );
};

Complete Flow: From User Request to Token Deployment

The entire process flows through these steps:

User Connects Wallet: The application detects the connected wallet and displays the Delegation Manager.
Initial Setup: The user clicks "Set Up Delegation Accounts", which creates two smart accounts and prepares for delegation.
Delegation Creation: The user clicks "Create Delegation with Restrictions", which grants Gaia limited permissions to deploy tokens.
Natural Language Interaction: The user types a request like: "Please create a token called Community Rewards Token with symbol CRT and an initial supply of 10000 tokens."
AI Processing: AI processes this request, recognizing it as a token creation instruction and extracting the key parameters.
Tool Invocation: AI invokes the deployERC20Tool with the extracted parameters (name, symbol, supply).
Delegation Redemption: The tool:
- Retrieves AI's account information and the delegation
- Encodes a call to the createToken function with the specified parameters
- Wraps this call in a delegation redemption that proves Gaia has permission
- Submits the transaction as a user operation through a bundler
On-Chain Execution:
- The bundler verifies the delegation and that the action is allowed by the caveats
- The factory contract creates a new ERC20 token with the specified parameters
- The transaction is confirmed and a TokenCreated event is emitted
Result Display: AI presents the results to the user, including:
- Confirmation of successful deployment
- The token name, symbol, and contract address

This entire process happens without the user needing to understand the underlying smart contract interactions, gas optimization, or transaction signing. They simply express what they want in natural language, and Gaia handles the rest.

The Technical Magic: How It Really Works

To fully understand this system, let's dig deeper into the technical mechanisms that make it possible.

Account Abstraction (ERC-4337)

The foundation of the delegation system is ERC-4337, the Account Abstraction standard. This separates transaction signing from transaction payment and execution, making more flexible account models.

In traditional Ethereum transactions, the account that signs a transaction must also pay for gas and must be the one executing the transaction. Account abstraction breaks these dependencies apart, enabling:

Separate accounts for signing, paying, and executing
More complex validation logic beyond simple signature verification
Batching of multiple actions into a single transaction
Gas sponsorship and alternative payment methods

Gaia leverages account abstraction through the bundler client:

// Send a user operation instead of a regular transaction
const userOpHash = await bundlerClient.sendUserOperation({
  account: aiSmartAccount,
  calls: [
    {
      to: aiSmartAccount.address,
      data: redeemDelegationCalldata,
    },
  ],
});

This approach allows AI to act as a delegate without requiring the user to send their private keys or pre-sign transactions. Instead, the delegation itself serves as the authorization.

The Function Selector: A Critical Security Boundary

One of the most important security aspects of the implementation is the use of function selectors in caveats. A function selector is the first 4 bytes of the keccak256 hash of a function signature, uniquely identifying that function.

For the factory's createToken function, the selector is calculated as:

keccak256("createToken(string,string,uint256)").substring(0, 10)
// Results in something like: "0x45ba7a0f"

This selector is used in the caveats to ensure Gaia can only call this specific function:

.addCaveat("allowedMethods", [CREATE_TOKEN_SELECTOR])

This is a critical security boundary because even if AI (or an attacker who somehow gained control of Gaia's private key) tried to call a different function on the target contract, the delegation system would reject the transaction as unauthorized.

Counterfactual Accounts: Efficiency Through Delayed Deployment

The smart accounts used in the system are "counterfactual" - they exist with predictable addresses before they're actually deployed on the blockchain. This is achieved through a technique called "CREATE2" that allows contracts to be deployed to deterministic addresses.

The benefits of this approach include:

Gas Efficiency: Accounts are only deployed when they first transact, saving deployment costs if they're never used.
Predictable Addresses: You can know an account's address before it's deployed, enabling references to it in other contracts.
Just-in-Time Deployment: Accounts can be deployed as part of the first transaction that uses them, simplifying the user experience.

This functionality is encapsulated in the toMetaMaskSmartAccount function, which creates accounts with deterministic addresses based on the deployment parameters and salt.

The interaction of AI agents with smart account/delegation technology shows a different approach of human interaction with blockchain. By allowing users to express their intentions in natural language while maintaining strict security boundaries, systems like Gaia can help bridge the gap between Web3's capabilities and mainstream adoption. This approach doesn't just make existing processes easier—it enables entirely new patterns of interaction that would be impossible with traditional interfaces. The combination of AI and delegation technology is just beginning to reveal its potential. There are more exciting directions could be taken in the future, for example: multi-chain operation, conditional multi-delegations, AI governance and even collaborative creation of tokens or other smart contract functionalities.

Some Resources:

The Code: https://github.com/meowyx/metamask-gaia-starter

Gaia Docs: https://docs.gaianet.ai/intro

Happy Coding 🚀

Introducing Gaia Toolkit: How to use it and why

Sushmita - aka meowy — Mon, 18 Aug 2025 11:43:07 +0000

Running Gaia node locally has been a bit of repetitive process filled with some hurdles, resource guesswork, and time-consuming setup procedures for each specific LLMs. The Gaia Toolkit changes this narrative by providing an intelligent, user-friendly command-line interface that makes running LLM as simple as running a single command.

The Problem with old Setup

In the old days, you would have to head over to this repo and then find specific LLM you want to run then go through the 3 steps of running your model.

That's quite a lot of steps to run one simple model and there isn't a way to determine how much RAM you have available on your device and if you can actually run the model.

I've talked to multiple builders and they're unable to understand which model to use for their own specific case and some developers even ran a huge model without knowing specifics causing their system to shut down.

These challenges have kept powerful Gaia Node capabilities out of reach for many developers who could benefit from running gaia node.

Meet the Gaia Toolkit: Simple terminal tool

The Gaia Toolkit is a comprehensive CLI tool that transforms AI model management from a technical challenge into an intuitive experience. By combining intelligent system analysis with automated model discovery, it provides the guidance and safety mechanisms needed for successful AI deployment.

Smart Model Discovery and Management

Back in the days of manually researching compatible models. The toolkit automatically fetches available models from the GaiaNet repository and intelligently categorizes them:

Size-Based Categories:

Small (1B-5B parameters): 8-16GB RAM - Perfect for quick responses and basic tasks
Standard (6B-9B parameters): 16GB RAM - Balanced performance for most use cases
Medium (10B-16B parameters): 24GB RAM - Enhanced capabilities for complex tasks
Heavy (17B-24B parameters): 32GB RAM - Professional-grade performance
Big (25B-70B parameters): 64GB RAM - Maximum capability models
Max (70B+ parameters): 128GB+ RAM - Enterprise-level solutions

Use Case Intelligence:
Models are automatically tagged with specific applications like coding, creative writing, general chat, and research, making it easy to find the right tool for your needs.

System-Aware Intelligence

What sets the Gaia Toolkit apart is its deep system awareness:

Automatic RAM Detection: Analyzes your system's available memory
Smart Recommendations: Provides personalized suggestions based on your hardware
Safety Mechanisms: Prevents system crashes by blocking oversized models
Performance Warnings: Alerts you to potential issues before installation

One-Command to run LLM

The toolkit's simple command is the gaia run command, which transforms multiple steps into a single operation:

# Deploy and run Llama 3 8B instantly
gaia run llama3-8b

# Browse available models by category
gaia list --size small --use-case coding

# Get detailed model information
gaia info phi3-mini

Key Features That Make a Difference

Multi-Layer Safety Protection

The toolkit includes sophisticated safety mechanisms to prevent system crashes:

Resource Validation: Checks system capabilities before model selection
Six-Step Override Process: For advanced users who need to push limits
Clear Risk Communication: Explicit warnings about potential consequences
Graceful Fallbacks: Handles network issues and repository unavailability

Beautiful User Experience

Technical tools don't have to be ugly or intimidating:

Professional ASCII Art Banner: Creates a welcoming first impression
Interactive Prompts: Guided setup process with clear choices
Progress Indicators: Real-time feedback during operations
Color-Coded Output: Easy-to-scan information hierarchy

Intelligent Recommendations

The gaia recommend feature provides personalized suggestions based on your specific use case:

Coding & Programming: Specialized models for development tasks
General Chat: Models optimized for natural dialogue
Creative Writing: Models designed for content generation
Research & Analysis: Models suited for analytical work
Resource-Constrained: Lightweight options for limited hardware

Real-World Impact

For Developers

# Find the perfect coding assistant
gaia recommend
> Select: Coding & Programming
> Recommended: Codestral 22B (if RAM > 24GB) or Llama 3 8B

# Run LLM instantly
gaia run codestral-22b

For Content Creators

# Browse creative writing models
gaia list --use-case creative
# Get detailed specifications
gaia info creative-model-13b
# Deploy with confidence
gaia run creative-model-13b

For Researchers

# Interactive setup for research workflow
gaia setup
> System Analysis: 32GB RAM detected
> Recommended Category: Heavy models for complex analysis
> Selected: Advanced reasoning model

What's Coming Next: Gaia Tool Test

The ecosystem continues to evolve with Gaia Toolkit, an upcoming CLI tool changes that adds interactive chat functionality and knowledge base management:

Key Features:

Interactive Chat: Connect to local or public Gaia AI nodes
Knowledge Base Management: Configure pre-built or custom knowledge bases
Multiple Connection Options: Support for both local and hosted deployments
Beautiful CLI Interface: Colorful, animated terminal experience

Pre-built Knowledge Bases Include:

London Tour Guide expertise
Vyper Language programming knowledge
Model Context Protocol (MCP) expert system
Solidity smart contract development

Getting Started Today

The Gaia Toolkit represents a fundamental shift in how we approach running LLM from terminal. By combining intelligent automation with safety-first design, it makes powerful AI capabilities accessible to developers, researchers, and organizations of all sizes.

Ready to experience simplified AI deployment?

Explore Available Models: gaia list
Get Personalized Recommendations: gaia recommend
Deploy Instantly: gaia run <model-name>

Toolkit Roadmap

Currently we're at the very first stage where trying to make available features of swapping knowledge base and adding simple CLI chat.

After that there's definitely plan to make it part of OSS Program.
We want to see gaia toolkit to become one tool for everything in the process.

Thank you so much for reading. Give gaia toolkit a try. Happy Building. 🚀

Web3, Community & Education

Sushmita - aka meowy — Wed, 05 Jun 2024 19:18:18 +0000

I'm a Developer Relations Engineer at Gaia. I connect with the web3 + AI developer community to empower them with the technology and the tools to build their own AI Agents. By providing resources, creating engaging content, and hosting workshops, I aim to enhance the developer experience and foster a collaborative environment. My role bridges the gap between our technology and the community, ensuring developers have the support they need to succeed.

Previously I was a Developer Relations Engineer at Consensys, focused on Linea and MetaMask. I focus on building use-cases, contents and tutorials to improver developer experience. Before that I was also part of the RAD(Rapid Application Development) Team at Consensys, where I mainly focused on building full-stack web3 applications, use cases, and content using all the Consensys products available. I work primarily with Nextjs, TypeScript, React, and Solidity. I have over 3 years of experience in building web3 applications. I am passionate about learning new technologies and always look for new opportunities to learn and grow.

I have also worked on Udacity's Blockchain Nanodegree program.

I worked as an educational consultant (contractor) for Chainlink Certification, where I contributed to developing an educational curriculum focused on blockchain, smart contracts, and Chainlink technologies. My role involved assisting in the creation of certification exams to assess proficiency in blockchain and oracle concepts, as well as designing content related to oracle network concepts to enhance learning outcomes.

I have been involved with a web3 DAO (Decentralized Autonomous Organization) where I founded and led two teams. One team worked on an education platform, while the other focused on inclusivity and diversity. I led the education team in launching an education website and developing resources. My responsibilities included creating the website and writing content on Solidity Smart Contracts.

In this section, you can find all my blog articles, videos, podcasts, and workshops spanning from 2021 to 2025.