Strands Agents Integration

Integrate TealTiger with Strands Agents to add deterministic governance to your production agents. The strands-tealtiger package ships as a native Strands plugin — no external server, no LLM in the governance path, under 2ms per evaluation.

Why integrate TealTiger with Strands?

Strands Agents gives you a model-driven agent loop with lifecycle hooks and a plugin system. TealTiger plugs into that system to add:

Tool authorization — Allowlist and blocklist which tools the agent can call
PII protection — Block tool calls containing SSNs, credit cards, emails, or phone numbers
Secret detection — Catch API keys, tokens, and credentials before they leak
Prompt injection defense — Detect adversarial inputs in tool arguments
Cost budgets — Hard-stop when session spend exceeds your limit
Kill switch — Freeze all tool calls instantly without restarting
Structured audit trail — Every decision produces a traceable record

Installation

pip install strands-tealtiger

Quick start

from strands import Agent
from strands_tools import calculator
from strands_tealtiger import TealTigerPlugin

agent = Agent(
    tools=[calculator],
    plugins=[TealTigerPlugin(
        mode="ENFORCE",
        allowed_tools=["calculator"],
        budget_limit=5.0,
    )]
)

agent("What is 42 * 17?")

Configuration

Tool allowlist and blocklist

Control which tools the agent can call using glob patterns:

governance = TealTigerPlugin(
    mode="ENFORCE",
    allowed_tools=["search", "read_*"],    # Only these tools permitted
    blocked_tools=["delete_*", "rm_*"],    # Always denied (overrides allowlist)
)

PII detection

Block tool calls containing sensitive data in their arguments:

governance = TealTigerPlugin(
    mode="ENFORCE",
    pii_categories=["ssn", "credit_card", "email", "phone"],
)

Category	Pattern	Example
`ssn`	`\d{3}-\d{2}-\d{4}`	123-45-6789
`credit_card`	16-digit card number	4111-1111-1111-1111
`email`	Standard email regex	[email protected]
`phone`	US phone with optional +1	+1-555-123-4567

Secret detection

Block tool calls containing API keys, tokens, or credentials:

governance = TealTigerPlugin(
    mode="ENFORCE",
    detect_secrets=True,  # Default: True
)

Detects: OpenAI keys (sk-...), GitHub tokens (ghp_...), AWS keys (AKIA...), Slack tokens, generic API keys, and PEM private keys.

Prompt injection defense

Detect adversarial inputs in tool arguments before they reach the model:

governance = TealTigerPlugin(
    mode="ENFORCE",
    detect_injection=True,
    injection_threshold=0.8,  # Higher = fewer false positives
)

Catches 8 attack patterns: instruction override, DAN/jailbreak, developer mode, system prompt override, delimiter injection, XML tag injection, fake system messages, and jailbreak keywords.

Cost budget

Hard-stop when session cost exceeds your limit:

governance = TealTigerPlugin(
    mode="ENFORCE",
    budget_limit=5.0,         # $5 max per session
    cost_per_call=0.003,      # Estimated cost per tool call
)

Kill switch

Freeze all tool calls immediately — no policy can override:

governance = TealTigerPlugin(mode="ENFORCE")

# Later, when something goes wrong:
governance.freeze()    # All tool calls blocked instantly
governance.unfreeze()  # Resume normal governance

Governance modes

Mode	Behavior	Use case
`ENFORCE`	Block violations via `event.cancel_tool`	Production
`MONITOR`	Evaluate policies, log decisions, allow all through	Staging / shadow testing
`OBSERVE`	Skip evaluation, track cost only	Initial rollout

Start with OBSERVE when deploying, promote to MONITOR to see what would be blocked, then switch to ENFORCE in production:

# Staging
governance = TealTigerPlugin(mode="OBSERVE")

# Shadow testing
governance = TealTigerPlugin(mode="MONITOR")

# Production
governance = TealTigerPlugin(mode="ENFORCE")

Audit trail

Every evaluation produces a structured GovernanceDecision:

for decision in governance.decisions:
    print(
        f"[{decision.action}] {decision.tool_name} "
        f"— {decision.reason_codes} "
        f"(risk={decision.risk_score}, {decision.evaluation_time_ms:.2f}ms)"
    )

Field	Type	Description
`decision_id`	`str`	UUID for correlation
`action`	`str`	`ALLOW` or `DENY`
`mode`	`str`	`ENFORCE`, `MONITOR`, or `OBSERVE`
`tool_name`	`str`	Tool that was evaluated
`reason`	`str`	Human-readable reason
`reason_codes`	`list[str]`	Machine-readable codes
`risk_score`	`int`	0 (safe) to 100 (critical)
`cost_tracked`	`float`	Cost for this call
`cumulative_cost`	`float`	Session total
`evaluation_time_ms`	`float`	Governance latency

Multi-agent support

Works with Strands multi-agent patterns (Swarm, Graph). Attach the plugin to individual agents:

from strands import Agent
from strands.multiagent import Swarm
from strands_tealtiger import TealTigerPlugin

researcher = Agent(
    name="researcher",
    tools=[search],
    plugins=[TealTigerPlugin(
        mode="ENFORCE",
        allowed_tools=["search"],
        budget_limit=3.0,
    )]
)

