Agentes de IA y flujos agénticos

Los agentes de IA están transformando la forma en que interactuamos con la inteligencia artificial, pasando de simples chatbots a sistemas autónomos capaces de ejecutar tareas complejas.

La inteligencia artificial está atravesando un cambio de paradigma fundamental. Hemos pasado de la era de “conversar con máquinas” a la era de delegarles el trabajo. Ya no se trata solo de obtener una respuesta ingeniosa, sino de construir sistemas que planifican, ejecutan y supervisan flujos de trabajo complejos de principio a fin.

Del chatbot al agente IA

Hasta hace poco, el modelo mental predominante era el del chatbot: un usuario envía un input, el modelo de lenguaje (LLM) procesa la tarea y devuelve un output de texto. Este enfoque nos obligaba a ser expertos en prompts; si la instrucción no era exacta, no había acción.

El norte hasta ahora, la autonomía total similar al concepto de J.A.R.V.I.S.. La diferencia clave radica en el bucle de decisión: un agente no espera pasivamente; persigue un objetivo, percibe su entorno, razona, utiliza herramientas y se adapta si falla. Esta evolución nos lleva de reglas simples (años 60) y comandos básicos (2011) a agentes autónomos capaces de razonamiento y acción real en el mundo.

Anatomía de un agente de IA

Para entender cómo funciona un agente desde una perspectiva técnica, debemos visualizarlo como un organismo compuesto por cuatro pilares fundamentales:

1. El cerebro (LLM): es el motor de razonamiento y planificación. Modelos como GPT-4o o Claude 3.5 actúan como el agente base.

2. Memoria: provee contexto de corto y largo plazo, permitiendo que el agente aprenda de sus pasos anteriores.

3. Herramientas: la capacidad de salir del modelo para usar calculadoras, acceder a la web o invocar APIs.

4. Entorno: el espacio digital donde ocurre la acción (un navegador, una base de datos, etc.).

Ejemplo: creando un agente básico

Utilizando frameworks modernos como LangChain o CrewAI, podemos ver cómo se traduce esto a código. Imaginemos un agente especializado en investigación (el vehículo) que utiliza un modelo base (el motor) y herramientas específicas.

# REQUERIDO
!pip install langgraph langchain-openai langchain-community python-dotenv

# OPCIONAL pero RECOMENDADO para búsqueda real
!pip install tavily-pythonLenguaje del código: PHP (php)

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.tools import tool
from langchain_community.tools import TavilySearchResults
from langgraph.prebuilt import create_react_agent  # ✅ CORRECTO

# ============ 1. CONFIGURACIÓN ============
load_dotenv()

openai_api_key = os.getenv("OPENAI_API_KEY")
tavily_api_key = os.getenv("TAVILY_API_KEY")

if not openai_api_key or not tavily_api_key:
    raise ValueError("Configura OPENAI_API_KEY y TAVILY_API_KEY en .env")

# ============ 2. INICIALIZAR LLM ============
llm = ChatOpenAI(model="gpt-4o", temperature=0)

# ============ 3. DEFINIR HERRAMIENTAS REALES ============
# Opción A: Usar TavilySearchResults (RECOMENDADO - búsqueda real)
search_tool = TavilySearchResults(
    max_results=5,
    include_answer=True
)

# Opción B: Definir herramienta personalizada con @tool
@tool
def analyze_data(topic: str) -> str:
    """Analiza datos sobre un tema específico.
    
    Args:
        topic: El tema a analizar
    
    Returns:
        Análisis detallado
    """
    return f"Análisis de {topic}"

# Combinar herramientas
tools = [search_tool, analyze_data]

# ============ 4. CREAR AGENTE (SIN AgentExecutor) ============
# create_react_agent maneja TODO internamente
agent = create_react_agent(
    model=llm,
    tools=tools,
    prompt="Eres un asistente IA útil. Puedes usar herramientas para investigar."
)

