Use cases / Platform & AI engineering

Ship agents without becoming the governance bottleneck.

Keep your agents, Envoy and OPA. Roll out controls with Terraform and GraphQL—and trace decisions across model calls, MCP tools and production actions.

Envoy ext_procRemote OPAgovernor_policyGraphQL

GOVERNANCE / RELEASE OVERVIEWSample data

One policy change.
Three runtime paths.

REVIEWED CANDIDATE · SHADOW
production-changes
v13
K8s
Release agentKubernetes · sidecar
Would hold
MCP
Ops assistantMCP proxy
Would allow
API
Infra agentAPI proxy · forward-auth
Would deny
Try this policy rollout ↓Preview before enforcement

Keep the stack
you already run

EnvoyIstioMCPPortkeyLiteLLMOPATerraform
See the connections ↓

01 / Retain the stack

Keep the agents.
Keep your OPA.

Attach through existing infrastructure. Rego stays with your repository and reviewers.

Choose the connection ↓

02 / Control the rollout

Governance is
a pull request.

Declare, preview and promote policy. Treat a control change like a production release.

Try a policy change ↓

03 / Explain the decision

Every verdict.
With its reason.

Connect the agent, the policy that matched and the outcome. Keep the decision trail through rollback.

Inspect the record ↓

04 / Keep the model stream

Your gateway
keeps the tokens.

With gateway hooks, GovernorAI returns the governance result. Your gateway keeps the provider connection and keys.

See the request path ↓

In the product

See each enforcement point decide, in the console.

A recorded walk through the screens behind the connection matrix: decisions at the action boundary, a held action with its reason, what each enforcement point can execute, and the record every decision leaves.

Inside GovernorAI/ Runtime enforcementRecorded demo tenant

Enforcement, step by step

Real product screens from a demo tenant with seeded activity: the outcome, the rule and the reason for each governed action.

Watch the full 2-minute walkthrough →
Recorded against a demo tenant with seeded activity. Real product screens, not a mock-up.

See the control, not another architecture slide

See the impact.
Then make it policy.

A reviewed rule changes one of three outcomes. Try shadow, enforcement and rollback. The destructive deny stays in place.

GovernorAI / Policy rolloutInteractive sample · no live systems · runs locally

Active v12 · Candidate v13 in shadow

Preview without changing traffic

3 sample requests
Sample requests compared under production-changes policy versions 12 and 13
Agent / actionActive · v12Preview · v13
AllowEligible for dispatchWould hold
AllowEligible for dispatchWould allow
DenyNot dispatchedWould deny
1 of 3 decisions changes. The deployment would wait for a human. Read-only work continues; destructive deletion remains denied.
Inspect this decision and retained records 3 records
SELECTED REQUESTdemo-dec-001
POLICYproduction-changes
RUNTIME DECISIONallow
DISPATCH STATEeligible_not_executed

Standard-risk deployment meets v12. Candidate v13 would require a release approver.

Rollback does not rewrite past decisions.

3 illustrative decision records retained. Candidate results are previews, not enforced outcomes.

Retained sample decision records, in order created
DecisionAgentPolicyVerdictDispatch
demo-dec-001Release agentproduction-changesallowEligible, not executed
demo-dec-002Ops assistantproduction-changesallowEligible, not executed
demo-dec-003Infra agentproduction-changesdenyNot dispatched

From the example to the product

Follow a policy to the agents it governs.

Explore the Policy Graph and the published product walkthrough.

Integration, not migration

Five ways in.
One policy workflow.

Pick the connection that fits your stack and the response it needs to carry. Keep the policy, approvals and evidence shared.

Your execution paths

Envoy ext_procMCP proxyForward-authGateway webhookSDK

GovernorAI

Shared policy decisions

Remote OPA or embedded engine
Approvals · stop controls · evidence

Back to the chosen integration

Its native response

Allow · deny · approval
Supported payload transforms

How each connection carries policy decisions, approval responses and payload controls
ConnectionAgent integrationDecisionsApproval responsePayload controls
Envoy ext_procEnvoy Gateway · Istio · GlooInfrastructure configAllow / denyStop + 202Request-body mutation
MCP proxyYour MCP client and serverClient URL changeAllow / denyStop + approval errorTool-call arguments
Forward-authNGINX · Traefik · API managementInfrastructure configAllow / denyRefuse now · 403Use a shaping path
AI-gateway webhookPortkey · LiteLLMGateway configurationAllow / denyBlock + record approvalStructured content¹
Optional SDKPython · JavaScript · GoFunction wrapperAllow / denyTyped exceptionConsult-only