writer = Agent(
    name="writer",
    tools=[write_file],
    plugins=[TealTigerPlugin(
        mode="ENFORCE",
        allowed_tools=["write_file"],
        pii_categories=["ssn", "credit_card"],
    )]
)

swarm = Swarm([researcher, writer])

Complete example

from strands import Agent, tool
from strands_tealtiger import TealTigerPlugin

@tool
def search(query: str) -> str:
    """Search the web."""
    return f"Results for: {query}"

@tool
def send_email(to: str, body: str) -> str:
    """Send an email."""
    return f"Sent to {to}"

@tool
def delete_database(table: str) -> str:
    """Delete a database table."""
    return f"Deleted {table}"

# Configure governance
governance = TealTigerPlugin(
    mode="ENFORCE",
    allowed_tools=["search", "send_email"],
    blocked_tools=["delete_*"],
    pii_categories=["ssn", "credit_card", "email"],
    detect_secrets=True,
    detect_injection=True,
    budget_limit=5.0,
    cost_per_call=0.003,
    on_decision=lambda d: print(f"  [{d.action}] {d.tool_name}: {d.reason_codes}"),
)

agent = Agent(
    system_prompt="You are a helpful research assistant.",
    tools=[search, send_email, delete_database],
    plugins=[governance],
)

# This works (search is allowed)
agent("Search for AI governance frameworks")

# This is DENIED (delete_database is in blocklist)
agent("Delete the users table")

# Post-run analysis
print(f"\nTotal decisions: {len(governance.decisions)}")
print(f"Denied: {governance.deny_count}")
print(f"Session cost: ${governance.total_cost:.4f}")

How it works

TealTiger implements the Strands Plugin interface with two @hook methods:

BeforeToolsEvent — Kill switch enforcement at the batch level. If frozen, cancels the entire batch.
BeforeToolCallEvent — Per-tool policy evaluation. Checks allowlist, blocklist, injection, PII, secrets, and budget in sequence. First violation wins.

Evaluation order:

Kill switch (risk: 100)
Budget limit (risk: 70)
Blocked tools (risk: 90)
Allowed tools (risk: 80)
Prompt injection (risk: 95)
PII detection (risk: 90)
Secret detection (risk: 95)

Comparison with Agent Control

	Agent Control (Galileo)	TealTiger
Architecture	External server + Docker	In-process, zero infrastructure
Latency	Network round-trip	Under 2ms in-process
Dependencies	Galileo SaaS	None — stdlib only
Determinism	LLM-as-judge (Luna-2)	Pure regex/pattern matching
Offline	Requires connectivity	Works fully offline
Lambda/serverless	Cold start penalty	Zero cold start overhead
Cost	Paid AI evaluations	Free, Apache 2.0

API reference

Constructor parameters

Parameter	Type	Default	Description
`mode`	`str`	`"ENFORCE"`	Governance mode
`allowed_tools`	`list[str] \| None`	`None`	Glob patterns for permitted tools
`blocked_tools`	`list[str] \| None`	`[]`	Explicit deny-list
`pii_categories`	`list[str] \| None`	`[]`	PII types to detect
`detect_secrets`	`bool`	`True`	Enable secret detection
`detect_injection`	`bool`	`True`	Enable injection detection
`injection_threshold`	`float`	`0.7`	Confidence threshold (0.0–1.0)
`budget_limit`	`float \| None`	`None`	Max session cost in USD
`cost_per_call`	`float`	`0.002`	Estimated cost per tool call
`on_decision`	`callable \| None`	`None`	Callback for each decision

Methods

Method	Description
`freeze()`	Activate kill switch — block all tool calls
`unfreeze()`	Deactivate kill switch
`reset()`	Clear session state (cost, decisions, freeze)

Properties

Property	Type	Description
`decisions`	`list[GovernanceDecision]`	All decisions this session
`total_cost`	`float`	Cumulative cost
`deny_count`	`int`	Number of denials
`is_frozen`	`bool`	Kill switch status

Getting Started

Core Concepts

Governance Domains

Policy Authoring

Architecture

Integrations

Deployment

API Reference

Cookbook

Compliance & GRC

Guides

Reference

Versions

Playground

Dashboard

Blog

Strands Agents Integration

Why integrate TealTiger with Strands?

Installation

Quick start

Configuration

Tool allowlist and blocklist

PII detection

Secret detection

Prompt injection defense

Cost budget

Kill switch

Governance modes

Audit trail

Multi-agent support

Complete example

How it works

Comparison with Agent Control

API reference

Constructor parameters

Methods

Properties

Next steps

​Why integrate TealTiger with Strands?

​Installation

​Quick start

​Configuration

​Tool allowlist and blocklist

​PII detection

​Secret detection

​Prompt injection defense

​Cost budget

​Kill switch

​Governance modes

​Audit trail

​Multi-agent support

​Complete example

​How it works

​Comparison with Agent Control

​API reference

​Constructor parameters

​Methods

​Properties

​Next steps

Why integrate TealTiger with Strands?

Installation

Quick start

Configuration

Tool allowlist and blocklist

PII detection

Secret detection

Prompt injection defense

Cost budget

Kill switch

Governance modes

Audit trail

Multi-agent support

Complete example

How it works

Comparison with Agent Control

API reference

Constructor parameters

Methods

Properties

Next steps