Anthropic lanzó en mayo de 2026 Claude Managed Agents, una suite de APIs diseñada para que developers puedan deployar agentes autónomos en producción en días, no en meses. Si sos developer en Argentina o LATAM y querés construir tu propio agente de IA, esta guía te muestra el camino completo: desde el setup hasta el despliegue, con código de ejemplo en Python.

Los agentes de IA no son chatbots complejos: son sistemas que pueden razonar, tomar decisiones, usar herramientas externas y completar tareas de múltiples pasos de forma autónoma. Con la API de Anthropic y el modelo Claude, construir uno es más accesible que nunca para developers de LATAM.

Qué es un agente de IA y por qué construir uno con Claude

Un agente de IA es un sistema que percibe su entorno, razona sobre él y toma acciones para alcanzar un objetivo. A diferencia de una simple llamada a una API de LLM, un agente puede:

• Ejecutar múltiples pasos de razonamiento (chain-of-thought)

• Usar herramientas externas: buscar en la web, consultar bases de datos, ejecutar código

• Tomar decisiones basadas en el resultado de acciones previas

• Manejar contexto largo entre múltiples interacciones

Claude de Anthropic es especialmente bueno para agentes por su capacidad de seguir instrucciones complejas, su ventana de contexto extendida y su comportamiento predecible en tareas de múltiples pasos. Según el informe de capacidades de Anthropic, Claude mantiene coherencia en tareas de hasta 100+ pasos consecutivos.

Paso 1: Setup y credenciales

Primero necesitás una API key de Anthropic. Creá una cuenta en console.anthropic.com y generá tu clave. Luego instalá el SDK oficial:

pip install anthropic

pip install anthropic

pip install anthropic

pip install anthropic

Configurá tu API key como variable de entorno:

export ANTHROPIC_API_KEY="tu-api-key-aqui"

export ANTHROPIC_API_KEY="tu-api-key-aqui"

export ANTHROPIC_API_KEY="tu-api-key-aqui"

export ANTHROPIC_API_KEY="tu-api-key-aqui"

O en Python directamente:

import anthropic
client = anthropic.Anthropic(api_key="tu-api-key-aqui")

import anthropic
client = anthropic.Anthropic(api_key="tu-api-key-aqui")

import anthropic
client = anthropic.Anthropic(api_key="tu-api-key-aqui")

import anthropic
client = anthropic.Anthropic(api_key="tu-api-key-aqui")

Paso 2: Definir herramientas (tools)

Las herramientas son funciones que el agente puede usar para interactuar con el mundo externo. En la API de Anthropic, se definen como objetos JSON con nombre, descripción y schema de parámetros. Claude decide cuándo y cómo usarlas.

Ejemplo de una herramienta para buscar información del clima:

tools = [
    {
        "name": "get_weather",
        "description": "Obtiene el clima actual para una ciudad específica",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "Nombre de la ciudad, ej: Buenos Aires"
                },
                "units": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Unidad de temperatura"
                }
            },
            "required": ["city"]
        }
    }
]

tools = [
    {
        "name": "get_weather",
        "description": "Obtiene el clima actual para una ciudad específica",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "Nombre de la ciudad, ej: Buenos Aires"
                },
                "units": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Unidad de temperatura"
                }
            },
            "required": ["city"]
        }
    }
]

tools = [
    {
        "name": "get_weather",
        "description": "Obtiene el clima actual para una ciudad específica",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "Nombre de la ciudad, ej: Buenos Aires"
                },
                "units": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Unidad de temperatura"
                }
            },
            "required": ["city"]
        }
    }
]

tools = [
    {
        "name": "get_weather",
        "description": "Obtiene el clima actual para una ciudad específica",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "Nombre de la ciudad, ej: Buenos Aires"
                },
                "units": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Unidad de temperatura"
                }
            },
            "required": ["city"]
        }
    }
]

Podés definir cualquier herramienta: consultar una API externa, buscar en una base de datos, ejecutar código Python, leer archivos, enviar emails, etc.

Paso 3: El loop de agente

El núcleo de cualquier agente es un loop: el modelo recibe un mensaje, decide si usar una herramienta, ejecuta la herramienta, recibe el resultado y continúa razonando. Aquí está el patrón básico en Python:

import anthropic
import json

client = anthropic.Anthropic()

def run_agent(user_message: str, tools: list, tool_functions: dict):
    messages = [{"role": "user", "content": user_message}]
    
    while True:
        response = client.messages.create(
            model="claude-opus-4-6",
            max_tokens=4096,
            tools=tools,
            messages=messages
        )
        
        # Si el modelo terminó, devolvemos la respuesta
        if response.stop_reason == "end_turn":
            return response.content[0].text
        
        # Si el modelo quiere usar una herramienta
        if response.stop_reason == "tool_use":
            messages.append({"role": "assistant", "content": response.content})
            
            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    # Ejecutar la función correspondiente
                    func = tool_functions.get(block.name)
                    result = func(**block.input) if func else "Herramienta no encontrada"
                    
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": str(result)
                    })
            
            messages.append({"role": "user", "content": tool_results})

