Agent infrastructure
Memory, orchestration, harnesses, registries, runtimes, and protocols are settling into a stack. These essays cover the infrastructure layers agents run on and why each one still needs governance. Browse all insights.
Builderbot Proves the Next AI Engineering Layer Is Coordination, Not Coding
Block’s Builderbot operates across the company’s repos and workflows at scale. It shows the next AI engineering challenge is organizational coordination, and why coordination still needs governance.
Agentic Resource Discovery: Why Agent Discovery Still Needs Governance
Google’s Agentic Resource Discovery lets agents find and verify tools across the web. Discovery and identity are necessary but not sufficient: a trusted capability can still be used in an untrusted way.
What Is Harness Engineering? The Execution Layer Between Models and Production
Harness engineering is the emerging discipline of building the execution layer between a model and production — the runtime that coordinates tool calls, retries, state, and multi-step agent work. Where it sits in the stack, and why governance is the layer above it.
Prompt Engineering Was About Inputs. Harness Engineering Is About Systems.
Prompt engineering optimized a single input. Harness engineering designs the runtime system around the model — tools, state, retries, coordination. But a reliable system is not an architecturally correct one, and that gap is where governance begins.
The Missing Layer in Harness Engineering Is Verification
Harness engineering optimizes for successful execution. Enterprises need verifiable execution — runs proven to stay correct and compliant. The missing layer is verification: pre-registered contracts, explainable provenance, and deterministic enforcement.
Harness Engineering Still Needs Governance
The industry moved from prompt engineering to harness engineering: execution systems that coordinate tools, memory, and retries. Harnesses solve how agents act. They do not enforce architectural intent — and that is the missing layer.
Runtime Harnesses for AI Agents: Why Better Models Are Not Enough
Agent reliability lives in the harness around the model, not the model alone. For software agents, that harness has to enforce architectural invariants, not just wire up tools.
Agent Runtime Governance: The Next AI Infrastructure Layer
What Google Managed Agents signals about the runtime — and the governance layer the marketplace does not yet name.
Microsoft Execution Containers Show Why AI Agent Governance Is Moving to the Runtime
Microsoft Execution Containers bring OS-enforced isolation to AI agents. Runtime containment is a real layer — and exactly why architectural governance becomes the layer above it.
The Next AI Infrastructure Layer Is Coordination Governance
Subagents parallelize execution. They also parallelize inconsistency. Multi-agent systems need shared architectural invariants.
Latent-Space Agent Communication: What Happens When AI Agents Stop Talking in Natural Language?
If agents stop coordinating in natural language, we lose the surface we inspect and audit them through. Governance has to attach to the change agents make, not the conversation.
Long-Running Agents Need More Than Memory
Anthropic’s managed-agent harness solves continuity: progress logs, feature lists, git checkpoints. But continuity is not governance. As agents work across sessions, codebases need enforceable architectural contracts that define what must remain true.
Long Context Does Not Eliminate Governance Infrastructure
The reranker became optional. Retrieval did not. 1M context windows create an observability problem, not a governance solution.
RAG Is Not Memory
RAG retrieves similar text. Memory preserves durable identity. Most products labelled "AI memory" implement the first and are sold as if they implemented the second — and the failure modes are showing up in production.
Rule Files vs Retrieval Memory: Why Static Instructions Stop Scaling
Cursor Rules and CLAUDE.md load your conventions into every prompt. That is the right first answer and the wrong long-term one. Token budget, precedence, and scope are the three ceilings — and retrieval is the way past them.
Why Prompt Memory Fails at Scale
Teams paste architectural rules into CLAUDE.md and call it governance. Context injection has a ceiling: no precedence engine, no enforcement, no persistence across sessions. Here is where it breaks down.
Shared Memory Is Not Shared Intent: Why AI Coding Teams Need Governance
AI coding teams are getting a shared memory layer so every agent reads the same context. That solves distribution, not governance — and better shared memory can amplify architectural drift.
Open Knowledge Format vs Governance: Why Structured Memory Is Not Enough for AI Agents
Google Cloud’s Open Knowledge Format standardizes how AI agents find organizational knowledge. But finding a decision is not following it — discovery is memory, adherence is governance.
Your LLM Wiki Is a Library, Not a Law
LLM wikis, NotebookLM corpora, AGENTS.md files, and Cursor rules help agents read project knowledge. They do not enforce architectural decisions. Documentation is context. Governance is constraint — and the difference shows up at generation time.
Google Cloud Agent Registry Governs Which Agents Run, Not Whether Their Output Stays Aligned
Google Cloud’s Agent Registry catalogs and governs a fleet of agents, tools, and MCP servers. But a registry draws a perimeter around the actor; it says nothing about whether the diff that agent produced still matches the architecture it changed.
The Agent Manager Is the New Control Plane
Manager views without policy are dashboards. Manager views with policy are control planes.
The Next Layer After Agent Frameworks Is a Governance Control Plane
Databricks open-sourced Omnigent, a meta-harness that governs many agents with runtime policy. Frameworks coordinate execution and meta-harnesses coordinate agents — neither enforces architectural intent.
The New Attack Surface Is Agentic Infrastructure
The npm and developer-tooling compromises persisted by writing themselves into Claude Code hooks, VS Code tasks, and CI automation. The attack surface is no longer code — it is the execution fabric surrounding autonomous agents.
When Agents Launch the Database: Why AI Governance Has to Move Beyond the Repository
Most new databases on some platforms are launched by an agent, not a person. When AI provisions infrastructure directly, repository-level governance can no longer see the change.
Search as Code Turns Agent Search Into an Execution Surface
When agents write code to orchestrate search instead of calling tools, tool governance becomes code-execution governance — and the audit question shifts from which tool to what code.
Cloud Agents Need More Than Durable Execution. They Need Architectural Governance.
Cloud agents need durable execution. But durable execution keeps the agent running; it does not keep the architecture coherent. Once agents run unattended, governance is the missing layer.