AI agents are everywhere.
On LinkedIn, at conferences, in the media: “Build your army of agents”, “Automate 100% of your business”, “Generate several million euros with 0 employees”.
It's appealing. But on the ground, inside companies, it's far more nuanced. And even… far more disappointing. We're a long way from reality.
After building hundreds of workflows and supporting over 50 companies with Tandem, I wanted to share what I've learned about the different levels of optimization before you get to AI agents. Concrete examples to help you picture the right solution to choose based on your need.
So I'll go back over the 4 possible levels of optimization with AI, pros and cons to help you choose the right solution, once the problem is clearly defined.
Across these levels, there's a logical progression:
1️⃣ AI assistant (copilot)
2️⃣ Simple automation
3️⃣ Workflow with AI
4️⃣ Autonomous AI agent
Spoiler: in many cases, you stop at level 2 or 3. With a huge ROI. And far less friction.
The real problem: we skip the steps
When we talk about AI agents, we often lump everything together: assistants, automations, AI workflows, autonomous agents.
The reality? An AI agent is:
- complex to build
- risky to deploy
- expensive to maintain
- and far less deterministic (often exactly what you want when you automate something)
Companies want control, predictability and measurability first and foremost.
Not a probabilistic system that “should” make the right decision 95% of the time.
What we observe with Tandem, is that there's the myth of the agent. Even before the problem has been clarified, people already think about an agent.
“There are repetitive tasks → I want an agent.”
But is the task really frequent? (a task that takes 10 min a week isn't really worth a complex system like an agent) ? structured enough to identify all the steps needed to carry it out ? does it deserve an autonomous system ? or would a simple assistant be enough ?
We confuse technological opportunity with real need.
Level 1️⃣ : AI assistant (copilot)
What I call an AI assistant is a preconfigured conversational model that you trigger when you need it.
It does nothing on its own. It isn't autonomous. It doesn't plan.
You're the one who calls it. You're the one who stays in control.
It follows a very “copilot” logic. In practice, it can be:
- a custom GPT on ChatGPT
- an Assistant via the OpenAI API
- Microsoft Copilot
- an assistant on Claude
- an internal bot connected to Slack or Teams
The idea is simple: you configure precise instructions (role, tone, output format), possibly a knowledge base, and you use it in conversational mode.
Here's an example of configuring a GPT:
You then find them in a sidebar, to call on them occasionally when you need them:
No complex automation. No multi-step orchestration. Just an immediate productivity lever.
To recap the pros and cons:
Why is it often underestimated?
it seems basic, but in reality, it's the layer with the best time-to-value.
In 30 minutes, you create a dedicated assistant, with context on the task, and an immediate time saving, easy to share internally.
When is it a good fit?
An AI copilot assistant is especially suited when:
- the task is fuzzy or creative
- you need to iterate
- the output must be validated by a human
- the frequency is irregular
- the risk of error is manageable
We stay in a logic of assistance and optimization, not automation.
Level 2️⃣: Simple automation
Simple automation is the well-known principle: if X happens → then Y is triggered.
No intelligence. No complex analysis. No reasoning.
It follows a deterministic, sequential logic. And it can be for:
- A form is filled out → creating a contact in the CRM
- A payment is received → automatically sending an invoice
- An email received with a specific keyword → adding it to a specific folder
- A new row in a Google Sheet → Slack notification
In terms of tools, the most used are Zapier, Make, Power Automate.
You define a trigger, some steps, and an outcome. No surprises: it's always the same path, always the same structure. Only the input variables change.
No AI here, but that's precisely the strength. You know exactly what's going to happen.
You can also handle slightly more advanced tasks, but you quickly slide into overengineering:
To recap the pros and cons:
If the task is clear, with simple rules, adding AI would be almost counterproductive. Here we stay in a logic of automated execution, not intelligence.
Level 3️⃣: Workflow with AI (automation + intelligence)
Here, we keep the structure of simple automation… but we add an AI building block in the middle.
We're not on an autonomous agent yet. We stay within a scenario defined in advance.
The difference from simple automation is being able to process unstructured data.
A concrete example with the smart handling of incoming emails:
An email arrives.
→ The AI analyzes the content.
→ It categorizes it (billing / support / sales / spam).
For that, we constrain the output format to JSON so it can be manipulated:
→ Depending on the category, the workflow triggers the appropriate action. We no longer look for a specific keyword. We analyze the meaning. Here's an example with several branches:
The AI can hallucinate. But if we impose a strict output format with potentially some validation steps, we bring a bit more determinism by making the system more rigid.
And that's the whole subtlety: we use a probabilistic AI within a deterministic framework.
To recap the pros and cons:
It's often the sweet spot because you keep a clear trigger, a controlled path, a framed outcome for a higher value-added task. The AI handles the complex part of understanding, categorization, synthesis, rephrasing…
This level 3 is already enough to transform a process and get an attractive ROI in a company.
We're not yet after full autonomy on 100% of the task (there are always edge cases). We're after framed intelligence. And that's a major difference.
Level 4️⃣: Autonomous AI agent
Here, we completely change logic, from determinism to probabilism:
The agent decides which actions to launch, which tools to use, in what order, how many times to iterate and when to stop
It's a fundamental difference.
In practice, we can take the example of an automated strategic monitoring:
The entire white section follows an iteration logic to reach a satisfactory result. It's the agent that does this iteration, with web search, filters on the relevant sources, deciding whether or not to dig deeper into certain topics, structuring the report.
We don't know exactly how many searches it will run. Nor how many subtasks it will generate.
In terms of tools, n8n is one of the references I talk about a lot here, which uses LangChain under the hood. Make recently released an agent feature.
To recap the pros and cons:
With an agent, you leave a deterministic world. There's a probability that the agent makes the right choice, or not. And that's where many companies get stuck.
Because automating a critical process with 95% reliability… also means 5% errors.
The real question then becomes: what is the cost of an error? What is the gain of a success? Is the ratio positive?
We're no longer just talking about technology. We're talking about business impact.
AI agents are powerful, but they're not a default solution.
It's the final layer, with a mindset shift needed to go after a bigger leverage effect. Many companies aren't ready.