import anthropic
import json

client = anthropic.Anthropic()

def run_agent(user_message: str, tools: list, tool_functions: dict):
    messages = [{"role": "user", "content": user_message}]
    
    while True:
        response = client.messages.create(
            model="claude-opus-4-6",
            max_tokens=4096,
            tools=tools,
            messages=messages
        )
        
        # Si el modelo terminó, devolvemos la respuesta
        if response.stop_reason == "end_turn":
            return response.content[0].text
        
        # Si el modelo quiere usar una herramienta
        if response.stop_reason == "tool_use":
            messages.append({"role": "assistant", "content": response.content})
            
            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    # Ejecutar la función correspondiente
                    func = tool_functions.get(block.name)
                    result = func(**block.input) if func else "Herramienta no encontrada"
                    
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": str(result)
                    })
            
            messages.append({"role": "user", "content": tool_results})

import anthropic
import json

client = anthropic.Anthropic()

def run_agent(user_message: str, tools: list, tool_functions: dict):
    messages = [{"role": "user", "content": user_message}]
    
    while True:
        response = client.messages.create(
            model="claude-opus-4-6",
            max_tokens=4096,
            tools=tools,
            messages=messages
        )
        
        # Si el modelo terminó, devolvemos la respuesta
        if response.stop_reason == "end_turn":
            return response.content[0].text
        
        # Si el modelo quiere usar una herramienta
        if response.stop_reason == "tool_use":
            messages.append({"role": "assistant", "content": response.content})
            
            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    # Ejecutar la función correspondiente
                    func = tool_functions.get(block.name)
                    result = func(**block.input) if func else "Herramienta no encontrada"
                    
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": str(result)
                    })
            
            messages.append({"role": "user", "content": tool_results})

import anthropic
import json

client = anthropic.Anthropic()

def run_agent(user_message: str, tools: list, tool_functions: dict):
    messages = [{"role": "user", "content": user_message}]
    
    while True:
        response = client.messages.create(
            model="claude-opus-4-6",
            max_tokens=4096,
            tools=tools,
            messages=messages
        )
        
        # Si el modelo terminó, devolvemos la respuesta
        if response.stop_reason == "end_turn":
            return response.content[0].text
        
        # Si el modelo quiere usar una herramienta
        if response.stop_reason == "tool_use":
            messages.append({"role": "assistant", "content": response.content})
            
            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    # Ejecutar la función correspondiente
                    func = tool_functions.get(block.name)
                    result = func(**block.input) if func else "Herramienta no encontrada"
                    
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": str(result)
                    })
            
            messages.append({"role": "user", "content": tool_results})

Paso 4: Manejo de contexto

En tareas largas, el historial de mensajes puede crecer y superar el límite de contexto del modelo. Hay tres estrategias principales:

• Sliding window: Mantenés solo los últimos N mensajes. Simple pero puede perder información importante.

• Summarization: Cuando el contexto supera un umbral, pedís al modelo que resuma la conversación hasta ese punto y usás el resumen como contexto.

• Vector memory: Guardás las interacciones en una base de datos vectorial (Pinecone, pgvector) y recuperás solo los fragmentos relevantes para cada nueva consulta. Esto escala a sesiones indefinidamente largas.

Para la mayoría de agentes en producción en empresas de LATAM, la estrategia de summarization combinada con vector memory es el estándar recomendado según la documentación oficial de Anthropic sobre memoria en agentes.

Paso 5: Despliegue en producción

Para llevar un agente a producción, necesitás pensar en:

• API wrapper: Exponer tu agente como un endpoint REST (FastAPI o Flask) para que otras aplicaciones puedan consumirlo.

• Manejo de errores: Los LLMs pueden fallar o generar respuestas inesperadas. Implementá retry logic y validación de outputs.

• Rate limits: La API de Anthropic tiene límites de tokens por minuto. Para agentes con alto volumen, implementá una cola de mensajes (Redis, SQS).

• Observabilidad: Logueá cada paso del loop de agente para poder debuggear comportamientos inesperados. Herramientas como LangSmith o Weights & Biases son útiles para esto.

Si estás diseñando sistemas con múltiples agentes que se comunican entre sí, también podés leer sobre LLMOps: cómo gestionar modelos de lenguaje en producción en LATAM, donde cubrimos herramientas y estrategias específicas para el ecosistema de la región.

Ejemplo completo: agente de research

Aquí un ejemplo de agente que puede buscar información en la web y resumirla:

import anthropic
import requests

client = anthropic.Anthropic()

def search_web(query: str) -> str:
    # Simula una búsqueda web (en producción usarías SerpAPI, Tavily, etc.)
    return f"Resultados de búsqueda para '{query}': [contenido relevante]"

tools = [{
    "name": "search_web",
    "description": "Busca información actualizada en la web sobre cualquier tema",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {"type": "string", "description": "Consulta de búsqueda"}
        },
        "required": ["query"]
    }
}]

