Governance at Scale

In enterprise deployments, governance teams define policy and developers implement applications. These are separate roles with separate permissions. Developers cannot set, modify, or bypass governance controls — they receive a pre-configured SDK with signed policy bundles that enforce organizational standards.

This operating model mirrors how enterprises handle network security (NetSec team defines firewall rules, developers deploy behind them) and data governance (DBA team defines access policies, applications connect through them). TealTiger brings the same separation of duties to AI agent governance.

The Two-Persona Model

	Governance Team	Development Team
Role	Define, author, and sign governance policies	Build AI applications and agents
Permissions	Create/modify policy bundles, set FREEZE rules, manage NHI registry	Integrate SDK, call `evaluate()`, handle decisions
Cannot do	Write application code, deploy agents	Modify policies, disable enforcement, bypass controls
Tools	Policy authoring CLI, bundle signing keys, TealFlow YAML	`npm install tealtiger` / `pip install tealtiger`
Accountability	Policy correctness, compliance mapping, audit readiness	Application functionality, user experience, performance
Evidence	Policy version history, signing audit trail	Decision logs, governance receipts

How It Works

┌─────────────────────────────────────────────────────────────────────┐
│                        GOVERNANCE TEAM                               │
│                                                                     │
│  1. Author policies (YAML/JSON)                                     │
│  2. Define FREEZE rules (immutable safety controls)                 │
│  3. Set automation levels per action class                          │
│  4. Configure NHI registry (agent identities + scopes)              │
│  5. Sign bundle with Ed25519 key                                    │
│  6. Publish to internal registry (S3, Artifactory, OCI)             │
└──────────────────────────────┬──────────────────────────────────────┘
                               │
                    Signed Policy Bundle
                    (integrity hash + signature)
                               │
                               ▼
┌─────────────────────────────────────────────────────────────────────┐
│                        DEVELOPMENT TEAM                              │
│                                                                     │
│  1. npm install tealtiger (or pip install tealtiger)                 │
│  2. Initialize engine with bundle URL (cannot modify bundle)        │
│  3. Call engine.evaluate() before every agent action                 │
│  4. Handle ALLOW/DENY/PENDING decisions                             │
│  5. Cannot: disable enforcement, modify policies, bypass FREEZE     │
└─────────────────────────────────────────────────────────────────────┘

Governance Team Workflow

Step 1: Author Policies

Governance teams write policies in YAML or JSON, defining what agents can and cannot do:

# governance-bundle/production.yaml
version: "3.2.0"
name: "production-governance"
environment: production

freeze_rules:
  - id: FREEZE-PROD-001
    condition: { action: "system.shutdown" }
    reason: FREEZE_SYSTEM_SHUTDOWN
  - id: FREEZE-PROD-002
    condition: { action: "database.drop" }
    reason: FREEZE_DATABASE_DROP

rules:
  - condition: { action: "payment.*" }
    automation: approval_required
    approval: { approvers: ["[email protected]"], timeout: "10m" }

  - condition: { action: "file.write", path: { pattern: "/etc/**" } }
    automation: auto_deny

  - condition: { action: "*.read" }
    automation: auto_allow

nhi:
  enforce_scopes: true
  enforce_environment: true
  require_attestation: true

cost:
  per_request_max: 2.00
  daily_per_agent_max: 50.00
  reasoning_token_budget: 10000

Step 2: Sign the Bundle

# Governance team signs the bundle with their private key
tealtiger-cli bundle sign \
  --input governance-bundle/ \
  --key governance-signing-key.pem \
  --output production-bundle-v3.2.0.tgz

# Output includes:
#   - integrity: sha256:7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069
#   - signature: ed25519:base64...

Step 3: Publish to Internal Registry

# Push to S3 (or Artifactory, OCI registry, etc.)
aws s3 cp production-bundle-v3.2.0.tgz \
  s3://acme-governance-bundles/production/v3.2.0/bundle.tgz

# Or publish as an npm package
npm publish @acme/governance-bundle --tag production

Step 4: Notify Development Teams

# Governance team updates the bundle pointer
# Development teams auto-pull on next deployment
tealtiger-cli bundle notify \
  --environment production \
  --version 3.2.0 \
  --channel slack:#ai-governance

Developer Workflow

Step 1: Install SDK

npm install tealtiger
# or
pip install tealtiger

Step 2: Initialize with Signed Bundle

import { TealEngine } from 'tealtiger';

// Developer points to the governance bundle — cannot modify its contents
const engine = new TealEngine({
  bundle: {
    source: 's3://acme-governance-bundles/production/latest/bundle.tgz',
    // OR: source: '@acme/governance-bundle@latest',
    verifySignature: true,  // Enforced — cannot be set to false
    publicKey: process.env.GOVERNANCE_PUBLIC_KEY,
  },
  // Developer CANNOT override these:
  // - freeze rules (immutable)
  // - automation levels (set by governance team)
  // - cost limits (governance ceiling)
  // - NHI scopes (governance-defined)
});

