[Integration] TealTiger deterministic governance as a fast-path pre-filter for Adrian

[nagasatish007]

Summary

Proposing an integration between TealTiger and Adrian that creates a two-tier defense architecture: TealTiger handles fast deterministic checks (<5ms) as a first pass, and Adrian's reasoning engine handles the deeper behavioral/intent analysis for requests that pass the deterministic layer.

Why this makes sense

Adrian and TealTiger solve different parts of the same problem:

Layer	TealTiger	Adrian
Detection method	Deterministic pattern matching (no LLM)	LLM-based reasoning analysis
Latency	<5ms	~200ms (LLM inference)
Strength	PII, secrets (500+ patterns), tool allowlists, cost budgets	Intent detection, CoT analysis, behavioral anomalies
Weakness	Can't reason about why an agent did something	Slower, requires GPU, non-deterministic

Combined, you get defense-in-depth:

• Stage 1 (TealTiger): Catches the easy wins instantly — secrets in tool args, PII in queries, budget violations, tool allowlist violations. No compute cost, no false positives.
• Stage 2 (Adrian): For requests that pass Stage 1, do the deeper reasoning analysis — is the agent's intent malicious? Is it drifting from its remit? Is the CoT suspicious?

This saves Adrian's LLM compute for the genuinely ambiguous cases (where reasoning analysis provides the most value) while covering deterministic patterns at zero cost.

Proposed integration

import adrian
from tealtiger import TealOpenAI

# TealTiger handles fast deterministic governance (<5ms)
client = TealOpenAI(
    api_key=os.getenv("OPENAI_API_KEY"),
    guardrails={"pii_detection": True, "secret_detection": True},
    budget={"max_cost_per_session": 5.00},
)

# Adrian handles deep reasoning-level monitoring
adrian.init(api_key="adr_live_...")

# Both work together — TealTiger blocks the obvious violations,
# Adrian catches the subtle intent-based threats

Collaboration options

1. Joint example: A LangChain agent with both TealTiger (deterministic layer) and Adrian (reasoning layer) showing combined detection
2. Shared event format: Adrian events and TealTiger TEEC receipts could share correlation IDs for unified audit trails
3. SDK interop: TealTiger's on_decision callback could optionally forward "borderline" decisions (risk_score 40-70) to Adrian for deeper analysis
4. Benchmark: Compare detection rates of TealTiger alone, Adrian alone, and both combined — quantify the defense-in-depth benefit

About TealTiger

• Apache 2.0, Python + TypeScript SDKs
• Deterministic governance — no LLM in governance path, <5ms
• Secret detection (500+ patterns), PII, prompt injection, cost tracking, circuit breaker
• Already integrated with LangChain, AG2 (merged), CrewAI, Haystack, Vercel AI SDK
• PyPI: https://pypi.org/project/tealtiger/

Both projects are Apache 2.0, both target the same user base (teams deploying AI agents in production), and both are FOSS. Happy to collaborate on whatever integration approach works best for the Adrian team.

[max-c-sa]

Hey Naga - very timely and relevant suggestion. Let's pick up in Discord to chat more https://discord.gg/zcwYwfdAFz I am maxicorbs

[nagasatish007]

In reponse to our discord discussion:

Hey yanny — great questions, appreciate the interest .

On the defense layers:

TealTiger is NOT regex-only. We have a multi-stage pipeline (shipping in v1.4):

Stage 1 (fast, <5ms): Pattern/regex scanning — PII, secrets, injection
signatures. Deterministic, no model.
Stage 2 (standard, <20ms): Structural analysis — AST-based intent
classification, sentence-structure anomaly detection. Still deterministic.
Stage 3 (deep, <50ms): Lightweight pre-trained binary classifier for
harmful content. Not a generative LLM — a small inference model.

Each stage is opt-in via a depth parameter: "fast", "standard", or "deep".
You pick what latency budget you're willing to spend. Stage 1 DENY
short-circuits (skips Stage 2/3). So yes — fully opt-in per layer.

The hard constraint: no generative LLM in the governance decision path.
Everything is reproducible (same input → same decision).

On Go support:

Honest answer — we don't have a Go SDK today and it's not on the immediate
roadmap. Python and TypeScript are the current languages.

For the Adrian integration specifically, there are a few options:

HTTP sidecar — TealTiger runs as a lightweight local HTTP service (no external calls), Go calls it over localhost. Adds ~1-2ms for the
HTTP round-trip on top of evaluation time.
WASM — We've been exploring compiling the core evaluation engine to
WASM for embedding in non-Python/TS runtimes. Not shipped yet, but
it's the path that would give you in-process Go without a separate
container.
Go-native port — If there's enough demand from the Go agent
ecosystem, we'd consider it. Adrian would be a strong motivating use
case.

Which approach would work best for your architecture? The sidecar is
available now; WASM and Go-native are future work.

Thanks for checking out TealTiger — excited about the Adrian collab