Agent frameworks

Un agent framework es el esqueleto que sostiene el loop del agente: estado, plan, herramientas y lo que ocurre entre cada llamada al modelo. Sin framework, el agente se vuelve un script lleno de if/else que nadie puede auditar.

LangGraphCrewAIAutoGenDeepAgents

El loop: percibir, decidir, actuar, observar

Todo agente, del más simple al más complejo, ejecuta el mismo loop cuatro veces, hasta agotar un presupuesto de pasos o llegar a una respuesta final:

1. percibir: el agente mira el estado actual (system prompt, historial, resultado de la última acción) y lo que pidió el usuario.

2. decidir: el LLM produce o una respuesta final al usuario, o una llamada a herramienta con argumentos estructurados.

3. actuar: el runtime valida los argumentos contra el schema de la herramienta, la ejecuta y captura el resultado.

4. observar: el resultado vuelve al contexto y el loop se reinicia.

La parte del razonamiento solo vale algo si el loop termina, y por eso todo framework expone un límite máximo de pasos y un criterio de fin explícito.

loop.tsxtypescript

type Step = { kind: 'final'; answer: string }
       | { kind: 'tool';    tool: string; args: unknown };

async function agentLoop(state, llm, tools, maxSteps = 8) {
  for (let i = 0; i < maxSteps; i++) {
    const step: Step = await llm.decide(state);   // percibir + decidir
    if (step.kind === 'final') return step.answer; // fin
    const out = await tools[step.tool].run(step.args); // actuar
    state = state.observe(step, out);              // observar
  }
  throw new Error('loop budget exhausted');
}

Por qué usar un framework

El loop de arriba es corto, pero lo que lo rodea no lo es: persistir el estado entre pasos, retomar la conversación tras un error, paralelizar herramientas independientes, validar argumentos, gestionar reintentos y exponer observabilidad. Sin framework, lo reimplementas en cada proyecto, y lo reimplementas mal.

Un framework de agentes entrega tres cosas por las que vale la pena pagar: un grafo de ejecución explícito (ves qué puede correr y cuándo), un estado tipado que sobrevive entre pasos y la integración lista con el modelo, el proveedor de herramientas y el almacenamiento de memoria.

LangGraph: el agente como grafo de nodos

LangGraph modela el agente como una máquina de estados: cada nodo es una función (una llamada al LLM, una ejecución de herramienta, un filtro), cada arista es una decisión. El estado es un canal tipado que todos los nodos leen y escriben. Cuando el grafo es cíclico, el agente puede iterar; cuando es acíclico, es un pipeline.

El ejemplo de abajo define un agente de investigación con dos nodos (llamar al modelo y ejecutar herramienta) y una arista condicional: si el modelo pidió una herramienta, ve a tools y vuelve; si devolvió una respuesta final, termina.

research-agent.tsxtypescript

import { StateGraph, END } from '@langchain/langgraph';
import { ChatAnthropic } from '@langchain/anthropic';

type S = { messages: Array<{ role: string; content: string }> };

const llm = new ChatAnthropic({ model: 'claude-opus-4' });
const tools = { search: { run: async (q: string) => `result for ${q}` } };

const graph = new StateGraph<S>({ channels: { messages: { value: [] } } })
  .addNode('llm', async (s) => ({ messages: s.messages.concat([await llm.invoke(s.messages)]) }))
  .addNode('tool', async (s) => ({ messages: s.messages.concat([{ role: 'tool', content: 'ok' }]) }))
  .addEdge('__start__', 'llm')
  .addConditionalEdges('llm',
    (s) => s.messages.at(-1)?.content.startsWith('CALL ') ? 'tool' : END,
    { tool: 'tool', [END]: END })
  .addEdge('tool', 'llm')
  .compile();

const out = await graph.invoke({ messages: [{ role: 'user', content: '¿cuál es la capital de Francia?' }] });

DeepAgents (2025-2026): grafo de subagentes

, lanzados en 2025, generalizan el modelo de grafo a múltiples agentes cooperando: cada subagente es un nodo con su propio prompt, herramientas y presupuesto, y el grafo describe quién delega a quién. El orquestador descompone la tarea, asigna subtareas a los subagentes y consolida el resultado.

La diferencia práctica con un framework clásico es que la unidad de composición dejó de ser una herramienta y pasó a ser un agente completo. Cuando la tarea es 'investigar, analizar y redactar', instancias tres subagentes y los conectas por grafo, en vez de intentar con un único agente con 40 herramientas y un prompt monstruoso.

deepagents.pypython

from deepagents import Agent, Graph, tool as tasks


@tasks
def fetch_url(url: str) -> str:
    """Obtiene el contenido bruto de una URL."""
    return requests.get(url, timeout=10).text

researcher = Agent(name='researcher', system='investiga fuentes primarias', tools=[fetch_url])
analyst    = Agent(name='analyst',    system='sintetiza los hallazgos en puntos')
writer     = Agent(name='writer',     system='produce el informe final')

graph = Graph()
graph.add_edge('__start__', researcher)
graph.add_edge(researcher,   analyst)
graph.add_edge(analyst,      writer)
graph.add_edge(writer,       '__end__')

report = graph.run('informe sobre el mercado de LLMs en 2026')

CrewAI y AutoGen: estilos vecinos

CrewAI se enfoca en equipos con roles fijos (investigador, redactor, revisor) y un proceso de delegación más opinado; es rápido para prototipos donde la división del trabajo es conocida. AutoGen, de Microsoft, generaliza a múltiples agentes conversando entre sí, útil para explorar pero con tendencia a loops largos y un costo difícil de controlar.

La elección entre frameworks rara vez es técnica: se trata del nivel de estructura que quieres en el grafo. Cuanto más fijo el rol de cada nodo, más fácil de auditar; cuanto más flexible, más poderoso para tareas mal definidas y más caro de operar.

Puntos fuertes

loop explícito: cada framework puede saber cuánto ya corrió y qué falta correr, lo que simplifica presupuesto y auditoría
estado tipado: el canal de estado pasa a ser un contrato, no un diccionario suelto; el IDE muestra errores antes de ejecutar
grafo visual: el flujo del agente se vuelve un diagrama, y depurar se vuelve mirar el 'antes', ejecutar el nodo y leer la salida

Limitaciones

la abstracción se vuelve lock-in: migrar entre frameworks cuesta reescribir el grafo, no solo cambiar la llamada
el presupuesto del loop es heurístico: sin una buena protección, los agentes se traban en ciclos o se pasan del costo
LangGraph y DeepAgents todavía son proyectos jóvenes (2024-2026); las APIs y los contratos cambian entre versiones

DeepAgentsBiblioteca de agentes en grafo de LangChain que combina una planning tool, una filesystem tool y subagentes para resolver tareas demasiado largas para un loop único. Es una referencia práctica de agente que no se traba en la tercera tool call y el lugar donde aprendes a calibrar la autonomía antes de soltar un agente real en producción.ver en el glosario →

conexiones en el mapa

LLM - large language modeles el núcleoAgent frameworks
Agent frameworkshabilitaTool calling
Agent frameworksse coordina conOrchestration

actualizado el 14/10/2026 · fuentes para profundizar · reportar un error

en otros dominios

IAM - identidad y accesocloudsecel mínimo privilegio vale también para el agente