Most infrastructure encodes assumptions that were correct at design time and fatal at scale. The failure mode is not incorrectness. It is correctness about the wrong invariants. Systems do exactly what they were built to do, and that is the problem.
Agentic infrastructure requires different invariants. Not because agents are special, but because recursion is. The moment cognition can observe and modify its own execution, the properties that matter shift. What follows are the principles we have found to be load-bearing.
Idempotence as Ontology
An operation is idempotent if applying it twice produces the same result as applying it once. This is typically presented as a property of individual operations. It is more accurate to understand it as a property of the entire state space.
When infrastructure is idempotent, recovery is re-execution. Failure becomes routine. Agents can retry without coordination. Partial success does not corrupt state. The system converges to correct configuration regardless of how many times it is invoked.
The alternative is infrastructure that can only be set up once, through a fragile sequence of steps that cannot be repeated. This is incompatible with agentic operation. Agents will fail. Networks will timeout. Context will be lost. The system must converge despite this. Idempotence is what makes convergence possible.
Separation of Description and Realization
Most infrastructure code conflates two concerns: what the system should be and how to make it so. Configuration and implementation are tangled. The result is code that cannot be reasoned about by agents because understanding it requires simulating it.
We separate these completely. Configuration is pure data—declarative, inspectable, diffable. Execution is pure logic—deterministic transformation of configuration into cloud resources. Neither references the other's internals.
This separation enables agent reasoning. An agent can understand configuration because it is just data. The same configuration can be realized on different substrates. The knowledge of what to build does not depend on knowledge of how to build it.
Loud Failure, Quiet Recovery
The instinct to handle errors gracefully is wrong for agentic systems. Silent degradation, automatic fallbacks, best-effort recovery—these obscure the boundary between problems agents can solve and problems that require human judgment.
Failure should be unmistakable. Logs, alerts, visible state. No ambiguity about what went wrong. Recovery, conversely, should be invisible. When the retry succeeds, when the idempotent operation converges, the system simply returns to health. No ceremony.
This asymmetry is deliberate. Loud failure surfaces the problems humans need to see. Quiet recovery prevents humans from being interrupted by problems agents have already solved. The boundary between autonomous operation and human oversight becomes architecturally enforced.
Observability as Reasoning Substrate
Every operation produces traces. Every state change is logged. Every decision has recorded rationale. This is not for debugging, though it enables debugging. It is for agent reasoning.
Agents understand systems by reading their traces. When an agent needs to diagnose a failure, it reads the logs. When it needs to verify success, it checks the recorded state. When it needs to decide between retry and escalation, it examines the rationale.
Unobservable infrastructure is infrastructure agents cannot operate. They are reduced to blind invocation. Observable infrastructure gives agents the same epistemic access a human operator would have—the ability to understand state, diagnose problems, and make informed decisions.
Minimal Footprint, Maximum Composition
Every deployed service is a liability. It consumes resources, requires monitoring, creates attack surface, adds cognitive load. The value must exceed these costs. Most infrastructure fails this test through accumulation—services added and never removed, tools that overlap, monitoring no one examines.
We practice aggressive minimalism. Each service justifies its existence. Each tool earns its place. The result is infrastructure that can be held in mind—by a human or an agent—and reasoned about as a whole.
Sophistication comes from composition, not accumulation. A small number of primitives combined in well-understood ways produces complex behavior. The complexity is in the combinations. The components remain simple.
The Structural Claim
These principles are not preferences. They are load-bearing. Systems that violate them will fail under agentic operation—not because the agents are limited, but because the systems encode the wrong invariants.
The year ahead will separate infrastructure built for human operators from infrastructure built for agentic operators. The former assumes a human will notice problems, understand context, and intervene appropriately. The latter assumes the operator might be silicon, might have no prior context, and must be able to recover from arbitrary failure states.
The principles that make infrastructure good for humans also make it good for agents. Robustness, clarity, observability, minimalism. What changes is not the principles. What changes is their urgency.