Qué automatiza realmente LangChain una vez que has creado un bucle de agente
Explica cómo LangChain, LangGraph y SDK similares envuelven el mismo bucle de agente básico creado desde cero, y cuándo recurrir a un framework ayuda o perjudica.
Hasta este punto ya has creado un agente completo a partir de materiales básicos: el bucle, la memoria, las herramientas, los subagentes y los ganchos, utilizando únicamente el SDK de Anthropic. No hay ningún framework a la vista.
Este es exactamente el momento de hablar sobre frameworks, porque ahora ocurre algo útil: como construiste todo el mecanismo por ti mismo, ningún framework volverá a parecerte misterioso.
Los nombres que escuchas constantemente
LangChain. LangGraph. LlamaIndex. CrewAI. AutoGen. El SDK de OpenAI Agents.
Cada uno cuenta con su propia terminología y su propio método para abordar lo que aparentemente es la misma tarea subyacente. Si eres nuevo en este campo, la gran cantidad de opciones puede resultar abrumadora.
Existe una idea que disipa esa confusión:
Cada uno de estos frameworks está utilizando el mismo bucle que ya construiste anteriormente en esta serie.
Ese es realmente todo el secreto. Ninguno de ellos contiene magia oculta. En realidad, todos siguen la misma secuencia: enviar mensajes, examinar la razón de la interrupción, ejecutar herramientas y volver a introducir los resultados. Es el mismo bucle que ya conoces al dedillo.
Imáginalo como cocinar. Una vez que has aprendido a preparar un plato a partir de ingredientes crudos, conoces cada paso, puedes probar y ajustar durante el proceso, y si algo no sabe bien sabes exactamente qué cambiar. Un framework es más similar a un kit de comida lista: las verduras ya están picadas, la salsa está premezclada, y solo necesitas armarlo todo en unos minutos. Es más rápido, claro. Pero si la salsa resulta incorrecta, no hay forma de arreglarla, porque nunca la preparaste tú mismo y no sabes qué contiene.
Ese es el trato que ofrece cualquier framework: intercambias algo de control por mayor velocidad.
Véralo con tus propios ojos
Echemos un vistazo al mismo agente implementado dos veces: una a mano y otra mediante un framework.
Aproximadamente así se verá tu agente al usar el SDK en bruto, la versión que ahora comprendes completamente:
messages = [{"role": "user", "content": user_message}]
while True:
# call the API — this runs again every time the model asks for a tool
response = client.messages.create(
model="claude-sonnet-4-6",
tools=tools,
messages=messages,
) # if the model is done, stop
if response.stop_reason == "end_turn":
break # otherwise it asked for a tool: run it, append the result, loop again
messages.append(response_as_message)
messages.append(tool_result_message)
Este es precisamente el bucle introducido anteriormente en la serie. La llamada a la API se encuentra dentro de un bucle while porque se ejecuta repetidamente: una vez para la respuesta inicial y luego nuevamente después de que regrese el resultado de cada herramienta, hasta que el modelo indique que ha terminado.
Ahora compáralo con aproximadamente el mismo agente creado en LangChain:
from langchain.agents import create_agent
agent = create_agent(model="claude-sonnet-4-6", tools=tools)
result = agent.invoke({"messages": [user_message]})
Cinco líneas en lugar de treinta. A primera vista, eso parece una mejora obvia.
Pero fíjese en lo que desapareció. El bucle se ha ido. La verificación de stop_reason también se ha ido. El manejo manual de los mensajes ya no existe. Ninguna de esas lógicas desapareció realmente; sigue funcionando, solo está oculta dentro de create_agent, donde ya no se puede ver.
Cuando todo funciona sin problemas, se gana tiempo. Pero cuando algo falla, uno queda atascado depurando un proceso que no se puede inspeccionar.
Esa tensión es, en realidad, toda la historia detrás de los frameworks. Todo lo demás son solo detalles adicionales.
Lo que usted hace realmente vs lo que hace el framework
Aquí está la parte que suele sorprender a la gente. Una vez que se utiliza un framework, nunca se mira directamente stop_reason. Nunca se verifica la existencia de un bloque tool_use. Nunca se agrega manualmente un tool_result. Tampoco se escribe el bucle en absoluto.
En lugar de eso, su tarea se reduce a tres pasos:
- Escriba las funciones de su herramienta, tal como lo haría con el SDK original.
- Registre esas funciones con el agente mediante algo como
create_agent(tools=[...]). - Llame a
agent.invoke(...)una sola vez.
Ese es todo el flujo de trabajo. Conecta las herramientas y activa la llamada una sola vez.
Detrás de esa única llamada, el framework ejecuta en silencio todo el bucle que construyó anteriormente: envía los mensajes, verifica la razón de detención, detecta que el modelo necesita una herramienta, invoca su función, agrega el resultado, vuelve a iterar y repite ese ciclo hasta que el modelo finalmente devuelve end_turn. Solo entonces le entrega la respuesta completa.
Así que un framework no solo oculta el bucle en sí, sino también todo el mecanismo que hace posible la llamada a herramientas desde un principio. Quien aprenda sobre agentes comenzando con un framework ni siquiera sabría que existe una razón para detenerse como end_turn, ni que las llamadas a herramientas se resuelven mediante iteraciones repetidas. Para ellos, simplemente parecería “Registré una herramienta y esta se utilizó automáticamente”.
Eso está bien hasta que una llamada a herramienta comienza a comportarse de forma incorrecta. En ese momento, uno se queda frente a una caja negra, porque nunca vio los mecanismos que operan en el fondo. Usted, por el contrario, construyó ese mecanismo con sus propias manos; sabe exactamente qué está sucediendo dentro de él.
LangChain, LangGraph: ¿cuál es la diferencia?
Se topará constantemente con estos dos nombres, así que aquí está la versión breve.
LangChain es el propio framework. Proporciona definiciones de herramientas, conexiones con modelos y la función create_agent —el mismo atajo para ocultar bucles que se mencionó anteriormente.
LangGraph es un entorno de ejecución de nivel inferior sobre el cual se basa LangChain. Se utiliza cuando se necesita un control más detallado: pausar a un agente para que una persona pueda aprobar un paso, coordinar la lógica de ramificación entre varios agentes o persistir el estado para que un servidor caído pueda continuar exactamente desde donde se detuvo.
Un modelo mental sencillo: LangChain es el punto de entrada rápido y de alto nivel. LangGraph es lo que se utiliza cuando ese punto de entrada no es suficiente. Desde finales de 2025, LangChain se ha reconstruido sobre LangGraph, por lo que ya no son herramientas rivales; son dos capas de un mismo sistema, una simple y otra potente.
Si acabas de empezar, probablemente aún no los necesites. El SDK en bruto que ya conoces puede llevarte más lejos de lo que imaginas.
Cuándo es útil un framework
Los frameworks no son inherentemente una trampa. En algunas situaciones, recurrir a uno es realmente la decisión correcta.
Necesitas integraciones listas para usar. Supongamos que tu agente debe obtener registros de un almacén vectorial Pinecone y documentos de Google Drive. Es posible crear ambos conectores por tu cuenta con el SDK en bruto, pero es un proceso tedioso. LangChain ya los incluye preconstruidos: solo necesitas importarlos y conectarlos. Eso representa un ahorro real de tiempo.
Estás creando un prototipo bajo plazo. Tu jefe quiere una demostración funcional mañana por la mañana. En ese momento, los detalles internos aún no importan; solo necesitas algo funcional rápidamente. Una configuración de cinco líneas puede ayudarte a lograrlo ya esta noche.
Necesita una orquestación verdaderamente compleja de desarrollar. Imagine un agente que se detiene a mitad de tarea, espera a que alguien haga clic en “aprobar” antes de liberar un pago y luego reanuda exactamente donde se detuvo, incluso después de un reinicio del servidor. Algunos frameworks ofrecen este comportamiento ya listo para usar. Recrearlo desde cero requiere un esfuerzo de ingeniería considerable.
Cuando un framework resulta problemático
Depurar se vuelve doloroso. Imagine que su agente devuelve ocasionalmente una respuesta vacía y no puede determinar por qué. En el código que usted mismo escribió, agregaría una instrucción de impresión, seguiría el bucle y encontraría el problema en cuestión de minutos. Dentro de un framework, ese mismo error se encuentra dentro de create_agent, código que no es suyo. Acaba investigando el código fuente del framework en GitHub solo para entender qué está haciendo su propio agente.
La abstracción comienza a filtrarse. Los frameworks están optimizados para los casos habituales. Supongamos que necesitas que la salida de una herramienta esté formateada de manera no estándar, o una política de intentos reiterados adaptada a tu configuración específica. El framework nunca previó eso. Ahora tienes que recurrir a soluciones improvisadas y complicadas solo para obligarlo a hacer algo que treinta líneas de código propio podrían manejar directamente.
Al final terminas aprendiendo la herramienta en lugar del concepto. Empezar con un framework te enseña “cómo funciona LangChain”, no cómo funcionan realmente los agentes. Luego la API de LangChain cambia —y lo ha hecho repetidamente— y tu conocimiento se vuelve obsoleto de la noche a la mañana. El ciclo mencionado anteriormente en esta serie no ha cambiado desde que se crearon los agentes, y no va a cambiar.
La regla que vale la pena seguir
Comience con el SDK en bruto. Construya el bucle a mano. De esa manera sabrá con precisión qué está haciendo su agente y podrá rastrear cada línea cuando algo falle. Para la mayoría de los agentes, eso es realmente todo lo que necesitará.
Integre un framework solo cuando resuelva algo específico mejor de lo que usted podría hacerlo — una integración lista para usar, un estado que sobreviva a caídas del sistema, pasos de aprobación con intervención humana. Úselo intencionadamente, por esa razón exacta, y no como opción predeterminada.
No recurra a un framework solo para evitar aprender cómo funciona el bucle. Esa es la verdadera trampa. Si salta ese paso, terminará con una caja negra basada en ideas que nunca realmente comprendió.
Primero entienda el bucle. Después, un framework se convierte en una herramienta que elige a propósito — no en un apoyo al que recurrir porque nunca aprendió los fundamentos.
Por qué esta serie construyó todo desde cero
Ese es exactamente el motivo por el cual se ha esperado hasta ahora para utilizar frameworks.
Si esta serie hubiera comenzado con “instalar LangChain, llamar a create_agent”, tendríamos un agente funcional pero sin una comprensión real de él. No sabríamos qué es un bloque tool_use, por qué los resultados de las llamadas paralelas a herramientas se agrupan en un único mensaje, ni por qué la lógica de autorización debe estar en un hook.
Dado que ya tienes esa base, el vocabulario de cualquier framework se traduce al instante. Lo que sea que llame “agente” en realidad es solo el mismo bucle subyacente. Lo que denomine “memoria” no es más que la lista en tiempo real de mensajes que ya conoces. Lo que etiquete como “herramientas” se corresponde directamente con los bloques tool_use que has manejado manualmente. Y lo que promociona como “middleware” es simplemente otro nombre para los ganchos que tú mismo construiste.
Esa es la posición en la que vale la pena estar. No “Conozco LangChain”, sino “Entiendo cómo funcionan los agentes, y LangChain es solo una forma de expresarlo”.
Los frameworks seguirán evolucionando. Cada pocos meses aparecen nuevos. El bucle subyacente permanece constante. Construye tu conocimiento sobre la parte que no cambia.
Lecturas relacionadas
- Chatbot vs AI Agent: ¿Qué realmente los separa más allá del LLM? — Aprenda por qué la verdadera diferencia entre los chatbots y los agentes de IA radica en la arquitectura del sistema que los rodea: herramientas, planificación y acciones, y no en el propio LLM.
- Entendiendo los agentes de IA: objetivos, herramientas, memoria y el bucle del agente — Una explicación sencilla para principiantes sobre cómo los agentes de IA difieren de los chatbots, abordando sus componentes clave, el bucle de toma de decisiones, los niveles de autonomía y casos de uso en el mundo real.