Agentes Autónomos con Claude

Arquitectura de Agentes: cómo estructurar el sistema

/app/api/cron/
├── oracle/route.ts      # Dispara ORACLE diario
├── vera/route.ts        # Dispara VERA semanal
├── repo/route.ts        # Dispara REPO diario
└── signal/route.ts      # Dispara SIGNAL lunes

/lib/agents/
├── base.ts              # Clase base AgentRunner
├── oracle.ts            # Lógica de ORACLE
├── vera.ts              # Lógica de VERA
├── repo.ts              # Lógica de REPO
└── types.ts             # Tipos compartidos

/lib/tools/
├── web-scraper.ts       # Tool de scraping
├── email-sender.ts      # Tool de emails
├── db-writer.ts         # Tool de DB
└── index.ts             # Registry de tools

// lib/agents/base.ts
import Anthropic from '@anthropic-ai/sdk'
import { createClient } from '@supabase/supabase-js'

export interface AgentConfig {
  name: string
  systemPrompt: string
  tools: Anthropic.Tool[]
  maxTokens?: number
  model?: string
}

export interface AgentResult {
  success: boolean
  output: string
  tokensUsed: number
  duration: number
  error?: string
}

export class AgentRunner {
  private client: Anthropic
  private supabase: ReturnType<typeof createClient>
  private config: AgentConfig

  constructor(config: AgentConfig) {
    this.config = config
    this.client = new Anthropic()
    this.supabase = createClient(
      process.env.SUPABASE_URL!,
      process.env.SUPABASE_SERVICE_KEY!
    )
  }

  async run(userMessage: string): Promise<AgentResult> {
    const startTime = Date.now()
    let tokensUsed = 0

    try {
      // Loop de agente: sigue hasta que no haya más tool calls
      let messages: Anthropic.MessageParam[] = [
        { role: 'user', content: userMessage }
      ]

      while (true) {
        const response = await this.client.messages.create({
          model: this.config.model || 'claude-sonnet-4-20250514',
          max_tokens: this.config.maxTokens || 4096,
          system: this.config.systemPrompt,
          tools: this.config.tools,
          messages,
        })

        tokensUsed += response.usage.input_tokens + response.usage.output_tokens

        // Si no hay tool calls, terminamos
        if (response.stop_reason === 'end_turn') {
          const textContent = response.content.find(c => c.type === 'text')
          return {
            success: true,
            output: textContent?.text || '',
            tokensUsed,
            duration: Date.now() - startTime,
          }
        }

        // Procesar tool calls
        const toolCalls = response.content.filter(c => c.type === 'tool_use')
        const toolResults: Anthropic.MessageParam = {
          role: 'user',
          content: await Promise.all(
            toolCalls.map(async (tc) => ({
              type: 'tool_result' as const,
              tool_use_id: tc.id,
              content: await this.executeTool(tc.name, tc.input),
            }))
          ),
        }

        messages.push({ role: 'assistant', content: response.content })
        messages.push(toolResults)
      }
    } catch (error) {
      return {
        success: false,
        output: '',
        tokensUsed,
        duration: Date.now() - startTime,
        error: error instanceof Error ? error.message : 'Unknown error',
      }
    }
  }

  private async executeTool(name: string, input: unknown): Promise<string> {
    // Implementar cada tool aquí
    const tools: Record<string, (input: unknown) => Promise<string>> = {
      web_search: async (i) => this.webSearch(i as { query: string }),
      save_to_db: async (i) => this.saveToDb(i as { table: string; data: unknown }),
      send_email: async (i) => this.sendEmail(i as { to: string; subject: string; body: string }),
    }

    const tool = tools[name]
    if (!tool) throw new Error(`Tool not found: ${name}`)
    return tool(input)
  }

  private async webSearch(input: { query: string }): Promise<string> {
    // Implementar búsqueda web
    return JSON.stringify({ results: [] })
  }

  private async saveToDb(input: { table: string; data: unknown }): Promise<string> {
    const { error } = await this.supabase.from(input.table).insert(input.data)
    if (error) throw error
    return 'Saved successfully'
  }

  private async sendEmail(input: { to: string; subject: string; body: string }): Promise<string> {
    // Implementar envío de email
    return 'Email sent'
  }
}

Los 7 Agentes: código completo de cada uno

Cron Jobs en Vercel

{
  "crons": [
    {
      "path": "/api/cron/oracle",
      "schedule": "0 8 * * *"
    },
    {
      "path": "/api/cron/vera",
      "schedule": "0 9 * * 5"
    },
    {
      "path": "/api/cron/repo",
      "schedule": "0 10 * * *"
    },
    {
      "path": "/api/cron/signal",
      "schedule": "0 10 * * 1"
    }
  ]
}

import { NextRequest } from 'next/server'
import { runOracle } from '@/lib/agents/oracle'

export async function GET(req: NextRequest) {
  // Verificar auth
  const authHeader = req.headers.get('authorization')
  if (authHeader !== `Bearer ${process.env.CRON_SECRET}`) {
    return Response.json({ error: 'Unauthorized' }, { status: 401 })
  }

  try {
    const result = await runOracle()

    // Log para debugging
    console.log(`ORACLE completed: ${result.success ? 'SUCCESS' : 'FAILED'}`)
    console.log(`Tokens: ${result.tokensUsed}, Duration: ${result.duration}ms`)

    if (!result.success) {
      // Notificar error
      await fetch(process.env.SLACK_WEBHOOK!, {
        method: 'POST',
        body: JSON.stringify({
          text: `🔴 ORACLE failed: ${result.error}`,
        }),
      })
    }

    return Response.json(result)
  } catch (error) {
    return Response.json({
      success: false,
      error: error instanceof Error ? error.message : 'Unknown error',
    }, { status: 500 })
  }
}

⚠ Advertencia

Tip Pro