# ============ 5. EJECUTAR EL AGENTE ============
if __name__ == "__main__":
    # Usar .invoke() con estructura de mensajes correcta
    result = agent.invoke({
        "messages": [
            {
                "role": "user",
                "content": "Analiza las tendencias de IA en 2026. Busca información reciente y proporciona un reporte breve."
            }
        ]
    })
    
    # Extraer y mostrar resultado
    print("\n" + "="*70)
    print("RESULTADO FINAL:")
    print("="*70)
    last_message = result["messages"][-1]
    print(last_message.content)
Lenguaje del código: PHP (php)

La escalera de la autonomía

No todos los problemas requieren un agente autónomo. Las fuentes sugieren una Matriz de Decisión para usar la solución proporcional al problema:

• Automatización clásica: para tareas repetitivas y predecibles (ej. reportes fijos).
• Workflows con IA: para procesos estructurados con inputs flexibles (ej. procesar facturas).
• Agentes autónomos: para tareas complejas, no determinísticas, que requieren navegación y toma de decisiones (ej. planificar un viaje completo).

Arquitecturas: ¿lobo solitario o equipo?

Existen dos formas principales de desplegar estos sistemas:

• Agente único (single agent): un cerebro centralizado conectado a muchas herramientas. Es ideal para tareas secuenciales rápidas, pero puede confundirse si tiene demasiadas opciones.
• Sistemas multi-agente: un ecosistema de agentes especializados (investigador, redactor, crítico) coordinados por un orquestador. Esto permite el conflicto constructivo y es ideal para contextos de alta complejidad.

El nuevo rol humano: de productor a orquestador

Este cambio tecnológico transforma nuestra función. Pasamos del human-in-the-loop (ejecución manual) al human-on-the-loop (supervisión). Nuestras responsabilidades ahora son:

• Definir objetivos estratégicos.
• Auditar resultados y calidad.
• Manejar excepciones éticas y dar feedback para mejorar al agente.

¿Cuáles son las diferencias clave entre LangChain y CrewAI?

Dentro del ecosistema de desarrollo de inteligencia artificial, LangChain y CrewAI representan dos enfoques distintos pero complementarios para construir sistemas agénticos. Mientras que LangChain se enfoca en la infraestructura y la conectividad, CrewAI se especializa en la orquestación y el trabajo en equipo.

Aquí te presento las diferencias fundamentales explicadas desde la tecnología y la colaboración humana:

1. El enfoque: “cadenas” vs. “equipos”

• LangChain es un framework de propósito general diseñado para crear cadenas de pensamiento y conectar modelos de lenguaje con datos externos y herramientas. Es ideal para construir el agente único o “lobo solitario”, el cual es eficiente para tareas secuenciales y rápidas.
• CrewAI está diseñado específicamente para la orquestación de sistemas Multi-Agente. Su filosofía no es solo que una IA haga una tarea, sino que un grupo de agentes especializados colaboren, se deleguen trabajo y generen un conflicto constructivo para mejorar el resultado final.

2. Arquitectura y roles

Las fuentes distinguen entre el agente base y el agente especializado.

• En LangChain, tú construyes el vehículo paso a paso: defines la memoria, el prompt y las herramientas de forma manual.
• En CrewAI, el enfoque es el rol. Defines un investigador y un redactor, y el framework maneja cómo interactúan entre ellos bajo la supervisión de un orquestador.

3. Implementación en código

Para entenderlo mejor, veamos cómo se estructuran de manera simplificada:

• Ejemplo con LangChain (enfoque en la herramienta)

pip install langchain-openai langchain langchain-core

# ========================================
# AGENTE CALCULADORA - LANGCHAIN 2026
# ========================================
from langchain_openai import ChatOpenAI
from langchain.tools import tool
from langchain.agents import create_agent  # ← NUEVA IMPORTACIÓN
import operator

