Skip to main content
Version: v1.1.0
This page explains what TealTiger is NOT designed to do.

​
Non-Goals

TealTiger is focused on AI governance. To stay focused, we intentionally avoid solving problems that other tools handle better. This page explains what we don’t do and why.

​
Why Non-Goals Matter

Defining what we DON’T do is just as important as defining what we DO:
  • Prevents misuse - Helps you use TealTiger correctly
  • Avoids overlap - Works with your existing tools, doesn’t replace them
  • Keeps us focused - We do one thing well instead of many things poorly
  • Sets expectations - You know what to expect (and what not to expect)

​
What TealTiger Is NOT

​
1. NOT a Model Hosting Platform

We don’t:
  • Host LLMs or run inference
  • Replace OpenAI, Anthropic, Bedrock, or other providers
  • Manage GPUs, batching, or model serving
Why: Model hosting is a solved problem. We focus on governing what those models do, not running them. Use instead:
  • OpenAI API
  • Anthropic Claude
  • AWS Bedrock
  • Azure OpenAI
  • Self-hosted models
// ✅ Correct: TealTiger governs, provider hosts
const decision = engine.evaluate(context);
if (decision.action === 'allow') {
  const response = await openai.chat.completions.create({...});
}

// ❌ Wrong: TealTiger doesn't host models
const response = await tealTiger.runModel({...});  // This doesn't exist

​
2. NOT a Prompt Engineering Tool

We don’t:
  • Generate or optimize prompts
  • Suggest better prompt templates
  • Automatically rewrite prompts
Why: Prompt design is your domain expertise. We only evaluate and govern what you send. Use instead:
  • LangChain for prompt templates
  • Your own prompt engineering
  • Prompt optimization tools
// ✅ Correct: You design prompts, TealTiger governs them
const prompt = buildPrompt(userInput);  // Your prompt engineering
const decision = engine.evaluate({ input: prompt });

// ❌ Wrong: TealTiger doesn't generate prompts
const prompt = tealTiger.optimizePrompt(userInput);  // This doesn't exist

​
3. NOT an Identity or Secrets Manager

We don’t:
  • Authenticate users
  • Store API keys or credentials
  • Replace IAM systems
  • Manage secrets or encryption keys
Why: Identity and secrets are critical infrastructure. Use battle-tested tools, not governance SDKs. Use instead:
  • AWS IAM, Azure AD, GCP IAM
  • AWS KMS, HashiCorp Vault
  • Your existing auth system
// ✅ Correct: Pass identity context, don't manage it
const decision = engine.evaluate({
  action: 'tool.execute',
  context: {
    user_id: getCurrentUser().id,  // From your auth system
    api_key: process.env.OPENAI_KEY  // From your secrets manager
  }
});

// ❌ Wrong: TealTiger doesn't manage auth
await tealTiger.authenticateUser(username, password);  // This doesn't exist

​
4. NOT a SIEM or Analytics Platform

We don’t:
  • Provide dashboards for log analysis
  • Correlate events across infrastructure
  • Replace SIEM, XDR, or SOAR platforms
  • Store logs long-term
Why: We emit structured audit events. Your existing observability stack handles the rest. Use instead:
  • Datadog, Splunk, Elastic
  • Your SIEM
  • Grafana, Kibana
// ✅ Correct: Forward audit events to your SIEM
const engine = new TealEngine({
  audit: {
    outputs: [
      {
        type: 'custom',
        handler: (event) => sendToDatadog(event)
      }
    ]
  }
});

// ❌ Wrong: TealTiger doesn't provide dashboards
await tealTiger.viewDashboard();  // This doesn't exist

​
5. NOT a Data Loss Prevention (DLP) Engine

We don’t:
  • Discover sensitive data at rest
  • Classify enterprise datasets
  • Scan file systems or databases
  • Replace enterprise DLP products
Why: We focus on AI interaction governance, not enterprise-wide data discovery. Use instead:
  • Enterprise DLP tools
  • Cloud provider DLP services
  • Data classification tools
// ✅ Correct: Detect PII in AI interactions
const decision = engine.evaluate({
  action: 'llm.call',
  input: 'My email is john@example.com'
});
// decision.action === 'redact' (PII detected in prompt)

// ❌ Wrong: TealTiger doesn't scan your database
await tealTiger.scanDatabase();  // This doesn't exist

​
6. NOT an Incident Response System

We don’t:
  • Automatically quarantine agents
  • Trigger incident response playbooks
  • Perform kill-switch actions
  • Replace SOC workflows
Why: Policy enforcement is deterministic and scoped. Incident response requires broader context and human judgment. Use instead:
  • PagerDuty, Opsgenie
  • Your SOC workflows
  • Incident management tools
// ✅ Correct: Block risky actions, alert your team
const decision = engine.evaluate(context);
if (decision.risk_score > 80) {
  await alertSecurityTeam(decision);  // Your incident response
}

