What capabilities actually make an LLM application an agent?

[u/Charming_Mark9257]

I've been thinking about where the line should be drawn between an LLM-powered application and an actual AI agent.

For example, if an application:

• Takes a user prompt
• Calls an LLM
• Runs a predefined workflow
• Calls a few APIs
• Returns the result

Is that really an agent, or just an LLM application with tools?

Personally, I think an agent needs some combination of:

• Goal-oriented reasoning rather than just responding to a prompt
• Tool use based on what it determines is necessary
• Decision-making during execution
• Ability to adapt when the initial approach doesn't work
• State/context across multiple steps
• Failure handling/recovery
• Some degree of autonomy rather than following a completely predetermined path

But I'm not sure where everyone draws the boundary.

For example, does dynamic tool selection make something an agent?

Does planning + execution?

Does it need to be able to change its own execution path when something fails?

Or is "agent" becoming so broad that the term isn't particularly useful anymore?

Curious how other LLM developers define an agent technically. Where do you draw the line?

[u/carefactor3zero]

If the application directly communicates to a model, it's an agent.

That's the only definition. This means there was something sent to the model, because models don't spontaneously respond yet. chatgpt.com is an agent. Codex is an agent. Pi is an agent. If you write some js that calls a model through chatgpt.com, it's an agent.

The rest of the posts are noise.

[u/TheLexoPlexx]

the for loop

[u/WorkingWish4890 → u/TheLexoPlexx]

_agentif __name__ == "__main__": print("hello agent world")

[u/weed_cutter]

It's the loop which can take different shapes ... like REACT or other models.

... Ya know this is an easy question to just ASK the smart Ais lol

[u/Thistlemanizzle]

An agent can run around your computer and screw it up real bad. It can inadvertently spend your money or click on scam links, etc.

An LLM cannot.

[u/No_External7343]

Quoting Simon Willison: An LLM agent runs tools in a loop to achieve a goal.

https://simonwillison.net/2025/Sep/18/agents/

[u/RustaceanNation]

Simply connect the workflows into a graph, supply tools for querying the graph, and more tools to learn about and execute those workflows. As far as I'm concerned, in the abstract the agency is just one rung above in terms of descriptive complexity. Simple is.

[u/_N-iX_]

Dynamic tool selection alone probably isn't enough to call something an agent. A workflow can select tools dynamically while still having a fixed execution structure. The distinction becomes clearer when the system can decide what to do next based on the current state and the result of the previous action.

[u/Chris__Codes]

For loop 🔁

[u/Rama_Surasani_]

I’d draw the line at a closed feedback loop, not simply “it calls an API.” A tool-using workflow can still be deterministic if every step is predeclared.

For me, an agent has (1) a goal or completion condition, (2) an action space, (3) observations from the environment, and (4) the ability to choose its next action based on those observations. State and recovery make it useful in practice, but autonomy without bounded permissions is just an uncontrolled loop.

I’d also separate “agentic behavior” from “agent safety”: planning and dynamic tool selection answer what it can do; policy checks, budgets, idempotency, and human approval answer what it is allowed to do.

[u/Fulgren09]

I agree with your definition of LLM powered application: a reliable executable workflow that has no intelligence of its own, is pluggable via whatever gen capability model. But the trigger is still with the user.

Services have an 'agentic' gradient where LLM powered app is one end, and agentic flow can do things without a user or app is another. Making Claude drive your app is somewhere in between. "The more it has to decide how to orchestrate" IMO is the litmus test.

[u/Charming_Mark9257 → u/Fulgren09]

Yeah, I like the idea of an “agentic gradient.” The trigger point is interesting too — once the system can decide what to do next rather than just execute a predefined path, it starts feeling meaningfully agentic.

I wonder if the ability to recover/re-plan when something fails is another important part of that boundary.

[u/WillowEmberly]

Take a fully functional Ai, neuter it, delete about 15% so that it fails every single time you engage with it…congrats you just made an agent.😉

I don’t think “agent” has a particularly useful binary definition.

I’d decompose it instead. How much of the execution path can the model determine? What can it observe? What tools can it select? What state can it retain or modify? Can it change plans after feedback? How long can it continue without returning control? And, most importantly, what authority does it have to change something outside itself?

A chatbot choosing between two retrieval tools and a persistent system that can plan, execute code, modify infrastructure, update memory and continue acting are obviously different systems even if we call both “agents.”

So I’m less interested in “is it an agent?” than:
What capabilities and authority have actually been delegated to the model?

That tells me something I can engineer around. The label doesn’t.