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.
Programmable AI Policy Is Not Enough for Coding Agents
Enterprise AI governance is moving into the execution path. Coding agents expose a second problem: most of the policy they must obey was never written as policy.
The Emerging AI Agent Infrastructure Stack
Agent systems are separating into layers: models, tools, orchestration, memory, observability, governance, provenance, verification. Each answers a different reliability question — and the defining question is no longer model capability.
NVIDIA OpenShell Reference Architecture: Agent Access Policy Is Not Architecture Governance
NVIDIA's OpenShell Reference Architecture can verify agent access policy in five modeled areas. An allowed write can still break an architecture decision.
Claude Frontier Academy: What 10,000 Frontier Deployed Engineers Mean for Enterprise AI
Anthropic will train 10,000 Frontier Deployed Engineers by 2027. The decisions each deployment makes have to outlive the engineer who made them.
Multi-Agent Coding Needs More Than Shared Context
An AWS AI Labs preprint made coding agents talk only through structured artifacts. Pass rates rose and runs got faster. Agreements need scope and checks, not more context.
Your AI Is On Premises. Your Governance Probably Is Not.
Private compute decides where AI runs. It does not decide how AI acts. Why governance has to move inside the trust boundary too.
What Makes Prompts a Graph: Why Prompt Graph Engineering Needs Architectural Governance
A July 2026 paper defines prompt graph engineering through four conditions. Explicit execution graphs still need architectural constraints at the nodes that change software.
AI Agent Swarms Need Deterministic Guardrails
An agent-driven intrusion spanned roughly 17,600 actions. Long-horizon swarms need constraints that survive delegation and remain authoritative at execution time.
OpenAI Symphony: Why Agent Orchestration Still Needs Architectural Context
Symphony turns the issue tracker into a control plane for coding agents. Durable work still needs durable architectural authority across disposable sessions.
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.
Forward-Deployed Architects Need a Decision Layer
A forward-deployed architect discovers how a business unit actually operates. Without a decision layer that survives them, an agent working in that unit inherits none of it.
The Agent Economy Needs a Decision Layer
The agent stack is building identity, authorization and observability. None of them answers whether a proposed action contradicts what the organization already decided.
What Changes When Forward-Deployed Engineers Use Coding Agents
Agents do not widen the context deficit. They raise the rate at which it converts into committed code, which breaks the review arrangement that used to contain it.
Forward-Deployed Engineering in the AI-Native SDLC
Forward-deployed engineers change systems whose architectural reasoning they never inherited. Coding agents widen that gap, and turn a niche staffing condition into the general case.
The Hidden Architecture Problem in Forward-Deployed Engineering
A repository records what exists, not what was deliberate. Four structural failure modes explain why more documentation has never closed that gap.
Why Forward-Deployed Engineers Are Becoming Central to Enterprise AI
Enterprise AI deployments rarely fail on model quality. They fail on the environment, which is why the last mile became an engineering role rather than a configuration task.
DeepSeek Harness Got Agent = Model + Harness Right. Governance Is the Missing Term
DeepSeek Harness publishes a real pre-execute policy seam. It does not supply the architectural decisions to enforce through it.
What Anthropic's Model Hardware Standard Reveals About AI Agent Guardrails
MHS lets AI agents operate lab equipment and exposes device safety limits. It does not define the organizational policy layer above them.
AI Agent Orchestration Is Not Software Engineering Governance
Orchestration decides what runs next. Governance decides what must remain true. A perfectly orchestrated workflow can still violate an ADR.
Sovereign AI Needs Sovereign Engineering
Sovereign AI is about where models run. The next problem is how AI builds software. Architectural intent keeps engineering consistent across every model and region.
AI Coding-Agent Architecture: The Layers Between a Model and Production
A coding agent is not a model. It is a stack: the model, the harness, the governance layer, and the intent it enforces. Here is what each layer does, and which one most tools leave out.
Recursive Self-Improvement Makes Engineering Governance Inevitable
Anthropic says Claude now writes more than 80% of its merged code. When generation outpaces review, governance becomes production infrastructure, not process.
Databricks Omnigent and the Agent Infrastructure Layer
Omnigent orchestrates agents across Claude Code, Codex, and Cursor. Orchestration coordinates agents; it does not preserve architectural intent.
Morph Reflexes: Agent Observability Is Not Engineering Governance
Behavioral observability catches the loops and jailbreaks the trace can't see. It still can't decide what an agent is allowed to build.
NVIDIA NeMo Agent Toolkit: Who Governs the Code?
NVIDIA's toolkit connects, evaluates, and optimizes agent workflows. It does not verify that the code those agents write respects your architecture.
Palantir's Agentic Governance Reveals a Missing Layer
Palantir is right that governance must move to where agents operate. For software teams, that includes the code coding agents write.
Why the AI Race Won’t Be Won on Infrastructure Alone
The 2026 consensus says infrastructure, not algorithms, wins the AI race. Infrastructure decides how much intelligence you can access — governance decides how much you can safely deploy.
Recursive Self-Improvement Is Becoming an Orchestration Problem
Recursive self-improvement is framed as a model capability, but the fastest feedback loops are in the orchestration layer around the model. That makes it a governance problem, not an intelligence one.
Microsoft's Agent Platform Reveals the Next AI Infrastructure Layer: Governance
Agent HQ's control plane, Build 2026's agent stack, and the Agent Control Specification all name governance as an explicit layer. Platform governance covers access and audit. Architectural governance is the layer no platform ships.
Microsoft Project Solara: If Agents Replace Apps, Where Does Governance Live?
At Build 2026 Microsoft unveiled a platform for devices that run agents instead of applications — not on Windows. For fifty years governance attached to the app. The post-app computer needs governance that follows the agent.
The Future of Software Engineering After Vibe Coding
Vibe coding discovers what could exist; engineering decides what is allowed to persist. As agents absorb the writing of code, engineering becomes governing the systems that write it — and apprenticeship, the loop that used to renew architectural intent, is the first thing it makes look redundant.
AI Agent Governance: Runtime vs. Architectural Control
The industry is converging on agent governance, but the term is splitting into two markets: runtime governance protects systems from agent actions, while architectural governance protects systems from the architectural entropy autonomous iteration creates over time.
Google Gemini Deep Research Agent Shows Why Managed AI Agents Need Governance
Google’s Gemini Deep Research Agent packages planning, search, reading, and synthesis into a managed, long-running runtime reached through the Interactions API. That removes orchestration boilerplate but moves the governance problem closer to runtime rather than away.
The AI Stack Is Rebuilding Determinism Around Probabilistic Models
n8n moved business logic out of prompts. The same argument extends to architectural decisions.
The Emerging AI Engineering Control Plane
What Anthropic's Claude Marketplace reveals about the post-Copilot stack — generation, memory, orchestration, verification, and the layer above them.
Microsoft's Agentic Transformation Playbook: AI Agent Governance
Microsoft's playbook reframes agentic AI as an operating-model shift. Once agents execute work, governance becomes infrastructure.
Mistral Vibe Shows AI Coding Is Becoming Enterprise Infrastructure
Coding agents are becoming multi-surface execution systems. Architectural governance becomes a platform concern, not a prompt-file problem.
Snowflake's AI Data Engineering Report Signals a Shift Toward Governance Infrastructure
MIT/Snowflake report: data engineers' time on AI is tripling toward 61% by 2027. Data engineering is evolving into governance engineering.
Anthropic’s Research System Reveals the Next Layer of AI Infrastructure
Anthropic’s engineering breakdown of its multi-agent research system reads as a preview of the infrastructure layer emerging between orchestration and execution. Coordination infrastructure is becoming a category of its own.
AI Is Becoming the Operating Layer for Software Execution
Operating systems coordinate hardware. Cloud platforms coordinate infrastructure. AI is becoming the coordination layer for execution itself — intent, tools, agents, memory, and execution chains. Once that shift completes, governance stops being a policy concern and becomes infrastructure.
Agents of Chaos and the Governance Gap
A new red-teaming study deployed real AI agents in a live environment for two weeks. The failures weren’t about model alignment. They were about what happens when aligned agents operate without governance infrastructure.
The Generative AI Software Engineering Stack
A seven-layer reference frame for the GenAI software engineering stack — from foundation models to human oversight. Almost everyone is competing in layers 1–3. Very few are building layer 5 — governance and architectural control — seriously.
OpenAI-Compatible APIs Are Commoditizing Models
NVIDIA’s NIM platform exposes 80+ frontier models behind a single OpenAI-compatible endpoint. Models become interchangeable infrastructure. The strategically scarce layer is the system that preserves engineering continuity across constantly changing models and agents.