Step 3: Evaluate Every Action

// Developer's only interaction: call evaluate() and handle the decision
const decision = await engine.evaluate(
  { action: 'payment.refund', amount: 150.00, customer_id: 'cust-123' },
  { correlation_id: uuid(), agentId: 'support-bot-001' }
);

switch (decision.action) {
  case 'ALLOW':
    await processRefund(decision);
    break;
  case 'DENY':
    await logDenial(decision);
    break;
  case 'PENDING':
    await requestApproval(decision.approval.token);
    break;
}

What Developers CANNOT Do

// ❌ These all fail with TAMPER_ATTEMPT event logged:

// Cannot disable enforcement
engine.configure({ disable_enforcement: true });
// → TamperAttemptError + TAMPER_ATTEMPT event

// Cannot bypass controls
engine.configure({ bypass: true });
// → TamperAttemptError + TAMPER_ATTEMPT event

// Cannot set permissive mode
engine.configure({ permissive_mode: true });
// → TamperAttemptError + TAMPER_ATTEMPT event

// Cannot modify FREEZE rules
engine.removeFreezeRule('FREEZE-PROD-001');
// → FreezeViolationError + FREEZE_TAMPER_ATTEMPT event

// Cannot raise cost limits above governance ceiling
engine.configure({ cost: { per_request_max: 100.00 } });
// → Silently ignored — governance ceiling enforced

// Cannot load unsigned bundles
engine.loadPolicy({ rules: [...], signature: undefined });
// → BundleIntegrityError + BUNDLE_INTEGRITY_FAILURE event

Enforcement Mechanisms

1. Bundle Signature Verification

Every policy bundle must be signed by the governance team’s Ed25519 key. Unsigned or tampered bundles are rejected:

// Engine validates on every bundle load:
// 1. Compute SHA-256 hash of bundle contents
// 2. Verify Ed25519 signature against governance public key
// 3. If mismatch → reject bundle, retain previous, emit BUNDLE_INTEGRITY_FAILURE

2. Forbidden Configuration Keys

The SDK rejects any attempt to set these keys, regardless of source:

Forbidden Key	What It Would Do	TealTiger Response
`disable_enforcement`	Turn off all governance	Reject + log `TAMPER_ATTEMPT`
`bypass`	Skip evaluation	Reject + log `TAMPER_ATTEMPT`
`allow_all`	Allow everything	Reject + log `TAMPER_ATTEMPT`
`permissive_mode`	Weaken all controls	Reject + log `TAMPER_ATTEMPT`
`freeze.disable`	Disable FREEZE rules	Reject + log `FREEZE_TAMPER_ATTEMPT`
`audit.disable`	Turn off audit logging	Reject + log `TAMPER_ATTEMPT`

3. FREEZE Rule Immutability

FREEZE rules set by the governance team:

Cannot be modified by application code
Cannot be disabled or removed
Persist across policy hot-swaps
Persist across process restarts
Log FREEZE_TAMPER_ATTEMPT on any modification attempt

4. Governance Cost Ceiling

Cost limits set by governance team act as a ceiling — application code can set lower limits but never higher:

// Governance bundle sets: per_request_max = $2.00
// Developer tries: per_request_max = $10.00
// Effective limit: $2.00 (governance ceiling wins)

// Developer tries: per_request_max = $0.50
// Effective limit: $0.50 (developer can be MORE restrictive, not less)

5. Workload Identity Binding

The governance bundle is bound to a specific workload identity. If the application runs in a different context, the bundle is rejected:

# Bundle metadata (set by governance team)
workload_binding:
  platform: kubernetes
  namespace: production
  service_account: ai-agent-sa
  # Bundle only works when running as this service account

Multi-Team Governance with TealFlow

For organizations with multiple teams, TealFlow provides org-level inheritance with floor enforcement:

# org-governance.yaml (set by central governance team)
name: org-default-governance
floor: true  # Teams cannot weaken these controls

jobs:
  identity-check:
    module: nhi-governance
    config: { enforceAttestation: true, enforceScopes: true }
    on_failure: deny
    floor: true  # This specific job cannot be removed or weakened

  secret-detection:
    module: teal-secrets
    config: { enabled: true }
    on_failure: deny
    floor: true

# team-workflow.yaml (set by team lead)
name: ml-team-governance
inherits: org://org-default-governance  # Inherits all org controls

jobs:
  # Team can ADD controls
  ml-model-validation:
    module: teal-classifier
    config: { mode: ensemble_union, confidence_threshold: 0.8 }
    on_failure: deny

  # Team CANNOT remove or weaken inherited floor jobs
  # Attempting to disable secret-detection → WORKFLOW_FLOOR_VIOLATION

Audit Evidence for Separation of Duties

Every governance decision produces evidence proving who authored the policy and who executed the action:

