Blog · AI Agents
AI Agents: What Are They Really (and What Not)?
Olaf Lemmens, Founder NinA AI Agency · January 26, 2025 · 7 min read

Why everyone is suddenly talking about 'agents'
You can hardly avoid it: everywhere stories pop up about "AI Agents"—systems that supposedly independently perform complex tasks, report and make decisions.
But what is an agent actually? And equally important: when is it smart to deploy an agent, and when not?
Based on new insights from Anthropic and our own experiences at NinA AI Agency, I'd like to explain why "agents" are not a magic word, but can be an interesting tool—provided you use them the right way.
The following is required reading for all new employees at NinA AI and is exactly how we help clients in an open and honest way to get the most out of AI.

What makes an 'agent' different from a regular LLM system?
For clarity: LLM stands for Large Language Model. ChatGPT, CoPilot and Claude are a few examples of language models.
We make a clear distinction between:
- Workflows
- Agents
Two types of agentic systems
- ▸Workflows: LLMs + tools in a strict sequence.
- ▸Agents: LLMs decide themselves which tools to use and when.
Important: "Agent" can take many forms. One organization means a fully autonomous, long-running system (like an "Auto-GPT" concept).
Another organization means a more flexible workflow where the model occasionally makes its own decisions.
When (not) to choose an agent?
I always recommend starting as simply as possible.
You don't always need to build an 'intelligent, self-deciding' AI.
A few rules of thumb:
- Do you have a repetitive task that works fine in 1 or 2 LLM calls? Then a simple workflow or even a single prompt will suffice.
- Is your process predictable and easy to code? Then a workflow with fixed steps is often more reliable and cheaper.
- Do you have complex, open-ended questions with many variables? Then an agent can provide a solution. You let the model decide how often it calls tools, whether it asks for extra user input, etc.
Concrete example
- ▸Customer support: if you have customer questions that can branch widely—sometimes you need to check order history, sometimes issue a refund, sometimes file a ticket—then an agent structure can be useful.
- ▸Coding agents: the AI model splits the required subtasks itself (modifying multiple files), tests the solutions and only comes back when it actually works. Here the flexibility of an agent is worth its weight in gold.
How agents are (often) built
You might think you need all sorts of exotic libraries for this.
But in practice, the most robust systems often come down to simple, repeatable patterns:
Augmented LLM as foundation
- The LLM gets access to tools, retrieval sources (e.g., company documents) and memory. The model thus "knows" how and when it can call tools.

- ▸Iterative loop
- The agent runs in a loop:
- The model plans an action ("Which tool do I need?").
- It executes the action (e.g., generating code).
- It reviews the output and assesses whether to continue.
- For complex tasks: repeat steps 1-3 until the task is done.

- ▸Human checkpoints
- You can choose to have your agent "pause" for review or feedback. Such a checkpoint is very wise when the risk of errors is high, or when costs can escalate.
Watch out for the pitfalls
- ▸Lower speed and higher costs
- ▸More complex debugging
- ▸Compounding errors
- ▸Over-engineering
Examples of agent workflows
- Prompt chaining: divide your task into multiple steps (e.g., first an outline, then review, then elaboration).
- Routing: let the AI first classify ("Is this a refund request, or a regular question?") and then choose the right prompt or tool.
- Parallelization: multiple LLMs work simultaneously on sub-components, or multiple prompts evaluate the same input and then vote.
- Orchestrator-workers: one "orchestrator AI" delegates subtasks to "worker AIs", just like a project manager distributes tasks.
- Evaluator-optimizer: one AI generates text, another AI evaluates and provides feedback. This way you iteratively refine the output.

Agents go a step further, because they decide themselves how many workflows or steps they need.
Three lessons for those who want to work with agents
- Keep it simple Don't start with 15 tools and endless feedback loops. An unnecessarily complex setup leads to bugs faster and is more expensive in tokens.
- Be transparent Let the agent explicitly share its 'thinking process' (even in a hidden debug field), so you know why the model makes certain decisions.
- Invest in good tool documentation Just like a human-computer interface, you also need an 'agent-computer interface' (ACI) for AI. Make it absolutely clear how the AI can call your tool and what the expected input/output is.
What does this mean for your organization?
- ▸Do you often have open-ended tasks? Then agents can offer interesting time savings, provided you can handle the extra complexity.
- ▸Do you mainly have predictable, recurring processes? Then a workflow approach with fixed steps is usually faster, cheaper and more reliable.
- ▸Start small and measurable Build a first proof of concept around one defined problem. Test it thoroughly in a sandbox (not immediately on live customer data). Only expand when you see real added value.
At NinA AI Agency, we help clients with both simple prompt chains and more flexible "agentic systems". But we'll never help you with an agent solution if a simple approach already suffices.
Ultimately, it's about delivering value: as few bells and whistles as possible, and exactly enough intelligence to truly improve your process.
Conclusion
"AI Agents" are not a holy grail that solves every business problem. It's primarily a way to give your LLM extra freedom in deciding which steps are needed. For many use cases, one (or a few) smart LLM calls is sufficient.
But are you really dealing with complex, open-ended processes? Then an agentic system can be incredibly powerful—provided you pay sufficient attention to costs, security and tooling.
Until next time!
Olaf Lemmens
Founder, NinA AI Agency
Want to know more? Visit nina-ai.nl or schedule a meeting.