I use an AI agent to run parts of our cloud ops every day. I'd also bet money that the exact setup I'm running right now will look embarrassingly primitive by the end of this year, and I don't think that's a hot take. The vendors are telling us so, out loud, in their own roadmaps. You just have to read the release notes as a trend line instead of a changelog.
Here's the case, using what the platforms shipped this year as the evidence.
What "primitive" looks like from six months out
Every generation of tooling feels state-of-the-art until the next one lands and retroactively makes it look quaint. Remember when copy-pasting a stack trace into a chat window felt like the future? That was eighteen months ago. The current top of the stack, an agent with cloud credentials, a handful of MCP tools, and a system prompt full of guardrails, is going to age exactly the same way, and the roadmap tells you along which axes.
Axis 1: Memory goes from bolt-on to native. This year AWS Bedrock AgentCore, Azure Foundry Agent Service, and Vertex all shipped managed long-term memory. Today most people's ops agents are effectively amnesiac, every session starts cold, re-discovers the same infrastructure, re-learns the same "don't touch that instance." The roadmap direction is unambiguous: agents that remember last week's incident, your environment's quirks, and which alerts are always false positives. The moment that's real, a stateless agent looks like a junior who takes no notes.
Axis 2: Tool use gets standardized and deep. MCP went from an interesting Anthropic protocol to something Google is rolling across Vertex and every serious platform is adopting. Today's agent calls five or six hand-wired tools. The trajectory is hundreds of standardized ones, with the agent composing them. My current "here are your six functions" setup will read like hand-cranking a Model T next to that.
Axis 3: The context window stops being the constraint. Claude Opus 5 landed on Bedrock with a 1M-token context. A million tokens means an agent can hold your entire infrastructure state, a month of logs, and the full runbook in-context at once. Every ugly workaround I've built to summarize-and-truncate state before feeding it to the model, that whole category of plumbing, becomes dead code the day context stops being scarce.
Axis 4: Governance moves into the platform. AWS shipped agent observability and policy enforcement as first-class Bedrock features this year. Right now my guardrails are artisanal, bespoke blast-radius caps, hand-rolled approval gates, a homegrown state-verification loop. The roadmap says that governance becomes a platform primitive you configure, not code. When it does, my hand-built safety harness looks like the pile of shell scripts it basically is.
Why the roadmap is unusually trustworthy here
Roadmaps lie constantly, half of "coming soon" never ships. So why believe this one? Because these four axes aren't speculative features on a slide; they're already shipping, just unevenly distributed. Memory exists. MCP exists. Million-token context exists. Platform governance exists. None of it is science fiction, it's just not yet in your agent, today, all at once. The bet isn't "will this get invented," it's "how fast does it become the default," and defaults move fast once every major cloud is pushing the same direction simultaneously. When AWS, Azure, and Google independently converge on memory + MCP + governance in the same twelve months, that's not a roadmap promise, it's a current.
The trap: don't over-build for today
Here's the practical consequence, and it's the reason I'm writing this instead of just nodding at the news. If you know the platform is about to absorb memory, standardized tools, huge context, and governance, then the worst thing you can do right now is build a deep, bespoke version of any of those yourself. Every hour spent hand-crafting an agent memory store or a custom tool-routing layer is an hour building something the platform is about to give you for free, and your version will be worse and unmaintained.
What survives the transition is not the plumbing. It's the policy: what the agent is allowed to do, how big a blast radius you tolerate, what requires a human, how you verify state independently of the actor. Those are decisions, not features, and they stay valuable no matter how good the underlying agent gets. It's exactly why, building scheduling and remediation into ZopNight, we treated "what's the safe action and what's its undo" as the durable core and treated the model underneath as swappable, because the model is going to be swapped, repeatedly, and soon.
So what do you actually do
Not "wait for the future", that's how you end up two years behind. You run today's primitive agent now, because the operational muscle (what to delegate, where your lines are, how to review a plan) is the thing that compounds. But you build it thin: lean on platform primitives the moment they ship, keep your own code to the policy layer, and assume every piece of scaffolding you write has a six-month shelf life.
The agent I'm running today is genuinely useful and genuinely primitive, both at once. By fall it'll be embarrassing, and the release notes already told me which parts. I'd rather be embarrassed by how far it came than still hand-wiring six tools into an amnesiac.
Which of these four axes do you think lands first for real, memory, standardized tools, context, or governance? I keep going back and forth on the order, and I suspect whichever one your team feels first depends entirely on which cloud you're deepest in.
Top comments (0)