Agents Write the Code. Our Infrastructure Is Not Ready for Them.
Everyone talks about agentic coding. Very few talk about what happens after the code is written. CI/CD pipelines and infrastructure were built for humans, and they break when agents ship. Here is why, and what it takes to fix it.
Writing code with agents is mostly solved. Teams talk about software factories, agents opening pull requests, and shipping 10 times more code.
The infrastructure did not follow. CI/CD pipelines and infrastructure were built for humans who ship a few times a week. They are full of manual steps and human approvals.
A mistake in code is easy to fix. A mistake in infrastructure is not. You can patch and redeploy code. A deleted database or a broken network can take your business down for days.
Agents need guarantees. A clear job, very narrow permissions, and a test on a copy of production before they touch the real thing.
We are not there yet, and we are working on it. If this was already a pain before AI, it is worse now.
Every week I read another post about agentic coding. Software factories. Agents that take a ticket and open a pull request. Teams that write 10 times more code than a year ago.
I use these tools every day, and they work. For most teams, writing the code is close to a solved problem.
But almost nobody talks about what happens next. The code has to be built, tested, deployed and run somewhere. That part is infrastructure, and it is not ready for agents.
Last week I gave a talk at Alan's Second Opinion event in Paris. I asked the room a simple question: who gives an AI agent full access to production? Almost no hands went up.
Romaric on stage at Second Opinion by Alan in Paris, asking the room who gives an AI agent full access to production
The bottleneck moved
When a developer needed a week to build a feature, a slow pipeline did not matter much. Someone opened a ticket, a DevOps engineer set up an environment, someone approved the release. It was slow, but the code was slower.
That is no longer true. An agent can write the feature in 10 minutes. Then it waits. It waits for an environment. It waits for a review. It waits for someone to merge, to click "approve", to run the migration.
Today, for most companies, the hard part is shipping the code. Your developers and your agents produce more than ever, and the infrastructure becomes the bottleneck. It does not have the right level of automation, and it does not have the guarantees that would let an agent do the work on its own.
Most pipelines I see were designed around a few assumptions:
A human writes every change. So a human reviews every change.
Changes are rare. A few deploys a day, a few infrastructure changes a month.
Some steps are manual on purpose. Creating an environment, running a migration, changing a DNS record, resizing a database. They are manual because they are risky.
Agents break all three. They produce many more changes. They work at night and on weekends. And every manual step becomes a place where the agent stops and waits for a person.
So teams keep a human in the loop. The agent reads logs, finds the problem and suggests a fix. A human approves it. In practice, this does not protect much. Anthropic published that 97% of Claude Code permission prompts get approved. After a few hundred prompts, people stop reading and click yes. You pay with speed, and you don't get the safety.
Code mistakes are cheap. Infrastructure mistakes are not.
Here is why teams trust agents with code and not with infrastructure.
When an agent writes bad code, you see it in a test, in a review, or in production. Then you patch it and redeploy. It can still hurt: code changes data, and a bad migration can corrupt rows. But for data, we have good guardrails. Backups, point-in-time recovery, replicas. With those in place, you can usually recover.
Infrastructure is different. A wrong change there can be destructive, and you cannot always undo it:
A deleted database. This is the biggest fear, and it is a real one. In April 2026, a coding agent at PocketOS found a token with too many permissions and deleted the production database and its backups in one API call. It took 9 seconds.
A broken network. A wrong security group, route or DNS change can cut every service off at once.
Backups that do not restore. Everyone has backups. Few teams test them often. From experience, a backup that was not restored and checked recently often fails on the day you need it.
I like to compare it to a bank account. You would not let a system you cannot predict make payments from your company account. Once a bad transfer is done, it is done. Infrastructure works the same way. If your database is gone, you cannot tell your customers "sorry, my agent did it".
Agents are not deterministic. You cannot know in advance exactly which operations they will run. That is fine for code, where mistakes are cheap. It is a problem for infrastructure, where mistakes are expensive.
Your agents ship code. Can your infrastructure keep up?
Qovery gives each agent a narrow, tested scope on your own cloud: it can run real DevOps jobs, and it cannot step outside them.
From what I see with our customers and in the market, agents in infrastructure mostly do one thing: analysis. They read logs, metrics and config. They explain why a deployment failed or why costs went up. That is useful, and it is safe, because it is read-only.
The moment the agent has to decide and apply a change, a human takes over. The agent is not autonomous. Teams don't trust it enough to let it operate their infrastructure, and they are right: they have no guarantee it will stay inside its limits.
The Grant Thornton 2026 AI Impact Survey says only 5% of organizations let agents make high-risk changes without a human review. That matches what I hear.
What it takes: guarantees
You will never fully trust a system you cannot predict. So I ask a different question: what is the worst this agent can do? If the answer is "very little", you can let it work on its own.
To get there, I see three steps.
1. Define the job
An agent should have one job, written down. "Stop idle dev environments at night." "Right-size the CPU and memory of these three apps." "Patch this CVE and roll it out." A clear job tells you which operations it needs, and which ones it never needs.
2. Give it access to that job and nothing else
Most agents today run with a token built for a human. Human roles are broad. A role that can change a database can usually delete it too.
An agent needs permissions written for its job, checked on every request, whatever tool it uses. If the job is "resize three apps", the agent can resize three apps. It cannot delete them, touch the database or change the network. With permissions this narrow, there are no surprises. Even a bad decision can only do small damage.
3. Test it on a copy before it touches production
Before an agent runs in production, run it on a target environment that looks like production: a clone, with or without data. Check what it did. Check what it tried to do and was refused. Then promote it.
This is how we already treat code, with staging and preview environments. Agents that act on infrastructure need the same thing.
What we are building at Qovery
I won't pretend the problem is solved. Infrastructure is not at the agentic level yet. This is what we work on every day at Qovery.
Here is where we are today:
Scoped permissions for agents.API Policy Tokens carry a policy instead of a role. Qovery checks it on every API request, from the console, the CLI, Terraform or MCP. Anything the policy does not allow is rejected.
One policy per job. We published ready-to-use policies for jobs like stopping idle environments, right-sizing apps, rolling back a bad release or patching a security issue.
A copy of production to test on. Agents can clone an environment, run their job there, check the result and clean up, before anything reaches production.
An audit log for every action. Each call is logged under the token's own name, so you can always tell what an agent did from what a person did.
With that, an agent can manage the performance of your applications or cut your cloud costs, and you know it cannot go further than the job you gave it.
There is a lot left to do. I am convinced agents will run real DevOps work on their own. The teams that get there first will be the ones that built the guarantees early.
If this sounds familiar
Maybe your team writes code faster than ever with agents, and every release still waits on a pipeline, a ticket or a person. Maybe infrastructure was already a pain before AI, and now it is the thing slowing everyone down.
That is normal. Your infrastructure was built for a different pace. It is the problem we work on at Qovery.
Romaric founded Qovery to make Kubernetes accessible to every engineering team. He writes about platform strategy, developer experience, and the future of cloud infrastructure.
Next step
Your agents ship code. Can your infrastructure keep up?
Qovery gives each agent a narrow, tested scope on your own cloud: it can run real DevOps jobs, and it cannot step outside them.