tool_functions = {"search_web": search_web}

# Usar el agente
resultado = run_agent(
    "¿Cuáles son las últimas novedades sobre modelos de IA open source?",
    tools,
    tool_functions
)
print(resultado)

import anthropic
import requests

client = anthropic.Anthropic()

def search_web(query: str) -> str:
    # Simula una búsqueda web (en producción usarías SerpAPI, Tavily, etc.)
    return f"Resultados de búsqueda para '{query}': [contenido relevante]"

tools = [{
    "name": "search_web",
    "description": "Busca información actualizada en la web sobre cualquier tema",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {"type": "string", "description": "Consulta de búsqueda"}
        },
        "required": ["query"]
    }
}]

tool_functions = {"search_web": search_web}

# Usar el agente
resultado = run_agent(
    "¿Cuáles son las últimas novedades sobre modelos de IA open source?",
    tools,
    tool_functions
)
print(resultado)

import anthropic
import requests

client = anthropic.Anthropic()

def search_web(query: str) -> str:
    # Simula una búsqueda web (en producción usarías SerpAPI, Tavily, etc.)
    return f"Resultados de búsqueda para '{query}': [contenido relevante]"

tools = [{
    "name": "search_web",
    "description": "Busca información actualizada en la web sobre cualquier tema",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {"type": "string", "description": "Consulta de búsqueda"}
        },
        "required": ["query"]
    }
}]

tool_functions = {"search_web": search_web}

# Usar el agente
resultado = run_agent(
    "¿Cuáles son las últimas novedades sobre modelos de IA open source?",
    tools,
    tool_functions
)
print(resultado)

import anthropic
import requests

client = anthropic.Anthropic()

def search_web(query: str) -> str:
    # Simula una búsqueda web (en producción usarías SerpAPI, Tavily, etc.)
    return f"Resultados de búsqueda para '{query}': [contenido relevante]"

tools = [{
    "name": "search_web",
    "description": "Busca información actualizada en la web sobre cualquier tema",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {"type": "string", "description": "Consulta de búsqueda"}
        },
        "required": ["query"]
    }
}]

tool_functions = {"search_web": search_web}

# Usar el agente
resultado = run_agent(
    "¿Cuáles son las últimas novedades sobre modelos de IA open source?",
    tools,
    tool_functions
)
print(resultado)

Cursos de Coderhouse para dominar el desarrollo con IA

Si querés ir más allá de este tutorial y construir agentes robustos en producción, Coderhouse tiene formación específica para cada nivel:

• Curso de AI Agents: el curso más específico para construir agentes autónomos con distintos frameworks y APIs, incluyendo Anthropic Claude.

• Curso de AI Engineering: para aprender a integrar LLMs en sistemas de producción, con foco en arquitecturas escalables, manejo de contexto y observabilidad.

• Carrera Desarrollo Full Stack: si además querés construir el front-end y back-end que envuelve tu agente, esta carrera te da las bases sólidas de desarrollo web moderno.

Preguntas frecuentes

¿Cuánto cuesta usar la API de Anthropic para construir un agente?

Anthropic cobra por tokens de entrada y salida. Claude claude-sonnet-4-6, uno de los modelos más usados para agentes, cuesta aproximadamente $3 por millón de tokens de entrada y $15 por millón de tokens de salida (precios de mayo 2026, sujetos a cambios). Para proyectos pequeños o MVPs, el costo es muy manejable. Para producción a escala, conviene optimizar el tamaño del contexto y usar caché de prompts.

¿Qué diferencia hay entre usar la API de Anthropic directamente y usar LangChain o LlamaIndex?

LangChain y LlamaIndex son frameworks de alto nivel que abstraen la complejidad de construir agentes: manejan el loop, la memoria, los tool calls y la integración con decenas de fuentes de datos. La API directa te da más control y menos dependencias. Para producción, la API directa suele ser más robusta y predecible; los frameworks son ideales para prototipado rápido.

¿Claude puede usar herramientas en paralelo?

Sí. Claude soporta parallel tool use: puede solicitar múltiples herramientas en un solo turno, lo que reduce la latencia en agentes que necesitan obtener información de varias fuentes simultáneamente. Esto se configura en el parámetro tool_choice del request.

¿Qué es Claude Managed Agents y cómo se diferencia de la API estándar?

Claude Managed Agents es la suite lanzada por Anthropic en mayo de 2026 que agrega sobre la API base: gestión de estado de sesión, memoria persistente, orquestación de sub-agentes y monitoreo integrado. Reduce el trabajo de infraestructura para deployar agentes en producción, aunque la API base sigue siendo la opción más flexible para casos de uso personalizados.

¿Es posible construir agentes multi-modal con la API de Anthropic?

Sí. Claude soporta entradas de texto e imágenes, lo que permite construir agentes que analizan capturas de pantalla, documentos escaneados, gráficos y otras imágenes. En la práctica, esto habilita casos de uso como agentes que leen reportes en PDF con imágenes o que inspeccionan interfaces de usuario para automatizar tareas de QA.