On this page
Runtime Governance vs Pre-Deployment Review: The Right Model
tl;dr
Runtime governance is the right control model for AI agents; pre-deployment review alone is insufficient. Agents make live decisions that no pre-release gate can anticipate, so enforcement must happen inside the execution loop.
Anthropic’s monorepo changes landing per day grew from about 2,500 in May 2026 to more than 30,000 in September 2026. Review is the bottleneck as agents spread. That velocity jump didn’t happen because developers started typing faster — it happened because agents started generating code autonomously, and the old governance model broke.
What’s the fundamental difference between runtime governance and pre-deployment review?
Runtime AI governance is the set of policies, checks and logs that apply to an AI system while it runs in production, evaluating every prompt, output, tool call and data access as it happens. Pre-deployment review is a one-time gate that tests a model and approves it for release at a point in time. The difference is timing and object: review judges a model, runtime governance judges each live action for the life of the system, according to an Atlan article by Emily Winks. The check runs outside the model, so a manipulated prompt cannot switch it off. Runtime governance enforces limits, and the review is where those limits are set; read together, frameworks treat pre-release review as necessary and insufficient.
Security leaders say runtime security focuses on what software does while running rather than only evaluating it before deployment; because prevention will fail, detection and monitoring are equally important. Examples cited include a Meta AI assistant deleting an employee’s inbox and an Amazon internal agent knocking an AWS service offline for 13 hours. Joe Sullivan, former CSO of Uber, Cloudflare and Facebook, said agents have “all the access and none of the judgment,” as reported by CSO Online. Those incidents didn’t happen because the models were poorly vetted — they happened because the models made decisions at runtime that no pre-deployment review could anticipate.
A read from a customer table followed by an outbound email can be harmless step by step and a data leak as a sequence. That’s the core problem: risk lives in the sequence of actions, not in any single artifact. Pre-deployment review examines the artifact. Runtime governance examines the sequence.
Why is pre-deployment review insufficient for agentic development?
Snyk’s Evo Agentic Development Security governs AI coding agents inside the execution loop via PreToolUse and PostToolUse hooks, intercepting shell commands, file reads/writes, network requests, MCP tool invocations and external API calls before and after they execute. The authors argue pre-deployment review cannot govern a decision made mid-session, because an agent’s risk lives in its real-time decision-making process, not in a code artifact, as noted in Snyk’s Safeguard blog. A code review catches a bad line of code. It cannot catch an agent that reasons its way into running curl | bash against an untrusted URL, or exfiltrating a .env file, three tool calls after a review would have signed off.
Anthropic’s monorepo changes landing per day grew from about 2,500 in May 2026 to more than 30,000 in September 2026. Review is the bottleneck as agents spread; vendor telemetry from Faros AI, LinearB and Jellyfish shows more and bigger PRs and longer review waits. Teams that automated the first pass report faster cycles: Microsoft 10 to 20% faster median PR completion, Atlassian 30.8% in a peer-reviewed paper, according to Dbggr. The math is brutal: if your team merges 50 PRs a day and agents push that to 500, no amount of human review scales. You either automate the gate or you become the gate.
According to Sonar’s 2026 State of Code survey cited by Thoughtworks, 42% of committed code is now AI-generated or AI-assisted, and AppSec Santa found that 25% of AI-generated code samples contain critical security vulnerabilities. Thoughtworks launched Agent/works on June 16, 2026, to govern agent sprawl, compliance and AI spend at runtime, as announced by Thoughtworks. When nearly half your codebase comes from autonomous agents and a quarter of it ships with exploitable flaws, governance stops being a compliance checkbox and becomes an architectural necessity.
How do runtime governance tools actually work inside the execution loop?
Snyk’s Evo ADS hooks directly into an agent’s tool calls — proof that pre-deployment review can’t govern a decision made mid-session. The design decision buried in that release is more consequential than the announcement itself: Snyk built the control point directly into an agent’s tool-calling loop, hooking into what it calls PreToolUse and PostToolUse events to observe and govern shell commands, file reads and writes, network requests, MCP tool invocations, and external API calls as they happen, as detailed in Snyk’s Safeguard blog. Snyk’s framing groups this into three concerns — what an agent uses (its tools and data sources), what it does (the actions it takes with them), and what it generates (the code or output it produces) — and argues all three need coverage, because an agent that’s perfectly safe in isolation can still be dangerous in the sequence it chooses.
Nvidia’s Open Agent Safety Platform combines OpenShell, an open-source runtime that controls an agent’s access and actions while it operates, with Sentry, a reference design for monitoring and enforcing limits using a separate control layer. Lee Rossey, CTO of SimSpace, said model-level guardrails are only one layer and enterprises also need controls around the agent that define what it can access, where it can go and when it has to stop; the system enforcing the boundary should not depend on the agent itself to respect that boundary. More than 100 organizations, including Microsoft, Salesforce, SAP, ServiceNow, Cisco and Scale AI, are working with Nvidia’s agent safety technologies, as reported by TechTarget. That separation matters because an agent can create a security problem without acting maliciously — it can follow its instructions and still take action the organization did not intend to allow.
LaunchDarkly’s AgentControl, launched May 2026, enables teams to manage prompts, models, tools and policies as runtime configurations and optimize AI behavior against live traffic without a full deployment cycle. Jonathan Nolen, SVP of product at LaunchDarkly, stated: “You can review a change before it ships; you can’t review an agent’s next thousand decisions… An agent doesn’t misbehave in code review — it misbehaves in production, in front of your customers, so that’s where control has to live.” LaunchDarkly surpassed $200 million ARR, growing more than 25% year over year, with AI-related pipeline nearly doubled since launch, according to LaunchDarkly’s press release. The platform puts control in the runtime layer: teams see what their agents are doing, and when something drifts they can correct it in seconds — no pull request, no redeploy, no waiting.
| Tool | Governance Approach | Pricing (Teams) | Target Audience |
|---|---|---|---|
| Runtime | Per-agent sandbox isolation + usage-based compute | $99/seat/mo + $0.025/vCPU-hr CPU, $0.0075/GiB-hr memory | Engineering teams running agents at scale |
| Snyk Evo ADS | PreToolUse/PostToolUse hooks in execution loop | — | Security teams needing code-to-runtime coverage |
| LaunchDarkly AgentControl | Runtime feature flags for prompts/models/policies | — | Product/engineering teams optimizing live AI behavior |
| Nvidia Open Agent Safety | OpenShell runtime + Sentry control layer (open source) | Free (open source) | Enterprises building custom agent control planes |
Runtime bills $0.025 per vCPU-hour of CPU actually used and $0.0075 per GiB-hour of memory, with no plan fee. A thousand five-minute agent runs on 2 vCPU, 4 GiB sandboxes cost $3.54 on Runtime: $1.04 for CPU and $2.50 for memory, as shown in Runtime’s blog. Agent runs are mostly waiting with short bursts of work; a typical run uses 150 CPU-seconds out of 600 available on 2 vCPUs for 300 seconds (a quarter of allocated compute), while paying for 100% of allocated memory for the full duration. Most coding agents fit in 2 GiB unless the test suite or language server needs more.
Runtime Teams plans start at $99 per seat per month, with a free plan available that includes one session, base sandbox resources and 500 credits. Enterprise plans add custom pricing, advanced security, self-hosting and dedicated support, as noted in MakerStack’s review. A 50-developer Runtime Teams deployment costs $59,400/year in subscriptions alone [50 × $99 × 12], based on the Teams pricing reported by MakerStack. Without credit, Runtime accounts run at most 8 vCPU and 16 GiB at once across sandboxes and image builds, with 2 vCPU and 4 GiB each and eight at once; past that, creates are refused. When every sandbox slot is taken, a create waits for one to free for up to two minutes instead of failing, as documented in Runtime’s changelog. That slot scarcity is the hidden constraint: you can’t just spin up unlimited parallel agents without hitting the credit ceiling.
What does runtime governance cost at scale?
JetBrains reported its AI spend grew roughly tenfold in the first half of 2026, and its first cross-vendor usage report took four days to compile by hand. JetBrains Air Governance now manages agentic usage of roughly 2,300 people monthly and lets admins set AI credit limits for individual users, teams and service accounts, as described in JetBrains’ blog. That tenfold spend growth in six months is the canary in the coal mine — if you’re not tracking per-agent compute and memory at runtime, you’re flying blind on cost.
Snyk’s telemetry from nearly 9,700 developer environments shows 43% of developers run two or more AI coding environments simultaneously, more than half have MCP servers installed, and the most heavily instrumented environments had more than 80 MCP servers running in parallel. Independent reporting found 71% of MCP packages have a single maintainer; among developers with MCP servers installed, 1 in 12 has at least one high or critical finding, as reported by AIntelligenceHub. Each of those MCP connections is a live path from an agent into a code repository, a browser, an internal tool, or a production system — and most of them sit behind no security control at all.
The hidden cost isn’t the governance tool subscription. It’s the incident you didn’t prevent because your control plane stopped at the PR gate. When an agent with MCP access to your production database decides to “clean up” a table at 2 AM, the cost isn’t measured in dollars per seat — it’s measured in downtime, data loss, and regulatory exposure. Runtime governance moves the checkpoint from “before merge” to “before tool call.” That’s the only place it can actually stop the action.
How do you choose the right control model for your team?
If your team runs fewer than five concurrent agents and your codebase has low regulatory sensitivity, pre-deployment review plus automated PR scanning might suffice. But the moment you cross into multi-agent workflows, MCP server proliferation, or production data access, the execution loop becomes the only enforcement boundary that matters. The decision framework comes down to three variables: agent concurrency, data sensitivity, and tolerance for workflow disruption.
Teams running agents in sandboxed environments with per-session isolation (like Runtime’s microVM model) get the strongest security posture but hit slot limits without credit. Teams needing policy-as-code across heterogeneous agent fleets (Copilot Studio, Bedrock, Vertex, browser extensions) need a control plane like Dataiku or Classie that inventories across platforms. Teams optimizing for developer velocity with feature-flag-style control over prompts and models at runtime need LaunchDarkly’s approach. There’s no universal best — there’s only the best fit for your constraints.
The contrarian take: memory, not CPU, is the dominant agent cost. A typical run uses a quarter of its allocated compute but pays for 100 percent of its memory for the full duration, so the cheapest agent architecture shrinks RAM and pauses aggressively rather than optimizing code. That insight changes how you architect governance: you’re not just buying security, you’re buying the right to run agents economically at scale. The governance tool that helps you right-size sandboxes pays for itself.
What’s your current agent concurrency, and where does your control plane actually sit — at the PR gate or inside the execution loop?
Recommended Reading
-
AI Agent Governance for Small Teams: 1-Page Operating Model
Start with a one-page AI agent governance model before buying a platform. Small teams should enforce controls at the agent hook and review weekly, graduating to paid tooling only when the verification gap costs more than the subscription.
-
Shadow AI Agents Already in Your Codebase: Detect and Block
Shadow AI agents are already writing unreviewed code into production from developer endpoints. Network firewalls and CASB tools cannot see the local write path where agents modify repositories, so endpoint detection is required before agents merge pull requests.
-
Finding and Eliminating Shadow AI Without Slowing Developers
Endpoint agents are required to catch shadow AI in engineering organizations. Network and browser tools miss CLI, IDE, and MCP traffic where sensitive code and credentials actually flow.