Agents

The word "agent" has become one of those terms that means everything and nothing. Everyone in AI is building agents now. But when you ask what that actually means, you get a surprising range of answers.

Here's the simplest definition I find useful: an agent is an LLM running in a loop. You ask it what to do, it picks an action, you execute the action, observe the result, and repeat. The loop continues until some goal is achieved or the system gives up.

This sounds trivial, but the difference between a single LLM call and an LLM in a loop is larger than it appears. A single call is like asking someone a question. A loop is like giving someone a job. Jobs involve iteration, failure, recovery, and judgment about when you're done.

The interesting questions are all about what makes the loop work well.

Planning is the obvious one. Most tasks require multiple steps, and current LLMs are surprisingly bad at planning. They'll confidently propose a sequence of actions that falls apart three steps in. The usual fix is external scaffolding: break the task into subtasks, reflect after each step, backtrack when things go wrong. This works, but it feels like we're compensating for a missing capability rather than building on a strength.

I suspect planning will eventually be absorbed into the models themselves. But right now, the gap between "can answer questions brilliantly" and "can execute multi-step plans reliably" is one of the more striking limitations of current systems.

Memory is harder than it looks. You want the agent to remember what it's learned, both about the task and about the user. But memory isn't free. More context means slower inference and higher costs. And deciding what to remember is itself a judgment call. Most current approaches feel crude: either stuff everything into context, or use retrieval that often misses what matters.

The most underrated problem is user experience. How much autonomy should an agent have? Too little, and it's just a chatbot with extra steps. Too much, and users lose trust when things go wrong. The best pattern I've seen is letting users rewind and edit. The agent proposes actions, the user can accept, reject, or modify, and the agent learns from the corrections. This keeps humans in the loop without making them do all the work.

There are a few design patterns that seem to actually help.

Reflection means having the model critique its own output before finalizing. This catches obvious errors and improves reliability more than you'd expect. It's a cheap trick, but it works.

Tool use means giving the agent access to external capabilities: web search, code execution, calculators, APIs. This is important because LLMs are good at deciding what to do but often bad at actually doing it. Let them delegate the doing.

Multi-agent setups involve multiple LLMs playing different roles: one generates, another critiques, a third decides. This sounds overcomplicated, but it can help. Different prompts elicit different behaviors, and having a dedicated critic catches things the generator misses.

I should be clear about the state of the field. Agents work for some tasks and fail at others, and we don't have great theories for predicting which is which. Simple, well-defined tasks with clear success criteria tend to work. Open-ended tasks with ambiguous goals tend to fail. Tasks that require lots of real-world interaction are bottlenecked by the slowness and unpredictability of that interaction.

The hype around agents is probably ahead of the reality. But the core idea, LLMs in loops with tools and memory, is sound. The question is how far it scales. Can you get from "useful assistant" to "autonomous worker" just by improving the components? Or is there some qualitative barrier we haven't figured out how to cross?

I don't know the answer. My guess is that we'll see steady progress on well-defined tasks and continued frustration on open-ended ones. The agents that work will be those with tight feedback loops, clear goals, and humans available to correct mistakes. The dream of fully autonomous agents that just go off and do complex jobs unsupervised is probably further away than the marketing suggests.

But further away isn't never. And even limited agents, ones that handle 80% of a task and ask for help on the rest, could be transformative. Most work isn't that creative. Most work is executing known procedures with occasional judgment calls. That's exactly what current agents are starting to handle.

The interesting question isn't whether agents will matter. It's which tasks they'll take over first, and what happens to the people who used to do those tasks.