Getting Started with AI Agent Development: A Practical Guide

Building AI agents in 2025 is simultaneously easier and more complex than ever. The tools are better, the patterns are clearer, but the possibilities have expanded dramatically. This guide walks you through building agents that can operate autonomously in the real world.

What We're Building

By the end of this guide, you'll understand how to create an AI agent that can:

• Reason about tasks and make decisions
• Use external skills to accomplish goals
• Pay for services autonomously via x402
• Operate continuously without human supervision

Let's start.

The Agent Architecture

Modern AI agents follow a common pattern:

┌─────────────────────────────────────────┐
│                  Agent                   │
├─────────────────────────────────────────┤
│  ┌─────────┐  ┌──────────┐  ┌────────┐ │
│  │  Brain  │  │  Memory  │  │ Wallet │ │
│  │  (LLM)  │  │  (State) │  │(Crypto)│ │
│  └────┬────┘  └────┬─────┘  └───┬────┘ │
│       │            │            │       │
│  ┌────┴────────────┴────────────┴────┐ │
│  │           Skill Interface          │ │
│  └────────────────┬───────────────────┘ │
└───────────────────┼─────────────────────┘
                    │
        ┌───────────┼───────────┐
        ▼           ▼           ▼
   ┌─────────┐ ┌─────────┐ ┌─────────┐
   │ Skill A │ │ Skill B │ │ Skill C │
   └─────────┘ └─────────┘ └─────────┘

The Brain (LLM)

The reasoning engine. Takes the current situation, decides what to do next. Usually a capable language model (GPT-4, Claude, etc.) with function-calling abilities.

Memory (State)

What the agent remembers. Short-term (current conversation/task) and long-term (persistent knowledge, past experiences).

Wallet

The agent's ability to pay for things. Holds crypto (typically USDC), can sign transactions, manages spending limits.

Skill Interface

How the agent calls external capabilities. Handles discovery, invocation, payment, and error handling.

Step 1: Setting Up the Foundation

Start with your development environment:

mkdir my-agent
cd my-agent
npm init -y
npm install openai viem dotenv

Create your basic agent structure:

// agent.ts
import OpenAI from 'openai';
import { createWalletClient, http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { base } from 'viem/chains';

// Initialize components
const openai = new OpenAI();
const account = privateKeyToAccount(process.env.AGENT_PRIVATE_KEY as 0x${string});
const wallet = createWalletClient({
  account,
  chain: base,
  transport: http(),
});

// Agent state
interface AgentState {
  task: string | null;
  memory: string[];
  budget: number;
  spent: number;
}

const state: AgentState = {
  task: null,
  memory: [],
  budget: 10.00, // $10 max spend
  spent: 0,
};

Step 2: Defining Skills

Skills are the agent's capabilities. Define them as tools the LLM can use:

// skills.ts
export const skills = [
  {
    name: 'get_market_data',
    description: 'Get current price and market data for a cryptocurrency',
    endpoint: 'https://x402skills.com/api/skills/market-data',
    pricePerCall: 0.001,
    parameters: {
      type: 'object',
      properties: {
        symbol: {
          type: 'string',
          description: 'Token symbol (e.g., BTC, ETH)',
        },
      },
      required: ['symbol'],
    },
  },
  {
    name: 'search_web',
    description: 'Search the web and return relevant results',
    endpoint: 'https://x402skills.com/api/skills/web-search',
    pricePerCall: 0.005,
    parameters: {
      type: 'object',
      properties: {
        query: {
          type: 'string',
          description: 'Search query',
        },
      },
      required: ['query'],
    },
  },
  // Add more skills as needed
];

Step 3: The Reasoning Loop

The agent operates in a loop: observe → think → act → repeat.

// loop.ts
async function agentLoop() {
  while (state.task) {
    // 1. Build context
    const context = buildContext(state);

    // 2. Ask LLM what to do
    const response = await openai.chat.completions.create({
      model: 'gpt-4-turbo',
      messages: [
        { role: 'system', content: AGENT_PROMPT },
        { role: 'user', content: context },
      ],
      tools: skills.map(skillToTool),
      tool_choice: 'auto',
    });

    // 3. Execute actions
    const message = response.choices[0].message;

    if (message.tool_calls) {
      for (const call of message.tool_calls) {
        await executeSkill(call);
      }
    }

    // 4. Check if done
    if (message.content?.includes('[TASK_COMPLETE]')) {
      break;
    }

    // 5. Update memory
    state.memory.push(JSON.stringify(message));
  }
}

Step 4: Executing Skills with Payment

Here's where skills meet payments:

// execute.ts
async function executeSkill(call: ToolCall) {
  const skill = skills.find(s => s.name === call.function.name);
  if (!skill) throw new Error(Unknown skill: ${call.function.name});

  // Budget check
  if (state.spent + skill.pricePerCall > state.budget) {
    throw new Error('Budget exceeded');
  }

  // Initial request
  let response = await fetch(skill.endpoint, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: call.function.arguments,
  });

  // Handle payment if required
  if (response.status === 402) {
    const paymentInfo = await response.json();

    // Execute payment
    const tx = await sendPayment(
      paymentInfo.address,
      paymentInfo.amount,
      paymentInfo.currency
    );

    // Retry with payment proof
    response = await fetch(skill.endpoint, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-Payment-TxHash': tx.hash,
      },
      body: call.function.arguments,
    });

    // Track spending
    state.spent += skill.pricePerCall;
  }

  return response.json();
}

