Vercel just published a number that should make every CTO pause: 30% of their deployments are now initiated by coding agents. Up 1,000% from six months ago. Claude Code alone accounts for 75% of agent-driven deploys.
This isn't a trend line. It's a phase transition.
The implications go far beyond "developers use AI now." The entire infrastructure layer, how code gets tested, deployed, monitored, and rolled back, was designed for human operators making deliberate decisions. When agents are the primary actors, every assumption changes.
What breaks when agents deploy
Traditional CI/CD pipelines assume a human reviewed the PR. That the person who clicked "merge" understood the blast radius. That someone is watching the dashboard after deploy.
Agents don't watch dashboards. They don't have institutional knowledge about which database is near capacity or which feature flag will change the load profile of a downstream service. They produce code that passes every automated check and looks indistinguishable from senior engineer output.
The gap between "CI is green" and "this is safe to ship" has always existed. Agents are making it wider.
The real infrastructure tax
Every company building AI-powered products is paying an infrastructure tax they haven't budgeted for.
Orchestration complexity. A single agent task might fan out into dozens of concurrent operations: API calls, document processing, model inference, tool invocations. Each one needs timeout handling, retry logic, and error recovery. Traditional request-response infrastructure wasn't built for this.
Cost opacity. When agents make decisions about which model to call, how much context to include, and how many retries to attempt, costs become unpredictable. A subtle prompt change can 3x your inference bill overnight.
State management. Agents need to pause, resume, branch, and merge execution paths. They need durable state that survives failures. This is closer to workflow orchestration than web serving, but most teams are still running agents on web server infrastructure.
Observability gaps. Traditional APM tools show you latency and error rates. But when an agent produces a confident, well-formatted answer that's factually wrong, nothing in your monitoring catches it. The failure mode of probabilistic systems is silent incorrectness.
How we think about this
We design agent infrastructure with three principles.
Deterministic shells around probabilistic cores. The orchestration logic, which agent runs, when, with what inputs, under what timeout, is pure code. No LLM in the routing loop. The only probabilistic layer is inside each individual agent's reasoning. This makes costs predictable, workflows testable, and failures debuggable.
Progressive deployment for agent output. Every agent-generated artifact goes through the same gated rollout as human code: canary, percentage ramp, full deploy. If metrics degrade at any stage, automatic rollback. The system doesn't trust the agent more than it trusts a junior developer on their first week.
Cost as a first-class metric. Every agent invocation tracks token usage, model selection, and wall-clock time alongside correctness. We set hard budgets per task type and alert when unit economics drift. Cheap inference isn't cheap if the agent calls it 50 times to handle an edge case.
The companies that win
The next generation of software companies won't differentiate on whether they use AI. Everyone will. They'll differentiate on how efficiently they run it. How quickly they can deploy new agent behaviors without breaking production. How tightly they control costs while scaling throughput.
The infrastructure tax is real and growing. The question is whether you're paying it consciously or discovering it on your monthly cloud bill.
We build AI agent infrastructure that handles the operational complexity so your team can focus on what the agents actually do. If your infrastructure tax is growing faster than your revenue, let's talk.