¹ Portkey: transformedData. LiteLLM: transformed_messages / transformed_response. Approval stops dispatch; after review, the caller re-runs the call as a new request, which the approval does not release. Adapter contracts ↗

An integration, not a second policy migration

Your OPA returns the verdict.

Keep your OPA service, repository and review process. Add the agent controls and the decision trail around it.

Explore policy & governance ↗

Built for the people who operate it

Yes, there’s code.
No, not in every agent.

Wire the boundary. Declare the objects. Query the result. Use the SDK when a function is the right place to govern.

Your existing Envoy makes the check. The processor fails closed.

# Filter excerpt; add before envoy.filters.http.router in your existing HTTP connection manager.
- name: envoy.filters.http.ext_proc
  typed_config:
    "@type": type.googleapis.com/envoy.extensions.filters.http.ext_proc.v3.ExternalProcessor
    grpc_service:
      envoy_grpc: { cluster_name: governor_extproc }
    processing_mode:
      request_header_mode: SEND
      request_body_mode: BUFFERED
    failure_mode_allow: false
    allow_mode_override: false
    message_timeout: 5s

Versus what you would otherwise do

Keep your choices.
Unify the governance.

You may already have access controls, guardrails and policy engines. GovernorAI connects them to a shared action-governance workflow.

AI gateways

LLM gateways

What you keepModel access, routing and gateway-native controls; many also support MCP.

Where GovernorAI fitsKeep your gateway. Add policy-controlled actions and a shared rollout and evidence workflow across connected paths.

Gateway infrastructure

API and agent gateways

What you keepAI traffic policy, MCP access and observability in the gateway you operate.

Where GovernorAI fitsKeep the traffic infrastructure. Reuse policy authority and connect its decisions to reviews, rollout and evidence.

Native agent policy

Cloud-native agent policy

What you keepTool authorization built into your cloud provider's agent platform.

Where GovernorAI fitsChoose GovernorAI when you need a shared governance workflow across your existing gateways, policy engines and agent environments.

Build around your engine

DIY OPA

What you keepYour Rego, policy expertise and existing review process.

Where GovernorAI fitsKeep OPA as the decision authority. Reuse integrations, approval workflows and decision evidence rather than building every surrounding component.

Protect and investigate

Your security suite

What you keepThe detection and response tools your security team already operates.

Where GovernorAI fitsConnect platform-owned pre-action controls to evidence that security and GRC can review. Complement the suite rather than replacing it.

Positioning by deployment choice, not a feature-exclusion scorecard. References checked October 5, 2026.

The availability question

Add the control.
Keep the model connection.

Use gateway hooks when you want a governance result without another model-stream proxy. Use local sidecar evaluation when routine policy checks should stay on the host.

Published engine microbenchmark

In-process policy evaluation
Engine only, not end-to-end sidecar or gateway latency.

Read the method and results ↗
01

The gateway keeps the token stream.

For Portkey and LiteLLM hooks, your gateway owns routing, provider credentials and model connections. GovernorAI returns decisions and supported transforms.

02

Fail closed, deliberately.

Set failure_mode_allow: false on Envoy. Use deny-on-error settings in gateway integrations. Test an unavailable processor before promotion.

03

Keep routine evaluation local.

With a local embedded engine, policy evaluation stays beside the agent. Remote OPA follows the network path you choose.

04

Measure the path you deploy.

Validate end-to-end p50, p95 and p99, timeout behavior and request overhead on your chosen integration during the evaluation.

Before you connect

The platform
team’s questions.

Does this replace our gateway or OPA?

No. Use the gateway integrations with your existing model connections. Point GovernorAI at your OPA service when that is your policy authority, or choose embedded evaluation.

Do we have to install an SDK in every agent?

No mandatory agent SDK. Envoy, forward-auth, MCP and gateway integrations attach through infrastructure or client configuration. Use a function wrapper when the SDK is the better fit.

What happens when a request needs approval?

It is not dispatched. The chosen integration returns its approval response or blocks the current request. Human review does not mean a synchronous connection stays open, and a deny rule is not overridden by an approval.

Does rollback undo previous actions?

No. Restoring a policy revision changes how new requests are evaluated. It does not undo completed actions or automatically release held requests. Earlier decision records are not rewritten.

A scoped design-partner evaluation

Six weeks.
One consequential workflow.

Agree on the success criteria, connect the chosen path, preview policy, then enforce with your approval. Measure what changed before expanding.

  1. 01Connect & agree
  2. 02Observe & preview
  3. 03Enforce & measure

Continue