Every vendor promised agents that 'just work.' Reality delivered toy agents - fragile in production, useless when correctness matters. AI doesn't remove complexity. It relocates it.
Today is 2 February 2026, and I’m looking back at a year that was supposed to be “the year of agents.”
It wasn’t.
It was the year of agent demos.
Everywhere you looked, vendors had the same storyline:
“Just use natural language. Our agent will write the query, fetch the data, do the work. No more technical barriers.”
The screenshots were polished. The marketing decks were confident.
And in real-world environments? Most of these “agents” collapsed immediately under the weight of reality:
Ambiguous questions.
Messy schemas and half-documented systems.
Shifting business definitions.
Permissions, compliance, and auditability.
Cost and latency constraints.
The boring but non-negotiable requirement of being correct.
What shipped in 2025, in the vast majority of cases, were toy agents: safe enough for a demo, fragile in production, unusable when the cost of being wrong is non-trivial.
Who am I to say this?
I’m not a marketing lead trying to hit an “AI” slide quota. I’m the person who:
Last year, I didn’t “play” with AI. I worked with it.
Not in one-off chats or weekend experiments, but in long, messy, multi-day sessions, wired into terminals, codebases, CI, pre-commit hooks, and MLOps pipelines. I spent last year battling models, forcing them to be useful, and building the scaffolding to make their output safe enough to connect to reality.
And here is the core observation from that experience:
AI doesn’t remove complexity.
It relocates it.
The hard part isn’t prompting.
The hard part is governance.
The current narrative is:
“AI will make everything less technical. Anyone can just tell the system what they want in plain language. The agent will figure it out.”
That sounds empowering. It’s also dangerously incomplete.
To let “anyone” safely control complex systems via natural language, you need someone who:
Deeply understands the system and its failure modes.
Anticipates the anti-patterns the model will generate.
Enforces hard constraints around what the agent can and cannot do.
Designs verification layers that don’t trust the model just because the answer sounds confident.
That someone is not a casual user.
That someone is not a slide in a pitch deck.
That someone is a domain expert who is actively governing the AI.
Which leads to a very unpopular truth:
AI does not make things “less technical.” It makes them differently technical.
The work moves from “write all the code yourself” to “design, constrain, and continuously audit a non-deterministic collaborator.”
When I say I “govern” AI, this is what that actually looks like in practice:
Heavy, layered instructions I don’t rely on a single prompt or a pretty “system message.” I use building blocks that define what the model is allowed to do, what it must never do, and how it should behave in specific contexts. These are not inspirational guidelines. They are constraints.
Pre-commit hooks and guardrails I don’t just let an agent commit code. I wire it into a pipeline where its changes are checked, formatted, statically analysed, and tested before they get anywhere near main. The AI doesn’t get to “be helpful” without being inspected.
Pattern-spotting and anti-pattern hunting Over time, you learn what your models consistently get wrong: subtle security issues, performance foot-guns, concurrency problems, data leakage, brittle abstractions. You start reading AI-generated output with a mental checklist of “usual crimes” and scanning for them constantly.
Tight tool boundaries Agents don’t get a wide-open toolbox. They get very specific tools with well-defined contracts. They don’t get to freely roam your systems. Everything is explicit, limited, and supervised.
Verification first, trust never The model’s job is to propose; my job is to verify. I never confuse fluency with correctness. The more confident the output looks, the more suspicious I am.
That is what “harnessing” AI actually looked like in 2025.
Not “ask once, trust always,” but “ask repeatedly, constrain aggressively, verify relentlessly.”
The marketing story is: “AI makes things easier.”
My experience: it makes things faster, not easier.
Before agents, work was slower but more linear. When you write everything yourself:
With AI, the work changes:
You constantly read and review large volumes of generated content.
You look for invisible edge cases that are not obvious at a glance.
You reverse-engineer the model’s choices and ask, “Why this? What did it miss?”
You run more tests, more often, because you don’t trust the generator.
The result: your throughput goes up, but so does your cognitive load.
Ironically, it was less mentally taxing before agents existed.
You had fewer surprises, fewer hidden landmines, and more direct control.
Today, if you want to stay ahead, you don’t really have the option of ignoring AI. But using it seriously means accepting that:
So when I see yet another announcement about:
“Now you can query your database in natural language. Our agent will just handle it.”
I don’t see innovation. I see a risk disguised as a convenience.
Because in the real world:
Data has access boundaries and regulatory constraints.
Business logic lives in weird legacy corners nobody wrote down.
“Revenue” means one thing in Finance, another in Sales, and a third in Analytics.
A wrong answer isn’t just “oops,” it’s a bad decision, a broken audit trail, or a compliance incident.
If there is no visible story about governance, constraints, observability, and evaluators, then it’s not a production agent. It’s a demo.
We don’t need more toy agents in 2026.
We need agents that are:
Bounded.
Testable.
Auditable.
Operated by people who deeply understand the systems they’re touching.
Despite all of this, I’m not pessimistic about AI.
Quite the opposite.
Last year showed me that:
The gap between those two outcomes is not the model. It’s the operator.
2025 was not the year where agents replaced experts. It was the year where we started to understand that the only people who can reliably use agents are the ones who were already experts - and who are willing to stay fully engaged while the model does the typing.
If there’s a mindset I’ve taken into 2026, it’s this:
Treat AI as a powerful but unpredictable collaborator. Don’t worship it. Don’t fear it. Govern it.
That’s not as shiny as “everyone can be a developer now.”
But it’s honest. And in real-world systems, honest beats hype every single time.
© Tobias Klein 2026 · All rights reserved
LinkedIn: https://www.linkedin.com/in/deep-learning-mastery/