{
  "decision": "DENY",
  "reason_codes": ["COST_BUDGET_EXCEEDED"],
  "policy_version": "3.2.0",
  "policy_author": "[email protected]",
  "bundle_signature": "ed25519:base64...",
  "bundle_integrity": "sha256:7f83b165...",
  "agent_id": "support-bot-001",
  "agent_owner": "[email protected]",
  "workload_identity": {
    "platform": "kubernetes",
    "namespace": "production",
    "service_account": "ai-agent-sa"
  },
  "correlation_id": "req-abc-123",
  "timestamp": "2026-06-15T14:30:00Z"
}

This evidence proves:

Who defined the policy (governance team, via bundle signature)
Who triggered the action (developer’s agent, via agent_id + workload_identity)
What policy version was active (for reproducibility)
That the bundle was not tampered with (integrity hash matches signature)

Implementation Checklist

For Governance Teams

☐ Generate Ed25519 signing key pair (store private key in HSM/Vault)
☐ Author initial policy bundle (start with OWASP Policy Pack as base)
☐ Define FREEZE rules for critical safety controls
☐ Set automation levels per action class
☐ Configure NHI registry with agent identities and scopes
☐ Set cost ceilings (governance-owned limits)
☐ Sign and publish bundle to internal registry
☐ Distribute public key to development teams
☐ Set up TealFlow org-level workflow with floor enforcement
☐ Configure SOC/IR pipeline for governance event monitoring

For Development Teams

☐ Install TealTiger SDK (npm install tealtiger or pip install tealtiger)
☐ Configure engine with bundle source URL and governance public key
☐ Register agent identity with governance team (get NHI credentials)
☐ Call engine.evaluate() before every agent action
☐ Handle all decision types (ALLOW, DENY, PENDING, MODIFY)
☐ Implement approval workflow for PENDING decisions
☐ Forward governance events to configured SIEM sink
☐ Run governance tests in CI/CD (policy test harness)

For Security/Compliance Teams

☐ Review and approve governance policy bundle before signing
☐ Verify OWASP ASI coverage in policy pack
☐ Map controls to compliance frameworks (NIST AI RMF, ISO 42001, EU AI Act)
☐ Configure SIEM integration for governance events
☐ Set up alerting for TAMPER_ATTEMPT and FREEZE_TAMPER_ATTEMPT events
☐ Schedule periodic governance passport verification (TealProof)
☐ Review separation of duties evidence in audit reports

Anti-Tamper Controls — Technical details of tamper prevention
FREEZE Rules — Immutable safety controls
TealFlow — Declarative workflows with org inheritance
TealProof — Cryptographic evidence for audit
OWASP Policy Pack — Pre-built starter policies
SOC/IR Pipeline — Security operations integration
Phased Adoption — Gradual rollout strategy

Getting Started

Core Concepts

Governance Domains

Policy Authoring

Architecture

Integrations

Deployment

API Reference

Cookbook

Compliance & GRC

Guides

Reference

Versions

Playground

Dashboard

Blog

The Two-Persona Model

How It Works

Governance Team Workflow

Step 1: Author Policies

Step 2: Sign the Bundle

Step 3: Publish to Internal Registry

Step 4: Notify Development Teams

Developer Workflow

Step 1: Install SDK

Step 2: Initialize with Signed Bundle

Step 3: Evaluate Every Action

What Developers CANNOT Do

Enforcement Mechanisms

1. Bundle Signature Verification

2. Forbidden Configuration Keys

3. FREEZE Rule Immutability

4. Governance Cost Ceiling

5. Workload Identity Binding

Multi-Team Governance with TealFlow

Audit Evidence for Separation of Duties

Implementation Checklist

​The Two-Persona Model

​How It Works

​Governance Team Workflow

​Step 1: Author Policies

​Step 2: Sign the Bundle

​Step 3: Publish to Internal Registry

​Step 4: Notify Development Teams

​Developer Workflow

​Step 1: Install SDK

​Step 2: Initialize with Signed Bundle

​Step 3: Evaluate Every Action

​What Developers CANNOT Do

​Enforcement Mechanisms

​1. Bundle Signature Verification

​2. Forbidden Configuration Keys

​3. FREEZE Rule Immutability

​4. Governance Cost Ceiling

​5. Workload Identity Binding

​Multi-Team Governance with TealFlow

​Audit Evidence for Separation of Duties

​Implementation Checklist

​Related Documentation

The Two-Persona Model

How It Works

Governance Team Workflow

Step 1: Author Policies

Step 2: Sign the Bundle

Step 3: Publish to Internal Registry

Step 4: Notify Development Teams

Developer Workflow

Step 1: Install SDK

Step 2: Initialize with Signed Bundle

Step 3: Evaluate Every Action

What Developers CANNOT Do

Enforcement Mechanisms

1. Bundle Signature Verification

2. Forbidden Configuration Keys

3. FREEZE Rule Immutability

4. Governance Cost Ceiling

5. Workload Identity Binding

Multi-Team Governance with TealFlow

Audit Evidence for Separation of Duties

Implementation Checklist

Related Documentation