Field noteNov 21, 20265 min read1 source

Check what your AI agents do before they do it, with Semantic governance policies

In one minute

Google has introduced Semantic governance policies in Preview in the Gemini platform, checking proposed agent tool calls against both user intent and plain-language business rules before execution. For teams connecting agents to sensitive tools, this adds an inline control point outside the agent’s own instructions, with dry-run testing and audit logs.

What changed: Google’s Gemini platform is previewing semantic governance policies that check agent tool calls against plain-language rules and user intent before execution.

What happened

Google’s announcement describes Semantic governance policies as a check on each tool call proposed by an agent’s model. A proposed call must pass two tests: whether it follows rules written by the organization, and whether it matches what the user asked the agent to do. The user-intent check is on by default. Policies can be written in natural language and attached to all of an agent’s tools or to a specific tool; they can also refer to tool parameters. Google gives examples including limits on sharing unreleased financial results, invoice approval requirements, spending caps, and requiring a person to make hiring decisions.

The policy engine operates through Agent Gateway, the policy enforcement point Google currently supports. An organization must configure the agent’s egress traffic to pass through Agent Gateway. When the model proposes a tool call, the gateway sends it to the policy engine before returning the response to the agent. An LLM judge evaluates the call using the conversation so far, system instructions, tool descriptions, and applicable policies. If the call passes, it reaches the agent unchanged. If it fails, the engine replaces the response, including its tool calls, with a configurable denial message, so the action does not run. The verdict and the judge’s rationale are sent to Cloud Logging. Responses containing only text—such as an answer, plan, or question—are not evaluated.

Google says an agent can use models through the Gemini API, Anthropic Messages API, Claude models in the Gemini platform, or OpenAI-compatible Chat Completions APIs, including self-hosted servers such as vLLM. To get started, teams provision the policy engine, connect it to Agent Gateway, and turn on dry-run mode. Dry run logs what the system would deny without blocking it; the intent check is already enabled. Google advises giving every tool a clear description, adding policies with specific limits and terms that match those descriptions, reviewing verdicts in Cloud Logging, and then switching to enforcement.

The announcement positions this as one layer in a defense-in-depth setup, not a replacement for other controls. IAM and Agent Gateway access policies govern which tools and MCP servers an agent can reach; Model Armor screens prompts and responses; Agent Anomaly Detection analyzes sessions asynchronously. Semantic governance policies instead judge each proposed action inline. Google cautions that LLM-based verdicts are probabilistic, streamed model responses are not evaluated, and the policies complement rather than replace disclosure controls and legal or compliance review.

What the archive adds

New Runtime’s earlier coverage of ODAP Gateway’s governed semantic review for AI-to-data access appeared on 2026-11-07. Google’s announcement is a new event in the same broader direction: placing policy evaluation between an agent and the tools it can invoke, rather than relying only on agent instructions.

Trend signal

This supports agent security moving to runtime boundaries: Google describes an inline policy check outside the agent’s code, before a tool action runs. The approach still depends on routing traffic through Agent Gateway and on probabilistic judgments, so it is a runtime control layer rather than a deterministic guarantee.

Why now

Google frames the feature around a practical gap in existing controls: permissions can limit which actions an agent is capable of, but do not determine whether a particular permitted action follows the user’s intent or business rules. The announcement also points to indirect prompt injection as a reason to put the check outside the agent. Google says it plans to report how the policies performed against AgentDojo in a subsequent post.

Why it matters

An agent’s access to tools is not the same as authorization for every individual action. A finance agent may legitimately read and email files yet still need to stop a disclosure to a personal account; a tool-enabled agent may encounter instructions embedded in a document that no user authorized. Inline checks let teams express some of those boundaries as policies and inspect decisions before broad enforcement.

The deployment trade-off is operational: teams must route egress through Agent Gateway, write policies that make relevant facts and limits clear, and supply useful tool descriptions. Dry run offers a way to observe likely denials before blocking work, but it does not eliminate false decisions. Because Google describes the judge as probabilistic, teams should retain other access, disclosure, and review controls rather than treating a natural-language policy as a hard guarantee.

Limits and uncertainty

The feature is in Preview, and Agent Gateway is the policy enforcement point Google currently supports. The announcement does not quantify latency, cost, false-positive or false-negative rates, or how reliably the judge handles varied policy wording. It explicitly warns that verdicts may vary and that streamed model responses are not evaluated. Google recommends dry-run testing, but does not report a completed evaluation against an independent benchmark in this announcement; it says a future post will discuss AgentDojo results.

Skill to build now

Choose one consequential tool action, such as sending external email or submitting a payment, and write a policy with a specific boundary and any required exception handling. Attach it to the relevant agent and tool, make the tool description explicit, and test in dry run before enforcement. Review the logged verdicts and rationales for cases the policy misclassifies; only then decide whether the rule is ready to block actions.

Reader takeaway

Google’s preview adds an inline, policy-based checkpoint for agent tool calls, but it is not a deterministic safety guarantee. Route actions through the enforcement point, test policies in dry run, inspect decisions, and keep other controls in place.

Evidence / sources

  1. 1developers.googleblog.com/check-what-your-ai-agents-do-before-they-do-it-with-semantic-governance-policies
All Field Notes

Next reads

Read next

Open the graph
  1. 01topicGoogleExplore the google topic hub.
  2. 02topicGeminiExplore the gemini topic hub.
  3. 03archiveField NotesOpen the latest editorial analysis.
  4. 04sourcesSourcesSee the original sources this archive cites.
Who read this page?Machine requests, hidden until opened

Loading the privacy-safe route aggregate...

Open the JSON contract