Keep It Simple, Seriously

Let’s talk about KISS.

No, I’m not talking about the Kiss Cam everyone’s been posting about since the Coldplay concert last week. I’m talking about Keep It Simple, Seriously. (I never liked the original last word.)

Lately, I’ve found myself saying things like: “don’t boil the ocean”, “do we really need to do this?”, “is there actual value in it?”

In our rush to stick “AI” on everything (bonus points if you add the prefix “agent”), we might be making things unnecessarily complex. Solutions that used to take a handful of if/then statements are now being rewritten as autonomous agents that plan, strategize, and act. Cool? Sure. Necessary? Not always.

I get it. We’re experimenting, learning, and pushing boundaries to see what else we can do with the technology available to us. But we’re often skipping a key part of the definition of technology:

“The application of scientific knowledge for practical purpose.”

We sometimes miss the practical aspect of it.

If your problem is a chatbot that answers basic FAQs within a narrow domain, do you really need an autonomous agent with memory, planning, and recursive tools? Or would a rule-based flow (fast, cheap, and predictable) be a better fit?

This isn’t anti-agent. It’s pro-fit.

There’s a concept in systems thinking called task-technology fit: using the right level of technology for the problem at hand. Sometimes a simple script is enough. Other times, you might need an agent that understands nuance, adapts to changing inputs, and takes initiative. But every jump in autonomy introduces trade-offs in control, predictability, and safety that we shouldn’t ignore.

Complexity feels smart. Simplicity is smart.

The real evolution in tech isn’t about outsourcing everything to AI. It’s about building systems that enhance human judgment, operate within constraints, and stay aligned with our goals and values. This starts with knowing when not to over-engineer.

To those building agents: The more control you hand over to the machine, the more responsibility you have to understand the trade-offs. Sophisticated systems demand a solid grasp of simpler ones first.

And for most real-world use cases: The simpler, the better. Seriously.