Audience: Senior Engineers
Format: Opinion + Architecture Patterns
Context: Lean teams in LATAM
TL;DR
- Many agent systems are over-engineered
- More abstraction ≠ more value
- A simple architecture based on pipes + well-defined tools is usually superior
The problem: too much magic
Over the last 12 months, “AI agents” went from being an interesting idea to becoming complex stacks:
- Orchestrators
- Planners
- Vector memory
- Tool routers
- Recursive loops
All of this… even to solve relatively simple problems.
Clear signs of over-engineering
If your system has this, you’re probably over-building:
- More than 3 layers of abstraction to execute a task
- Difficult or non-deterministic debugging
- Excessive dependence on “autonomous loops”
- Prompts that are hard to version or test
The alternative: simple architecture
Instead of complex agents, consider this pattern:
1. Structured input
{
"task": "generate_summary",
"input": "long text"
}
2. Explicit router
if (task === "generate_summary") {
return summarize(input);
}
3. Deterministic tools
Each function does one thing well:
async function summarize(text: string) {
return llm.call({
prompt: `Summarize this: ${text}`
});
}
4. No unnecessary loops
Avoid patterns like:
- “agent decides what to do next”
- recursive executions without control
Instead:
- linear flows
- explicit steps
Direct comparison
| Approach | Complexity | Debugging | Control | Cost |
|---|---|---|---|---|
| Complex agent | High | Difficult | Low | High |
| Simple architecture | Low | Easy | High | Low |
When SHOULD you use agents?
There are cases where agents make sense:
- Open-ended tasks (research, exploration)
- Non-deterministic workflows
- Multi-step systems with high variability
But even then:
Start simple, add complexity only if necessary
Perspective from lean teams
This is relevant for any team looking to move fast without sacrificing quality.
Reality:
- Teams that prioritize focus and clarity
- Need to iterate quickly
- Search for maintainable systems
Implication:
- Each unnecessary layer adds friction
- Simplicity improves speed, debugging, and scalability
Recommended pattern
Instead of “agent frameworks”, use:
- Explicit functions
- Lightweight orchestration
- Clear logs
- Well-defined inputs/outputs
Think of:
“LLM as a function”
not:
“LLM as an autonomous system”
Risks of over-simplifying
- Lose flexibility in complex cases
- Rewrite logic if the system grows
But in most cases:
It’s the right trade-off
Verdict
Agents aren’t the problem.
The problem is using them when you don’t need them.
Final reflection
The best AI architecture today isn’t the most sophisticated.
It’s the one your team can:
- understand
- maintain
- scale
Without friction.