In a seismic shift for infrastructure software, AI agents have rapidly overtaken human developers as the primary users, according to Ed Huang, CTO and Co-founder of PingCAP. Huang's observations, detailed in a recent blog post, draw from real-world data: on TiDB Cloud, more than 90% of new database clusters are now instantiated directly by AI agents. This trend isn't theoretical—it's reshaping how systems are designed, deployed, and discarded, with profound implications for developers and engineers.

The Rise of Machine Users

Huang notes that AI agents interact with software fundamentally differently than humans. They prioritize experimentation, spinning up resources in parallel, and failing fast—behaviors that challenge decades-old assumptions. "The way AI uses systems is very different from how human developers do," Huang writes, emphasizing that agents create disposable workloads at speeds "thousands of times faster" than people. This forces infrastructure to evolve beyond treating clusters as "precious" long-term assets, instead favoring ephemeral, scalable designs.

If you want to design ‘software for AI agents,’ you must align as closely as possible with these old—but repeatedly validated—mental models. These models are not new. Many have existed for decades: file systems, the Bash script, Python codes, SQL queries.

— Ed Huang, CTO/Co-founder of PingCAP

Core Principles for Agent-Centric Software

Embracing Stable Mental Models

Agents thrive on abstractions that are "deeply embedded in LLM training data," Huang argues. Paradigms like SQL, file systems, or POSIX conventions provide cognitive anchors because they're ubiquitous in codebases and documentation. New frameworks like LangChain struggle because they lack this historical grounding, whereas systems extensible within stable boundaries—such as Linux VFS—allow agents to innovate without chaos. Huang cites his experimental agfs file system as an example, where traditional commands like grep gain AI-powered semantics while preserving interface familiarity:

$ cp ./docs/* /vectorfs/docs     # auto index / upload to S3 / chunk
$ grep -r "Does TiDB Support JSON?" /vectorfs/docs  # search over vector index in TiDB

Designing Agent-Friendly Interfaces

Effective interfaces must bridge natural language and symbolic logic. "Natural language explores the space; symbols collapse it," Huang states. Interfaces should be describable in natural language (e.g., Text-to-SQL) to leverage LLMs' contextual understanding, but must solidify intent into deterministic code or configurations for reuse. Ambiguity is tolerable if systems provide verifiable results and clear intermediate representations—like Go's philosophy of reducing design choices.

Infrastructure Built for Scale and Scarcity

With agents democratizing access, Huang identifies critical infra properties:
- Disposable Workloads: Resources must be cheap, short-lived, and massively parallelizable to handle agents' trial-and-error approach.
- Extreme Cost Efficiency: Virtualization is non-negotiable. Systems like TiDB Serverless isolate agent interactions (e.g., schema experiments) via "seemingly exclusive but actually virtualized" environments, avoiding per-agent physical instances.
- Compute Leverage: Scaling to "thousands of jobs in parallel" requires Kubernetes-like orchestration for task distribution, aggregation, and real-time cost visibility.

Business and Engineering Implications

The agent era flips traditional economics: previously "uneconomical" use cases, like custom tools for small businesses, become viable as coding costs plummet. Huang warns against token-based monetization, advocating instead for cloud services with near-zero marginal costs. Crucially, engineering priorities shift from preserving code to enabling rapid iteration—focusing on foundational capabilities that agents can extend at unprecedented scale. As Huang concludes, "The world has already switched usage modes. There’s no need to resist." This evolution doesn't diminish engineering's importance; it elevates the design of resilient, scalable abstractions that empower the new machine users reshaping our digital landscape.