// ❌ Wrong: TealTiger doesn't manage incidents
await tealTiger.quarantineAgent();  // This doesn't exist

​
7. NOT an AI Ethics Framework

We don’t:
  • Evaluate model bias or fairness
  • Certify models for ethical compliance
  • Perform human-value alignment assessments
  • Make moral judgments
Why: We enforce technical governance (cost, security, reliability), not ethical judgments. Use instead:
  • AI ethics frameworks
  • Fairness evaluation tools
  • Human review processes
// ✅ Correct: Enforce technical policies
const decision = engine.evaluate({
  action: 'llm.call',
  context: { cost_limit: 10.00 }
});

// ❌ Wrong: TealTiger doesn't evaluate ethics
const ethicsScore = tealTiger.evaluateEthics(model);  // This doesn't exist

​
8. NOT a FinOps Platform

We don’t:
  • Forecast budgets
  • Optimize vendor pricing
  • Perform chargeback or showback
  • Replace FinOps tooling
Why: We track and limit AI spending in real-time. Financial planning is a different problem. Use instead:
  • CloudHealth, Cloudability
  • Your FinOps tools
  • Vendor cost management
// ✅ Correct: Enforce cost limits in real-time
const decision = engine.evaluate({
  action: 'llm.call',
  estimated_cost: 15.00,
  context: { budget_limit: 10.00 }
});
// decision.action === 'deny' (over budget)

// ❌ Wrong: TealTiger doesn't forecast budgets
const forecast = tealTiger.forecastCosts();  // This doesn't exist

​
9. NOT a UI-First Product

We don’t:
  • Require dashboards for core functionality
  • Enforce UI-based configuration
  • Provide hosted policy management (in v1.1.0)
Why: We’re SDK-first. Developers should be able to use TealTiger entirely from code. Use instead:
  • Your code editor
  • Your CI/CD pipelines
  • Infrastructure as code
// ✅ Correct: Configure in code
const engine = new TealEngine({
  policies: {
    cost: { budget_limit: { perUser: { daily: 10.00 } } }
  }
});

// ❌ Wrong: TealTiger doesn't require a UI
// (No UI required - that's the point!)
Note: A SaaS platform with UI is planned for future versions, but the SDK will always remain open source and fully functional without it.

​
10. NOT a Black Box

We don’t:
  • Use hidden heuristics
  • Make probabilistic decisions
  • Apply undocumented behavior
  • Hide why policies pass or fail
Why: Governance requires transparency. Every decision is deterministic and explainable. 
// ✅ Correct: Every decision is explainable
const decision = engine.evaluate(context);
console.log(decision.reason_code);  // "COST.BUDGET.EXCEEDED"
console.log(decision.metadata);     // { budget_limit: 10.00, current_spend: 12.50 }

// ❌ Wrong: TealTiger never hides its logic
// (All decisions are transparent and deterministic)

​
The Pattern: We Govern, You Own

TealTiger follows a consistent pattern:
ResponsibilityWho Owns It
Model hostingYou (OpenAI, Anthropic, etc.)
Identity managementYou (IAM, auth system)
Secrets handlingYou (KMS, Vault)
Log analyticsYou (SIEM, Datadog)
Incident responseYou (PagerDuty, SOC)
Policy governanceTealTiger
Cost trackingTealTiger
Security guardrailsTealTiger
Audit loggingTealTiger
We do one thing well and integrate with everything else.

​
Why This Matters

By staying focused, TealTiger: ✅ Integrates easily - Works with your existing stack
✅ Avoids lock-in - You own your infrastructure
✅ Stays simple - One SDK, one purpose
✅ Evolves safely - Focused scope means stable behavior If we tried to do everything, we’d do nothing well.

​
What About Future Versions?

Some non-goals may evolve: v1.2.x (Q3 2026):
  • Multi-agent coordination
  • Workflow orchestration
  • Advanced cost allocation
v1.3.x (Q4 2026):
  • Adaptive policies
  • Learning from decisions
  • Advanced analytics
v2.0.0 (2027):
  • SaaS platform with UI
  • Hosted policy management
  • Team collaboration
But TealTiger will never become a monolithic AI platform. We’ll always focus on governance and integrate with your stack.

​
Summary

TealTiger is:
  • ✅ AI governance (cost, security, reliability)
  • ✅ Policy enforcement
  • ✅ Audit logging
  • ✅ Developer-friendly SDK
TealTiger is NOT:
  • ❌ Model hosting
  • ❌ Identity management
  • ❌ SIEM or analytics
  • ❌ FinOps platform
  • ❌ Incident response
  • ❌ Ethics framework
We do one thing well and let you own the rest.

Goals

What TealTiger is designed to achieve

Anti-Patterns

Common mistakes to avoid

Best Practices

How to use TealTiger effectively

v1.1.0 Scope

What’s included in this version