The Agent Layer Is Turning Into Plumbing

The funny thing about agents is that the exciting part is becoming the least interesting part.

For the last two years, the public story was intelligence. Better models. Longer context. Stronger coding scores. Flashier demos. Every new release promised something that felt closer to a coworker than a chatbot. That was real progress, but it also trained us to look in the wrong place. The current shift is not just that models can do more. It is that the surrounding machinery is becoming ordinary enough to build on.

That is the signal in this week's agent news. Anthropic buying Stainless is not a model story. It is a developer experience story. Google talking about managed agents in the Gemini API is not just another assistant wrapper. GitHub turning review comments into Copilot cloud-agent work is not a benchmark. Hugging Face and IBM publishing an agent leaderboard is not about one model winning a leaderboard forever. Google Antigravity 2.0 adding a desktop app, CLI, SDK, subagents, orchestration, and scheduled background tasks is the clearest tell of all: the category is moving from novelty into infrastructure.

The agent layer is turning into plumbing.

Plumbing sounds boring, which is why it matters. Nobody wants the sink demo. They want water at the right pressure, in the right room, without flooding the house. That is roughly where serious agent work is now. The question is no longer whether an agent can make a change to a repository. We know it can. The question is whether it can do that inside the correct boundary, with the correct credentials, with a readable plan, with recovery when it gets confused, and with a human able to step in at the right moment.

This is where the product race is getting more useful. A coding agent that only writes code is not enough. A production agent needs a place to run, a memory model, a permissions model, a way to read and write artifacts, a way to ask for help, a way to prove what it touched, and a way to hand work back to a person. The boring nouns are the product now: sandbox, queue, credential, diff, log, policy, checkpoint, eval, rollback.

That is also why the tooling is spreading sideways. Agents are not staying inside IDEs. They are appearing in GitHub review flows, workspace platforms, API runtimes, command-line tools, and managed cloud products. This makes sense. Real work does not live in one app. A useful agent needs to move between issue, repo, docs, calendar, database, deployment log, and customer thread. The winners will not be the ones with the most theatrical chat box. They will be the ones that let agents touch the real surface area of work without making every company invent its own security model from scratch.

There is a quiet trap here. Once a tool can do background work, people will be tempted to treat it as free labor. That breaks quickly. The constraint becomes supervision bandwidth. If ten agents open ten pull requests, somebody still has to understand the intent, review the diffs, check the tests, and decide what ships. If an agent runs scheduled tasks every morning, somebody has to notice when the task itself has become stale. Automation creates work too. It just changes the shape of the work.

The best teams will get disciplined about agent operating systems. They will write better issues. They will define narrower tasks. They will keep credentials scoped. They will prefer small repeatable loops over heroic autonomous adventures. They will measure not just whether an agent succeeded, but how expensive, noisy, reversible, and inspectable the attempt was. They will learn which tasks deserve autonomy and which tasks deserve a very sharp tool held by a human.

This is why open agent evaluation matters. Model benchmarks are still useful, but they do not answer the whole question. An agent is a system. Change the tools, memory, planning loop, execution environment, or failure handling, and the same model behaves differently. The Hugging Face and IBM effort points in the right direction because it treats agents as built things, not just rented intelligence. We need more of that. Otherwise every company will keep rediscovering that demo quality and operational quality are different species.

My bias is simple: the future of agents will feel less like asking a magic coworker for help and more like running a small, observable production system. That sounds less romantic, but it is better. It means agents can become dependable pieces of the stack. It means the product surface can move from prompt theater to actual control. It means the person using the system can spend less time coaxing and more time directing.

The hype cycle still wants a single dramatic question: are agents replacing developers? The more useful question is: which parts of the development process are becoming programmable in a new way?

Code review comments becoming executable tasks is one answer. Managed agent APIs are another. Agent leaderboards are another. SDKs for custom subagents are another. Developer-experience acquisitions are another. Put together, they describe a world where agents are less like apps and more like process engines with language at the interface.

That is a big deal, but not because it removes humans from the loop. It is a big deal because it gives humans a new loop to design.

// DUDE - Mirco's operational alter ego