Introducción a los agentes de IA

Un chatbot responde preguntas. Un agente hace cosas: consulta sistemas, ejecuta herramientas y encadena pasos hasta completar una tarea. Esa diferencia, que parece de matiz, cambia por completo cómo se diseña, se prueba y se opera el software. Este post es la introducción que me habría gustado leer antes de meterme de lleno.

Qué es un agente

Un agente de IA es un sistema que puede:

1. Percibir su entorno (recibir inputs)
2. Razonar sobre qué acción tomar
3. Actuar ejecutando herramientas o APIs
4. Observar los resultados y decidir el siguiente paso

A diferencia de un LLM que solo genera texto, un agente interactúa con el mundo. El bucle es sencillo de dibujar y sorprendentemente difícil de operar bien.

La arquitectura básica

┌─────────────────────────────────────────┐
│             Usuario                      │
└─────────────────┬───────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────────┐
│          LLM (el cerebro)                │
│   - Entiende la tarea                    │
│   - Decide qué herramienta usar          │
│   - Procesa resultados                   │
└─────────────────┬───────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────────┐
│          Herramientas                    │
│   - Búsqueda web                         │
│   - Ejecución de código                  │
│   - APIs externas                        │
│   - Bases de datos                       │
└─────────────────────────────────────────┘

La pieza que ha ordenado este mundo es MCP (Model Context Protocol): un estándar para que el modelo descubra e invoque herramientas sin que cada proyecto reinvente el cableado. Si empiezas hoy, empieza por ahí.

Un ejemplo mínimo

Con PydanticAI, un agente con una herramienta de búsqueda cabe en pocas líneas:

from pydantic_ai import Agent
from pydantic_ai.common_tools.duckduckgo import duckduckgo_search_tool

agent = Agent(
    "anthropic:claude-sonnet-5",
    tools=[duckduckgo_search_tool()],
    system_prompt="Responde con datos verificados y cita la fuente.",
)

result = agent.run_sync("¿Qué modelos abiertos destacan este año?")
print(result.output)

El framework importa menos de lo que parece. Lo que importa es entender el bucle: el modelo decide, la herramienta ejecuta, el resultado vuelve al modelo.

Patrones que funcionan

ReAct (razonar y actuar). El agente piensa, actúa con una herramienta, observa el resultado y repite. Es el patrón por defecto y llega más lejos de lo que se suele creer.

Planificar y ejecutar. Para tareas largas: primero un plan explícito, luego la ejecución paso a paso, con replanificación si algo falla. La ventaja real es que el plan se puede revisar antes de gastar tokens y paciencia.

Multiagente. Varios agentes especializados que colaboran: uno investiga, otro escribe, otro revisa. Funciona, pero el precio es coordinación y contexto compartido. Mi consejo: no empieces por aquí. Llega al multiagente cuando un solo agente se te quede corto, no antes.

Los desafíos de verdad

1. Alucinaciones. El agente puede inventar. La respuesta no es confiar más, es verificar mejor: contratos estrictos y evaluación por resultado.
2. Bucles infinitos. Un agente puede atascarse repitiendo la misma acción. Los límites de presupuesto y de pasos no son opcionales.
3. Coste. Cada vuelta del bucle son tokens. La gestión del contexto es diseño, no fontanería.
4. Seguridad. Darle herramientas a un modelo exige gobernanza: permisos, entornos aislados y registro de todo lo que toca.

Hacia dónde va esto

Los asistentes de código agénticos ya escriben una parte seria del software en producción, y los protocolos como MCP han convertido la integración en un problema resuelto. Mi predicción sigue siendo la misma que hace un año, con más convicción: la mayoría de nuestras interacciones con software pasarán por agentes.

Si quieres ver uno funcionando ahora mismo, dale al botón de la esquina de esta web y pídele un tour. De cómo está construido hablo en otro post.