# ⚠️ PASO 1: REEMPLAZA CON TU KEY REAL
# Ve a https://platform.openai.com/api-keys → "Create new secret key"
API_KEY = "sk-proj-TU-KEY-REAL-AQUI"  # ← ← ← ← ← ← ← ← ← ← ←

# 1. LLM con tu API key
llm = ChatOpenAI(
    model="gpt-4o", 
    temperature=0, 
    api_key=API_KEY  # ← Tu key real aquí
)

# 2. Calculadora SEGURA (sin eval() peligroso)
@tool
def calculadora(expresion: str) -> float:
    """Calcula expresiones matemáticas seguras como '25 * 1500 / 100'."""
    # Solo permite operaciones básicas: + - * / **
    allowed_ops = {
        '+': operator.add, '-': operator.sub, 
        '*': operator.mul, '/': operator.truediv, '**': operator.pow
    }
    
    try:
        # Evalúa SOLO con operadores seguros
        resultado = eval(expresion, {"__builtins__": {}}, allowed_ops)
        return round(float(resultado), 2)
    except Exception:
        return 0.0

# Lista de herramientas
tools = [calculadora]

# 3. Crear agente MODERNO (LangChain 2026)
agent = create_agent(
    model=llm,
    tools=tools,
    system_prompt="Eres un asistente experto en matemáticas. "
                  "Usa la herramienta 'calculadora' para cálculos precisos."
)

# 4. TU CONSULTA ORIGINAL ✅
result = agent.invoke({
    "messages": [{"role": "user", "content": "¿Cuánto es 25% de 1500?"}]
})

# RESULTADO ESPERADO
print("=" * 50)
print("✅ RESPUESTA DEL AGENTE:")
print("=" * 50)
print(result["messages"][-1].content)Lenguaje del código: PHP (php)

Aquí creamos un agente que simplemente usa una herramienta para resolver una instrucción.

• Ejemplo con CrewAI (enfoque en colaboración Multi-Agente)

Aquí creamos un sistema donde un agente investiga y otro escribe, permitiendo una planificación de punta a punta.

!pip install crewai crewai[tools]Lenguaje del código: CSS (css)

from crewai import Agent, Task, Crew
import os

# ← AQUÍ TU KEY REAL (NO "aqui")
os.environ["OPENAI_API_KEY"] = "sk-proj-abcd1234efgh5678ijklm..."

# Agentes
investigador = Agent(
    role='Investigador de IA',
    goal='Analizar tendencias IA 2026',
    backstory='Experto IALAB UBA',
    verbose=True,
    allow_delegation=False
)

redactor = Agent(
    role='Redactor Técnico',
    goal='Escribir artículo técnico',
    backstory='Transforma datos complejos en historias claras',
    verbose=True,
    allow_delegation=False
)

# Tarea
tarea = Task(
    description="Reporte agentes autónomos IA 2026",
    agent=investigador,
    expected_output="Reporte markdown 500-800 palabras"
)

# Crew (verbose=True, NO 2)
equipo = Crew(
    agents=[investigador, redactor],
    tasks=[tarea],
    verbose=True  # ← Booleano correcto
)

# Ejecutar
resultado = equipo.kickoff()
print(resultado)Lenguaje del código: PHP (php)

Desafíos y realidad

A pesar del optimismo, los flujos agénticos enfrentan limitaciones críticas que debemos considerar:

• Bucles infinitos: el agente puede atascarse intentando resolver un paso sin éxito.

• Alucinaciones en cadena: un error en el paso inicial se amplifica en los pasos siguientes.

• Costos y latencia: el razonamiento complejo (chain-of-thought) es más lento y costoso computacionalmente.

En resumen, el futuro no es el reemplazo total, sino un modelo híbrido donde equipos de agentes especializados son orquestados por humanos expertos para alcanzar niveles de eficiencia y escala nunca antes vistos, destacando la importancia de mantener una supervisión humana responsable para validar resultados y mitigar riesgos éticos.