On November 20, the Google Developers Blog announced Semantic governance policies, available in preview on the Gemini platform. Deepti Sehrawat, a software engineer, writes that they “enable enterprises to govern their agents and provide guardrails to stop that call before it runs.” They check each tool call an agent proposes “against what the user asked for and against rules you write in plain language.” The on-page date is November 20, 2026, and the published date in the page metadata is 2026-11-20. Here’s what that post and the current official Google Cloud docs say.

This is a developer-facing preview for people who build and run agents that call tools, not a new coding assistant in an editor. The blog’s examples are workplace agents that search a shared drive, read files, and send email. The interesting part for engineering work is the control plane: you attach plain-language rules to an agent, a check sits outside that agent, and a denial can stop a proposed tool call before it runs.
Why the blog says permissions aren’t enough
Sehrawat’s opening example is an employee who asks an agent to send preliminary quarterly results to an investor and to copy a personal inbox. “The agent can read the file and send email, so it fulfills the user request.” Permissions already allowed those tools. “Permissions alone can’t catch this,” the post says. “They say what an agent can do, not whether a particular call follows your rules.”
The other gap the post calls out is that a model “can also be talked out of the rules in its system instructions, by a user with a good reason, or by a document telling it to do something nobody asked for, a technique called indirect prompt injection.” So, the post argues, “the check has to sit outside the agent.” Semantic governance policies are enforced through a policy enforcement point, “such as Agent Gateway,” and the post says they stay separate from your agent’s code.
Two checks, and both have to pass
The policies check each proposed tool call against two things. The first is your rules, written in plain language, the way “your legal or compliance team already writes rules.” One official example is that, before an earnings release, quarterly results may be shared only with addresses at example.com. The second is what the user asked for. That intent check, the post says, “ensures the proposed tool call has not deviated from the original user intent” and “is on by default to protect against hijacking.” “A call has to pass both checks to run.”
Google says the policy enforcement point that Semantic governance policies currently support is Agent Gateway. You configure the agent so its egress traffic goes through that gateway. When the model responds with a tool call, Agent Gateway “sends the proposed call to the Semantic governance policy engine for evaluation before the response reaches your agent.”
In the policy engine, “an LLM judge evaluates the proposed call against the conversation so far, the agent’s system instructions and tool descriptions, and your policies.” If the call passes, the response reaches the agent unchanged. If it doesn’t, the engine replaces the response’s content, “tool calls included, with a configurable denial message, so the call never runs.” Either way, “the verdict and the judge’s rationale go to Cloud Logging in your project.”
What the preview does not check
The post is explicit about the edges. “Responses that contain only text, such as an answer, a plan, or a question back to the user, aren’t evaluated, because they take no action.” “Streamed model responses aren’t evaluated.” The built-in user intent check “needs no policies, so it starts checking tool calls as soon as you connect the policy engine,” but a policy that doesn’t name a tool is still checked on every proposed tool call.
Google also says you can create a policy in the Google Cloud console or with the Google Cloud CLI, using gcloud beta ai semantic-governance-policies create. The official getting-started path is to provision the policy engine, connect it to Agent Gateway, and turn on dry run mode first. In dry run, “the engine logs what it would deny without blocking anything.” The post tells you to give every tool a clear description: “The judge relies on descriptions to understand a call, and is instructed to deny calls to tools that have none.” It also says your agent can call its model through the Gemini API, the Anthropic Messages API, Claude models in the Gemini platform, or OpenAI-compatible Chat Completions APIs, “including self-hosted servers such as vLLM.” That’s a compatibility claim, not a local-server setup guide.
The official limits on the judge
This is a preview, and the official docs are blunter than a launch headline. The Semantic governance policies overview marks the feature as a preview, subject to Google’s pre-GA terms. Those docs say pre-GA features are available “as is” and might have limited support. They also include this note: “Semantic governance policy is a Generative AI Service that uses an LLM to implement natural language policies. LLMs are probabilistic and can make mistakes. Verdicts may not be accurate.”
The blog makes the same point in plainer language: “Because verdicts come from an LLM, which is probabilistic, they may vary.” Google recommends reviewing verdicts in dry run mode before you enforce, and using the policies “alongside your other controls.” The post also says Semantic governance policies “complement, rather than replace, your disclosure controls and legal and compliance reviews.” Include facts a policy depends on, such as an earnings date, in the agent’s system instructions, because the judge decides from the conversation, those instructions, and your policies.
I’d treat this as one more layer, not a guarantee. An LLM judge is not an isolation boundary, and a denial in preview does not, by itself, limit which tools the agent can reach. The blog itself places these policies next to IAM and Agent Gateway access policies, Model Armor, and Agent Anomaly Detection, and says they add “the check none of them makes, as one layer of defense in depth.” Cloud Logging will hold each verdict, the judge’s rationale, and the tokens it used, so those logs can include sensitive details from the conversation or the policy text. Dry run is the official first step for a reason: you get to see what the judge would deny before it starts blocking calls.
Hero photo: Sluice gate at Croome Park by DIaNyf8q, via Wikimedia Commons; CC0 1.0; cropped and resized.