Step 5: The Agent Prompt

The system prompt defines your agent's behavior:

const AGENT_PROMPT = 
You are an autonomous AI agent. Your purpose is to complete tasks 
efficiently using available skills.

GUIDELINES:
Break complex tasks into subtasks
Use skills only when necessary
Verify results before considering tasks complete
If stuck, explain why and request guidance
Always respect budget constraints

AVAILABLE SKILLS:
${skills.map(s => - ${s.name}: ${s.description} ($${s.pricePerCall}/call)).join('\n')}


When the task is complete, include [TASK_COMPLETE] in your response.
;

Step 6: Running Your Agent

Put it all together:

// main.ts
async function main() {
  // Set the task
  state.task = process.argv[2] || 'Research the current Bitcoin market';

  console.log(Starting agent with task: ${state.task});
  console.log(Budget: $${state.budget});

  try {
    await agentLoop();
    console.log(Task complete. Spent: $${state.spent});
  } catch (error) {
    console.error('Agent error:', error);
  }
}

main();

Run it:

npx ts-node main.ts "Get the current price of ETH and summarize recent news"

Advanced Patterns

Once you have the basics working, explore these patterns:

Parallel Skill Execution

When multiple skills don't depend on each other, call them simultaneously:

const [prices, news, sentiment] = await Promise.all([
  executeSkill(getPricesCall),
  executeSkill(getNewsCall),
  executeSkill(getSentimentCall),
]);

Memory Compression

Long-running agents accumulate too much memory. Periodically compress:

if (state.memory.length > 50) {
  const summary = await summarizeMemory(state.memory);
  state.memory = [summary];
}

Error Recovery

Skills fail. Handle it gracefully:

try {
  return await executeSkill(call);
} catch (error) {
  // Log failure
  state.memory.push(Skill ${call.function.name} failed: ${error.message});

  // Try alternative skill if available
  const alternative = findAlternativeSkill(call.function.name);
  if (alternative) {
    return await executeSkill({ ...call, function: { name: alternative } });
  }

  return null; // Let agent decide what to do
}

Budget Allocation

For complex tasks, allocate budget across subtasks:

interface SubTask {
  description: string;
  budgetAllocation: number; // percentage of total
}

function planTask(task: string, budget: number): SubTask[] {
  // Use LLM to break down task and allocate budget
  // ...
}

Testing Your Agent

Before deploying, test thoroughly:

Unit Tests

Test individual components (skills, payment logic, state management).

Integration Tests

Test full agent loops with mock skills.

Sandbox Testing

Run against real skills with minimal budgets.

Chaos Testing

Deliberately inject failures to verify error handling.

Deployment Considerations

Running agents in production requires additional considerations:

Monitoring

Track: task completion rates, spending, errors, latency. Alert on anomalies.

Budget Controls

Set hard limits at multiple levels: per-task, per-day, per-agent.

Security

• Use separate wallets per agent
• Fund only what you're willing to lose
• Allowlist acceptable skill endpoints
• Monitor for unusual behavior

Scaling

For many agents: containerization, orchestration, shared skill caches.

What's Next?

You now have a working AI agent architecture. From here:

• Add more skills: Browse x402skills for capabilities
• Improve reasoning: Fine-tune prompts, add chain-of-thought
• Build memory systems: Vector stores, knowledge graphs
• Create specialists: Agents optimized for specific domains
• Enable agent cooperation: Multiple agents working together

The AI agent economy is still forming. Developers who master agent architecture now will build the systems that define it.

Explore skills to integrate →