Construir un Agente de IA Funcional: Un Glosario Práctico

Un agente de IA es un programa que recibe un objetivo, decide una secuencia de acciones, y ejecuta esas acciones usando herramientas hasta que se cumple el objetivo o se rinde. Es diferente de un chatbot, que solo responde mensajes. Un agente planifica, llama funciones, verifica resultados, y se ajusta. Si solo has usado ChatGPT a través de un navegador, construir tu primer agente es donde el modelo deja de ser un generador de texto y se convierte en un componente de un sistema más grande.

El bucle central

Cada agente, sin importar cómo se comercialice, ejecuta alguna versión del mismo bucle: observar, pensar, actuar, repetir. Concretamente:

1. El agente recibe una tarea ("encuentra el vuelo más barato a Lisboa el próximo mes y redacta un resumen por correo").
2. Llama al LLM con la tarea más una descripción de las herramientas disponibles.
3. El modelo devuelve una respuesta final o una llamada a herramienta, como search_flights(destination="Lisbon", month="2025-06").
4. Tu código ejecuta esa función, obtiene un resultado real, y lo devuelve al contexto del modelo.
5. El modelo decide qué hacer después: llamar otra herramienta, pedir aclaración, o terminar.

Este patrón se llama frecuentemente bucle ReAct (reason plus act), y es la base de frameworks como los ejecutores de agentes de LangChain, agentes de LlamaIndex, y la API function-calling de OpenAI. Puedes implementar todo esto tú mismo en menos de 100 líneas de Python con solo una API LLM y un bucle while — los frameworks añaden conveniencia, no magia.

Las herramientas son lo que lo hacen un agente

Un modelo sin herramientas solo puede hablar. Dale funciones y puede actuar. Las herramientas típicamente son funciones Python simples envueltas con un esquema que describe su nombre, parámetros, y propósito, para que el modelo sepa cuándo y cómo llamarlas. Ejemplo:

def get_weather(city: str) -> str:
    """Return current weather for a given city."""
    resp = requests.get(f"https://api.weather.example/v1/{city}")
    return resp.json()["summary"]

Con function-calling de OpenAI, pasas un esquema JSON junto a esta función, y el modelo genera una llamada estructurada como {"name": "get_weather", "arguments": {"city": "Lisbon"}} en lugar de texto libre. Tu código analiza eso, ejecuta la función real, y devuelve el resultado como un nuevo mensaje en la conversación. Repite hasta que el modelo tenga suficiente información para responder.

Memoria y estado

Una llamada API única no tiene memoria más allá de su ventana de contexto. Los agentes necesitan estado explícito: una lista corriente de mensajes (el historial de conversación), y frecuentemente un almacén separado para hechos a más largo plazo. Para tareas cortas, una lista Python de diccionarios representando la conversación es suficiente. Para agentes que necesitan recordar cosas entre sesiones, recurrirás a una base de datos vectorial (Chroma, Pinecone, Qdrant) para almacenar y recuperar información pasada relevante vía embeddings.

No sobre-ingenierices esto al principio. Un número sorprendente de proyectos de "agentes" fracasan no porque el LLM sea débil sino porque la gestión de estado es descuidada: mensajes duplicados, crecimiento de contexto sin límite, o perder la pista de qué llamada de herramienta corresponde a qué resultado.

Un ejemplo mínimo funcional

Aquí está la forma de un agente básico usando la API de OpenAI, sin framework:

messages = [{"role": "user", "content": "What's the weather in Lisbon?"}]

while True:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        tools=[weather_tool_schema],
    )
    msg = response.choices[0].message
    if msg.tool_calls:
        for call in msg.tool_calls:
            result = get_weather(**json.loads(call.function.arguments))
            messages.append(msg)
            messages.append({
                "role": "tool",
                "tool_call_id": call.id,
                "content": result,
            })
    else:
        print(msg.content)
        break

Ese es un agente real y funcional. Todo lo demás — estrategias de planificación, coordinación multi-agente, pipelines de recuperación — se construye sobre este bucle.

Dónde falla

Los agentes fallan de formas predecibles: bucles infinitos de llamadas a herramientas cuando el modelo no puede decir que tuvo éxito, argumentos de funciones alucinados, y costos desbocados por rellamar herramientas caras. Protégete contra bucles con un límite de iteraciones duro (digamos, 10 pasos) y registra cada llamada de herramienta durante el desarrollo. Valida argumentos antes de ejecutar cualquier cosa que toque un sistema real — un agente que puede enviar correos o ejecutar comandos shell necesita la misma desinfección de entrada que aplicarías al código orientado al usuario, porque el LLM es, en efecto, un usuario no confiable generando esa entrada.

Dónde ir después

Una vez que el bucle funciona, los problemas interesantes empiezan: elegir entre diseños de agente único y multi-agente, decidir cuánta autonomía otorgar, y probar agentes de manera confiable cuando su salida no es determinística. Las pistas de IA y Python de Korra Studio cubren generación aumentada por recuperación, diseño de prompts, y patrones de tool-calling con más detalle si quieres seguir construyendo desde aquí.