Veris Guard is the SDK/runtime integration point for Veris Runtime—a production control plane for AI agents that gates actions by proven competence, adds rollback-oriented safety for tool use, and turns production failures into automated regression tests.

What Veris Guard does

Veris Guard (via Veris Runtime) is designed for teams running agents that take real-world actions (issuing refunds, modifying records, calling external APIs) where the cost of mistakes is meaningful. It helps you:

• Gate autonomy by demonstrated competence (competence-based routing rather than static allow/block rules)

• Prevent unsafe tool calls before they execute (a “tool firewall”)

• Reduce blast radius with rollback-oriented execution (a universal “ctrl+Z” concept)

• Continuously improve from incidents by converting failures into regression tests and simulation scenarios

Core mechanisms

Competence Gate (competence firewall)

The Competence Gate routes incoming tasks based on what the agent has proven it can do on similar scenario types. Tasks the agent hasn’t demonstrated competence on can be escalated to a human, enabling production use earlier while limiting risk.

Earned autonomy

Earned autonomy means the agent only acts autonomously on scenario classes where it has proven competence through simulation. As reliability improves on new scenario classes, the agent’s autonomous scope expands—competence-based, not rule-based.

Tool Firewall

The Tool Firewall evaluates each tool call the agent attempts against competence data and safety policies, blocking actions the agent hasn’t earned the right to execute.

Action Rollback

Action Rollback is described as a universal “ctrl+Z” for agent actions: agents can try actions safely in production, and if something goes wrong, the action can be rolled back—combining internal state rollback with staged external calls to help prevent irreversible mistakes.

Continuous improvement loop: failures → regression tests

When an agent fails in production, the incident can be captured and converted into a simulation scenario. The agent is then retrained (or otherwise improved) on that scenario; once it demonstrates competence, it can re-earn autonomy for that class of task—closing the loop between production and simulation.

Integration and deployment (high level)

Veris is designed to work with agents as they are (framework-agnostic and model-agnostic) by interacting with the agent through its external interface.

• SDK integration: Veris provides an SDK that includes veris.guard() for Runtime integration.

• Deployment mode: Veris Runtime can run as a local gateway or sidecar with a minimal hot path.

• Failure behavior: It supports fail-open and fail-closed modes.

• Tooling fit: Runtime is positioned as an overlay control plane that integrates with your existing stack (cloud providers and observability tooling). It’s described as the layer between your agent and its tools—like a service mesh, but for agent actions.

Security, privacy, and operational transparency

Veris Runtime is described as supporting:

• Field-level redaction, configurable retention policies, tokenization, and strict access controls

• Auditable, explainable decisions with customer-configured thresholds and a signed audit trail

• Deployment in Veris Cloud, a customer VPC (AWS/GCP/Azure), or on-prem, depending on data-control needs

How Veris Guard relates to Veris Simulation

Veris Simulation is used pre-deployment to train and evaluate agents in sandboxed, stateful environments. Veris Guard / Runtime is used in production to govern what the agent is allowed to do in real time based on simulation-proven competence—and to feed production failures back into simulation for continuous improvement.

When to use Veris Guard

Use Veris Guard (Runtime governance) when your agent is in production and needs to take higher-risk actions—especially where you want:

• competence-based gating and escalation

• rollback-oriented safety for tool use

• a closed-loop process that turns incidents into regression tests and new simulation scenarios