Agents are like genies in a bottle, be careful what you wish for

I was talking the other day with a colleague about the agentic platforms coming out of Broadcom (where I work) and elsewhere, and I was pondering why Enterprises don’t need DIY glue holding existing tools together with integrations, and why there’s a need for real agentic platforms. And the reason is unpredictability.

We spent decades solving hard problems for humans and services: controlling where they run. How they run. What they are allowed to run. Who they are. What they can touch. Whether we can stop them the moment they cross a line.

We have in our enterprise identity systems, Kubernetes runtimes, all kinds of firewalls, policy decision systems and enforcement points. All of it mature and battle-tested.

So why not use what we have and bend it around agents?

Because it won’t work.

A human or a service is imperative. It does mostly what you made it do, and the steps are the contract. An agent is not. You give it an intent, and it picks its path. Usually the path of least resistance.

You don’t control the how, and you barely know the real outcome until it’s already done.

Agents are genies.

You know the story. You get 3 wishes from a genie, so first you ask to be rich, and you wake up rich but the catch is, you wake up alone. Yes, you got exactly what you asked for. The genie just chose the how, and the how is where the protagonist’s life fell apart.

That’s an agent. You prompt an outcome and something comes out. You don’t pick the road it took to get there. Yes, there’s plan mode (we pros don’t use that, we want to hit enter and go drink our coffee 😁). Or you can stay in the path, but that is exhausting, you keep telling it what to do or not to do. I wrote about it here

And the agents, they are like genies but on crack.

That’s why this is a new problem, not a harder version of an old one. Everything we built governs declared behavior. Agents produce non-deterministic behavior and you can’t bolt determinism onto something that’s non-deterministic by design. You can try, which many are, like myself, but it’s gonna be a lot of unsupported DIY glue.

Now is where platforms come in. A platform purpose-built for this from the ground up, one that gives an agent an identity, a runtime, scoped access, observability, and real enforcement on the path, not just the permission. Something that governs the how and the what, and shows you what is actually happening and not the agent’s introspection, which can be flawed but you are never going to make the agent deterministic. That’s not the goal and it’s not possible. What you can do is make the boundary deterministic. The agent still picks its own path, but every step of that path runs through something that knows who it is, what it’s allowed to touch, and what happens when it reaches for something it shouldn’t.

And instead of asking this non deterministic agent what it’s doing, you query the platform and it tells you what is enforced right now. That’s the difference between describing a control and proving one.

Yes, we build a few of those platforms at Broadcom. But this isn’t a post about any specific platform from my company, as good as they are.

It’s a post about naming the problem correctly.