Stop Studying Agents. Build One Small One First.

Months of frameworks, a 128GB machine bought just for studying agents — and still no idea how to actually build one. That is not a failure of effort. It is the order of operations, backwards.

The builders in this discussion keep landing on the same embarrassingly simple fix: stop collecting frameworks and build one small agent end to end, by hand, with the bare minimum stack. No LangChain, no CrewAI. Just a model and a loop.

The framework trap is a confidence trap

Every new framework promises to be the missing piece, and every new one quietly resets what you thought you knew. Collecting LangChain, LangGraph, CrewAI, RAG, and memory systems feels like progress while you are doing it — and like erosion afterwards. You end up with scattered pieces and a powerful machine with no clear job, because you studied the abstractions before the thing they abstract.

That is the vendor-adjacent version of the same story: frameworks are sold as the starting point, when they are really chapter two.

The loop teaches what the framework only names

Write the loop yourself and the jargon stops being jargon:

• State is no longer a chapter heading — it is the variable you pass around and watch grow.
• Retries are not a feature flag — they are the moment your agent gets stuck and you decide what it should do instead.
• Errors stop being abstract, because you are the one who sees them arrive and chooses how to handle them.

LangGraph's stateful graphs — nodes, edges, a shared state object acting as memory — are a precise, useful formalism. But they land completely differently after you have built the loop they formalize. Before that, one more abstraction to memorize. After that, a name for something you already understand, plus machinery for the cases your hand-written version cannot handle.

Your local machine does not need a framework to earn its keep

Here is the practical payoff: the loop-first path needs almost nothing to start. Local runners expose OpenAI-compatible endpoints, so a hand-written loop can talk to a local model by changing only the base address. Ollama and llama.cpp serve models the same way. The learner's 128GB machine did not lack capability — it lacked a job. Give it a loop, a model, and a task, and it is suddenly useful.

The honest objection — and why it proves the point

Hand-rolled loops are not the destination. Real agents need state management, retries, memory, and evaluation, and rebuilding all of that by hand is redoing solved problems. The builders concede this themselves.

But that concession is the point. The question was never whether frameworks are useful. It is when they become useful — and the answer is: after you have felt why you need state and retries. You earn them, one felt need at a time.

A first project, concretely

Pick one small agent you actually want. Not a platform, not a multi-agent system, not a demo. A single loop: a model, two or three tools (read a file, search, write a note), a hard cap on steps. A research assistant that reads your notes, searches, and writes a summary is a good shape — it forces every part of the loop to earn its place.

Then add one thing at a time. Memory, or a small set of test tasks to measure against. Keep only the additions that measurably help. When state starts to hurt, you will know what LangGraph is for. When retries start to matter, you will know why the frameworks exist.

Go deeper

The full article walks through the learner's predicament, the builders' recipe, and what should follow the first loop: Stop Studying Agents. Build One Small One First.

Originally published on Agentic Affairs (https://agentic-affairs.com)