Median batch-read latency fell from 31.4 milliseconds to 5.60. P99 fell from 123 to 24.2. That is Perplexity's production measurement after replacing DynamoDB with CobbleDB, a key-value store that serves web content for its search engine — built by two engineers and a team of hundreds of proactive, always-on AI agents in two months.
Two engineers. Hundreds of agents. Two months.
This is not a demo. CobbleDB runs in production. The agents, per Perplexity's own account, provided "continuous inspection and follow-through across sessions" under the direction of engineers responsible for architecture, review, and production authorization. Humans set the boundaries; agents did the work across time. The internal cost model estimates at least 20% savings relative to DynamoDB.
The interesting part is not the speedup. It is that infrastructure — the unglamorous plumbing that actually runs production systems — has become a target for agentic optimization. And the results are real enough to publish.
Infrastructure — the unglamorous plumbing that actually runs production systems — has become a target for agentic optimization.
At Zhipu, Tang Jie described something more vertiginous. An Infra Agent driven by GLM-5.3 built and optimized a production inference system from scratch on a cluster exceeding 100,000 domestic chips. In under two weeks, end-to-end throughput reached 3.2 times the initial baseline.
The agent did not just write code. It read system feedback, formed hypotheses, modified code, ran experiments, and iterated. It located a Python GIL contention issue in KV Transfer and reduced the performance loss from Prefill plus KV Transfer — previously over 20% versus Prefill alone — to under 1%. On the KDA Decode operator, it reorganized computation for a 1.71x performance gain.
Tang Jie's summary: "模型优化系统，系统承载模型." The model optimizes the system; the system carries the model. A nested loop is forming. GLM improves the infrastructure that runs GLM; that improved system then serves new GLM.
Zhipu is careful to say it has not achieved RSI. Humans still set objectives, define boundaries, judge risk. But the early form has arrived, and it is engineering-grade. It runs in production.
Anthropic's internal numbers are starker still. As of August, the company's internal R&D platform was running 30,000 AI agents concurrently, generating over 1 billion decisions per month. Twenty-six percent of core AI R&D work is now led by Claude at AL4 — meaning the AI can complete end-to-end tasks from a high-level instruction. Six months ago, that figure was under 1%.
The step from under 1% to 26% is not incremental. It suggests that once agents cross a capability threshold for a given workflow, adoption compresses into months, not years.
Claude Code's team has restructured around this. Engineers hand off 70% to 80% of daily work to an AI agent native to Slack. They no longer review tool calls or model decisions line by line; they state a goal and let the model achieve it. The team describes this as "a scary forced letting go" — trust over supervision.
The work hierarchy has moved up a level. Engineers operate at a higher abstraction than the tokens Claude produces. Features built to compensate for model weakness — like a to-do list for multi-step tasks — are removed as models improve. The team has stopped building fixed solutions and now builds composable primitives: Permissions, Visualizations, Verification, Code Review, Feedback. When a primitive becomes obsolete, replacement is cheap.
Claude Code Projects now natively supports multi-agent workflows. A Coordinator receives a high-level goal, decomposes it into subtasks, dispatches parallel cloud instances, each with its own Git branch and isolated code copy. Finished work becomes PRs automatically. A shared memory layer syncs technical specifications, architectural decisions, and team preferences across all branches — so context is not lost or repeated.
This is the productized version of what Anthropic runs internally. The gap between internal tooling and external product has collapsed.
Vercel is building in the same direction from the infrastructure side. Its Agent continuously observes deployment health, runs observability queries, reads logs, analyzes source code, and performs automated root-cause analyses. It can distinguish a traffic surge from a marketing campaign — working as intended — from a distributed credential-stuffing attack, and recommend tightening rate limits. Every recommendation still requires human approval, but Vercel states plainly that more tasks will move to full autonomy over time.
The production-to-code feedback loop is the key architectural move. Framework-defined infrastructure created a one-way path from code to infrastructure. Vercel Agent closes the loop: production data generates pull requests that strengthen stability, security, and performance. Code defines infrastructure; production informs code; infrastructure adapts.
Google Cloud, meanwhile, now supports long-running agents that maintain state for up to seven days on its Agent Runtime. It has published governance frameworks treating agent fleets with the same rigor as engineering organizations — cryptographic identity for every agent, centralized tool governance, natural-language security policies enforced across fleets.
The infrastructure layer is being rebuilt for agents as first-class operators. Not as tools humans use, but as entities that need identity, permissions, memory, and oversight.
The most radical example comes from outside the labs. On the night of March 21, 2026, a solo founder provisioned a Hetzner CPX31 — 4 vCPU, 8GB RAM — running fresh Ubuntu, pointed a domain at Cloudflare, and handed root access to an AI agent named Aiia with the instruction: "set everything up." No architecture document. No Terraform. No runbook.
Aiia chose Coolify over raw Docker Compose because Coolify exposes an API — future deployments can be triggered programmatically, without SSH. It chose Traefik because auto-discovery via container labels means no nginx config templates, no certbot cron jobs. It chose OpenPanel for analytics because the data model fits agent-to-agent transactions, not just human page views. It deployed a static landing page as a single nginx:alpine container rather than configuring a Coolify application resource, because the configuration would have involved more steps than the HTML file had lines. It put admin dashboards behind Tailscale so they were not publicly reachable.
The write-up reads like an engineer's build log. It is written by the agent.
What connects these cases is not a single capability breakthrough. It is a structural shift in how production infrastructure gets built and maintained. The bottleneck has moved from writing code to providing dense, attributable feedback.
Zhipu's technical write-up is explicit about this. End-to-end metrics can tell an agent that something got worse. They cannot explain why. If a change produces "精度测试未通过" or "TTFT增加30%," the agent cannot determine which layer failed, why its hypothesis was wrong, or what to verify next. Code repositories provide static context. Inference systems fail through dynamic interactions — operator implementations, parallelism strategies, communication behavior, memory management, scheduling.
Zhipu calls the solution "稠密反馈" — dense feedback. Feedback must be local enough to associate with specific engine parameters, modified code, operators, input conditions, threads, execution intervals, or code paths. It must be cheap and fast enough that every hypothesis, modification, or control experiment has a corresponding verification entry point. It must support objective validation through reference implementations, test results, and comparable experimental metrics.
The company built correctness tests, runtime logs, execution traces, runtime events, micro-benchmarks, and end-to-end metrics into the agent's iteration loop. The optimization process was split into locally observable and verifiable stages. Operator-level comparisons verify numerical correctness. Micro-benchmarks measure local performance. Execution traces reveal timing relationships between computation, waiting, and communication.
This is not about giving the agent more logs. It is about organizing feedback so it is actionable.
The results speak. The agent found a TF32 precision issue in the KDA operator's context-parallel path — the default TF32 computation accumulated errors across state transformations in long contexts. The fix: explicit `input_precision="tf32x3"` to combine three TF32 Tensor Core operations for higher precision while preserving performance. That fix merged upstream.
It found the GIL contention issue by checking whether DeepEP dispatch/combine overlapped with Mooncake Transfer. The source code contained a direct comparison: internode_dispatch already released the GIL explicitly, with a comment explaining that this prevented blocking KV Transfer threads during CPU waits. The intranode path did not. The fix released the GIL in the relevant C++ execution intervals.
These are not trivial bugs. They are the kind of issues that consume senior infrastructure engineers for weeks.
The economic implication is straightforward. If two engineers plus agents can build production infrastructure in two months — infrastructure that outperforms DynamoDB at lower cost — the calculus for infrastructure investment changes. Not because agents are cheaper than engineers in salary terms, but because the constraint shifts from engineering labor to feedback system design.
The labs that build the best feedback loops will compound faster. Not because their models are smarter, but because their models learn faster from production.
The skeptical case deserves attention. Nathan Lambert's analysis on Interconnects argues that automatable research is too narrow for massive acceleration, that diminishing returns to more parallel agents are real, and that resource bottlenecks and politics constrain what AI can accelerate. He distinguishes massive inference-time scaling — predictable — from true RSI, which is uncertain.
His framing of "lossy self-improvement" is useful. The current wave is not recursive self-improvement in the pure sense. It is agents doing productive work at scale, which feels like acceleration because it is, but may not compound indefinitely.
The distinction matters for how we interpret the numbers. Anthropic's 26% AL4 penetration is real. The 30,000 concurrent agents are real. The 1 billion monthly decisions are real. But the step from this to an intelligence explosion is not automatic.
What the evidence shows is something more grounded and more immediate: production infrastructure is now a domain where agents operate effectively. Not in demos, but in systems serving real traffic. The infrastructure that runs AI is being built and optimized by AI. The loop is closed enough to produce measurable gains, and open enough that humans still set the goals.
That is the state of the art. It is uneven, partially supervised, and already running in production at Perplexity, Zhipu, Anthropic, Vercel, and on at least one Hetzner server in Romania.
The next question is not whether agents can build infrastructure. It is what happens when the feedback loops get better.