Beyond Content Filtering: How TealTiger v1.2 Enforces AI Agent Governance with Deterministic Policy Evaluation

The Governance Gap: Why Traditional Guardrails Fall Short

AI agents are no longer just answering questions—they are taking actions. They call APIs, query databases, execute code, and manage memory. The security surface has shifted from what the model says to what the agent does. Most guardrail solutions address the first problem: they filter content, detect prompt injection, and moderate output. These measures are necessary, but insufficient for the new reality. The critical gap is who decides what the agent is allowed to do once it has been persuaded to act. Tool authorization, memory governance, cost limits, and audit evidence are not content safety problems—they are governance problems. They require a fundamentally different architecture.

Introducing TealTiger v1.2: A Deterministic Governance Engine

TealTiger v1.2 is a deterministic governance engine built specifically for AI agents. It evaluates every agent action against policy—in parallel, at runtime, with no large language model (LLM) in the decision path. The key design constraint is simple: same input plus same policy equals same decision, every time. There is no probabilistic scoring, no model inference, just pattern matching, severity ranking, and boolean logic. This makes every governance decision auditable, reproducible, and testable.

Architecture Overview

The engine is decomposed into seven specialized governance modules, each owning a single dimension of control. Examples include TealSecrets (secrets management), TealRegistry (allowlist of approved tools), TealReliability (circuit breakers for flaky APIs), and TealMemory (memory scope governance). All modules run in parallel via Promise.allSettled for maximum performance. The merge strategy is the most restrictive action wins: if TealSecrets returns DENY and TealRegistry returns ALLOW, the final decision is DENY. There is no way to “un-deny” a request—the same principle as AWS IAM’s explicit deny override, adapted for AI agents with 12 graduated actions instead of binary allow/deny.

How Policy Evaluation Works

Parallel Execution and Most Restrictive Wins

When a request arrives, all modules evaluate it simultaneously. Each module returns an action from the severity scale. These actions are merged: the highest severity action prevails. For example, if any module returns DENY, the entire request is denied regardless of other modules. If the highest severity is REQUIRE_APPROVAL, the request is paused for human intervention. The system is fail-closed by default—if any module throws an exception or times out, the entire request is denied to avoid unsafe behavior.

Action Severity Scale

Severity	Actions
100	DENY, DENY_WRITE, DENY_READ
80	REQUIRE_APPROVAL
70	REDACT, REDACT_AND_WRITE
60	DEGRADE, STORE_SUMMARY_ONLY
50	TRANSFORM
0	ALLOW, ALLOW_WRITE

This scale provides fine-grained control beyond simple allow/deny, enabling nuanced policies like redacting sensitive data or degrading image quality to prevent data exfiltration.

Docker Sidecar Deployment

TealTiger v1.2 is designed to run as a Docker sidecar alongside the AI agent. The agent sends all action requests to the sidecar’s HTTP endpoint, which evaluates them against the loaded policies and returns a decision. This architecture keeps governance completely isolated from the agent process, making it easy to update policies without redeploying the agent, and ensuring that the governance layer remains independent even if the agent is compromised. The sidecar handles all module evaluation, caching, and audit logging, and can be scaled independently of the agent.

Honest Benchmark Results

Because TealTiger uses no LLM in the decision path, its performance is predictable and fast. Each module performs deterministic checks—pattern matching against allowlists, regex for secrets, counters for rate limits—all of which complete in microseconds. In practice, the entire parallel evaluation pipeline completes in under 5 milliseconds for a typical request. This is orders of magnitude faster than calling an LLM for every governance decision, and avoids the cost and latency overhead of probabilistic methods. Furthermore, because decisions are deterministic, they can be replayed and audited without ambiguity. The architecture scales linearly with the number of modules; adding more modules does not significantly increase latency thanks to parallelism.

Conclusion: A New Standard for AI Agent Safety

TealTiger v1.2 addresses the governance problem that traditional content filters cannot solve. By providing a deterministic, modular, sidecar-based engine, it gives developers confidence that their AI agents will only perform actions that are explicitly permitted. The fail-closed design, auditable decisions, and minimal latency make it suitable for production environments where safety and reliability are paramount. As AI agents take on more autonomous tasks, architectures like TealTiger will become essential for building trustworthy systems.