You Don't Need an AI Agent Framework

An AI agent is just a while loop. So why does every "agent framework" want
2,000 lines of your codebase? Here's when LangGraph earns its keep, and when a
plain loop wins.

You decided to skip LangGraph and write your own simple agent loop. A hundred
lines, tops. Six weeks later you're staring at retry logic, state handling,
sessions, and approval gates you never planned to write. You rebuilt the
framework you swore off, only worse. This video walks the real decision: start
with the loop, build the "accidental framework" just far enough to feel which
wall you hit first, then add the one piece that fixes that wall and nothing
more. The twist most takes miss: the first wall is durability, and the honest
fix is a durable runtime under your loop, not an agent framework bolted on top.

CHAPTERS
00:00 The 100-line trap
00:31 An AI agent is just a loop
01:16 What a framework actually does for you
02:26 Why the question changed (the models got good)
03:40 The accidental framework you keep rebuilding
06:07 The multi-agent swarm trap
07:28 The decision line: loop, library, graph, runtime

WHAT THIS COVERS
- How the core agent loop works: request plus tools, call the model, run the
tool, append the result, repeat until it stops
- The four jobs a framework like LangGraph or CrewAI actually does (boilerplate,
state, orchestration, operations) and why none of it is hidden intelligence
- Why 2023-era frameworks existed, and what native tool calling and longer
context made obsolete
- The four walls every "no framework" team hits: crashes, runaway token spend,
multi-user sessions, and approval gates for destructive tools
- Why durability is a distributed-systems problem, and where a durable runtime
(Temporal, DBOS, Inngest) beats a framework
- When the multi-agent swarm pays off, and the context handoff that makes it
fail most of the time
- A plain decision rubric: loop first, then PydanticAI, then a graph framework,
then a durable runtime, with multi-agent dead last

GET THE HOTTER TAKES
One email every Tuesday, no fluff. Join the newsletter:
https://devsplainers.com/takeouts/

WHAT IS AN AI AGENT?
An AI agent is a language model running in a loop: you hand it a request and a
set of tools, it decides which tool to call, your code runs that tool and feeds
the result back, and the loop repeats until the task is done. Agent frameworks
like LangGraph, LangChain, and CrewAI wrap that loop with state management,
orchestration, and operational glue. The open question for any developer
building agents in 2026 is how much of that you should hand over, and when a
plain loop plus a durable runtime beats the whole stack.

MORE DEVSPLAINERS
AI Coding Costs Explained: https://www.youtube.com/@devsplainers
Claude Code Subagents: https://www.youtube.com/@devsplainers
Watch the full Devsplainers library: https://www.youtube.com/@devsplainers

SOURCES & FURTHER READING
- Anthropic, "Building Effective Agents" (anthropic.com/research) — the warning
that frameworks obscure the underlying prompts and responses
- Anthropic, "How we built our multi-agent research system" (anthropic.com) —
agents are stateful, errors compound, restarts are expensive
- Cognition, "Don't Build Multi-Agents" (cognition.ai) — why context handoffs
break agent swarms
- Anthropic tool use and computer use documentation (docs.anthropic.com) — the
documented agent loop
- Temporal, DBOS, and Inngest — durable execution runtimes (temporal.io,
dbos.dev, inngest.com)
- PydanticAI (ai.pydantic.dev) and LangGraph (langchain-ai.github.io/langgraph)

#aiagents #langgraph #agentframeworks