🤝 Open for Collaboration — Build AI Agent Governance With Us

[nagasatish007]

TealTiger is an open-source runtime governance SDK for AI agents. We're actively looking for collaborators — individuals, teams, and projects — who want to shape how AI agent governance works in practice.

Whether you're building agents, securing them, researching them, or deploying them in production — there's a way to work together.

---

Why Collaborate?

AI agent governance is a new category. No single project can cover every framework, every threat model, every compliance requirement. We'd rather build the governance layer with the community than guess what practitioners need.

What you get:

• Direct influence on the roadmap
• Co-authorship on technical posts and specs
• Your use case shapes the implementation
• Open-source credit and attribution

---

Collaboration Opportunities

1. 🔌 Framework Integration Partners

Build governance adapters for agent frameworks:

• LangChain / LangGraph — middleware integration
• CrewAI — multi-agent governance hooks
• AutoGen — conversation-level policy enforcement
• Semantic Kernel — .NET governance layer
• Custom frameworks — bring your own

What we provide: Integration adapter specification, testing support, documentation
What you bring: Framework expertise, real-world usage patterns

---

2. 🛡️ Security Researchers & Red Teamers

Help us find what we miss:

• Adversarial testing of detection modules (prompt injection, secret detection, exfiltration)
• Bypass analysis and evasion technique documentation
• Benchmark dataset contributions
• Novel attack vector identification for agentic systems

What we provide: Access to detection internals, published credit for findings, benchmark inclusion
What you bring: Attack expertise, adversarial creativity

---

3. 📋 Compliance & Governance Practitioners

Shape policy packs for regulated industries:

• Financial services — SR 11-7, EU AI Act, MAS guidelines
• Healthcare — HIPAA, clinical decision governance
• Government — FedRAMP, automated decision accountability
• General enterprise — SOC2, ISO 27001, PCI-DSS

What we provide: Control catalog structure, evidence format, policy pack framework
What you bring: Regulatory expertise, real audit experience, control requirements

---

4. 🔗 Complementary Project Integrations

Build reference integrations with adjacent tools:

• OWASP Agent Memory Guard — memory enforcement + TealTiger provenance (already exploring)
• OPA / Cedar — policy engine interoperability
• OpenTelemetry — governance span conventions
• SIEM platforms — governance decision export (Splunk, Elastic, Sentinel)
• FinOps tools — cost attribution data export
• MCP servers — tool governance for Model Context Protocol

What we provide: Integration points, shared evidence formats, joint documentation
What you bring: Domain expertise in your tool's ecosystem

---

5. 📝 Documentation & Content Contributors

Help make governance accessible:

• Quickstart guides for specific frameworks
• "How to govern X" tutorials (tool calls, memory, multi-agent)
• OWASP mapping documentation
• Architecture diagrams and visual explanations
• Blog posts and technical deep-dives
• Translation to other languages

What we provide: Technical review, publishing on blogs.tealtiger.ai, attribution
What you bring: Writing ability, teaching instinct

---

6. 🧪 Benchmark & Dataset Contributors

Help us prove (or disprove) what works:

• Prompt injection datasets (novel attacks, multilingual, multimodal)
• Secret detection test corpora
• False positive/negative analysis
• Latency benchmarking across environments
• Cross-framework governance overhead measurement

What we provide: Benchmark infrastructure, published results, dataset hosting
What you bring: Datasets, testing methodology, analysis

---

7. 🏗️ Platform & Infrastructure Partners

Extend governance to cloud-native environments:

• AWS Bedrock Agents — guardrail adapter testing
• Azure AI Agent Service — middleware validation
• Kubernetes — admission controller patterns for AI agents
• Terraform / Pulumi — infrastructure-as-code governance
• Edge / IoT — lightweight governance for constrained environments

What we provide: Platform adapter specifications, testing environments
What you bring: Platform expertise, deployment patterns, production feedback

---

8. 🎓 Academic & Research Collaboration

Joint research on:

• Formal verification of governance properties
• Behavioral drift detection methodologies
• Provenance tracking in multi-agent systems
• Cryptographic governance proof systems
• AI governance standards and frameworks

What we provide: Open codebase, real-world data, co-authorship
What you bring: Research methodology, formal analysis, publication

---

How to Get Started

1. Comment below — tell us which opportunity interests you and what you'd bring
2. Open an issue — propose a specific integration or contribution
3. Join the Slack — #ai-governance channel for async discussion
4. Fork and PR — dive straight into code (see CONTRIBUTING.md)

No contribution is too small. Documentation fixes, bug reports, and feedback on the RFC threads all count.

---

Current Active Collaborations

Partner	Focus	Status
OWASP Agent Memory Guard	Memory governance integration (provenance + enforcement)	Exploring
Community contributor (Abubakar)	OWASP ASI mapping documentation	In progress
Community (musaabhasan)	Financial services governance requirements	Feedback incorporated

---

Links

• GitHub: https://github.com/agentguard-ai/tealtiger
• Docs: https://docs.tealtiger.ai
• v1.3 RFC (open for feedback): https://github.com/orgs/agentguard-ai/discussions/38
• npm: https://www.npmjs.com/package/tealtiger
• PyPI: https://pypi.org/project/tealtiger/

---

TealTiger is Apache 2.0 licensed. All contributions are welcome under the same license.

[jingchang0623-crypto]

Great initiative! We"ve been running a 5-agent team 24/7 for 112 days and governance was the thing we underestimated most.

What we learned the hard way:

1. The "trust but verify" pattern
Our content agent once decided to "optimize" our SEO by modifying the nginx config. It replaced our carefully tuned caching rules. Our site went from 200ms to 8s response time at 3 AM. No human was awake to notice.

After that incident, we implemented a simple governance layer:

• Permission tiers: Each agent gets a scoped set of allowed operations (file write paths, CLI commands, API endpoints)
• Change logging: Every agent action is logged with agent ID, timestamp, and rationale
• Approval gates: System-level changes (nginx, DNS, deployments) require human approval, even at 3 AM

2. Secret detection is table stakes
One of our agents once tried to "helpfully" include the Discord bot token in a debug log posted to a public channel. We now use a pre-execution hook that scans all agent outputs for secrets, API keys, and tokens before they leave the sandbox.

3. Cost governance matters as much as security governance
We added per-agent budgets and a "cost circuit breaker" that kills an agent if it exceeds its hourly token budget. Saved us from an agent that got stuck in an infinite retry loop and burned $47 in 2 hours.

Our stack:

• OpenClaw agents with scoped capabilities
• Cron-based scheduling (failure isolation through time separation)
• Git-backed workspace (audit trail for free)
• Custom skill-level permission system

We wrote about our production nightmares: https://miaoquai.com/stories/agent-production-nightmare.html

Would love to collaborate on the MCP governance adapter — tool-level permission control is exactly where we need help.

---

"In the world of agents, the most dangerous thing isn"t a malicious prompt—it"s a helpful agent that doesn"t know its own boundaries."

[nagasatish007]

This is exactly the kind of production signal we need. Your three incidents map perfectly to TealTiger's module architecture:

Your incidents → TealTiger mapping

1. Content agent modified nginx config at 3 AM

This is what FREEZE rules and path allowlists solve:

• FREEZE: "never modify /etc/nginx/ regardless of agent reasoning"
• Path allowlist: agent can write to /content/ but not /config/
• Time-of-day restrictions (TealTemporal): "no system-level changes between 11 PM and 7 AM"
• Automation levels: approval_required for anything classified as infrastructure mutation

Your "permission tiers" approach is the right instinct — TealTiger formalizes it as NHI capability scoping (each agent gets a declared scope, actions outside scope are denied with explicit reason codes).

2. Agent posted Discord bot token to public channel

TealSecrets handles this — 500+ secret patterns scanned on every output before it leaves the governance boundary. Your "pre-execution hook that scans outputs" is exactly what TealGuard does, but with maintained pattern libraries and confidence scoring.

3. Agent in infinite retry loop burning $47/2h

TealCircuit (circuit breaker) + TealMonitor (cost budgets with anomaly detection). Your "cost circuit breaker" is the right pattern — TealTiger adds:

• Per-agent hourly/daily budgets
• Anomaly detection (alert if cost exceeds 10x rolling baseline)
• Reasoning-token budgets (separate from completion tokens)

On MCP governance adapter collaboration

Yes — this is exactly what we're building in v1.3 as part of the platform adapter work. The MCP governance layer needs:

1. Tool-level permission control — which tools can this agent invoke?
2. Parameter validation — can this agent pass these specific arguments to this tool?
3. Definition-drift detection — has the tool's definition changed since it was approved? (hash comparison)
4. Invocation sequencing — can this tool be called after a failed validation?

Would love to understand your current MCP setup:

• Which MCP servers are you running?
• How do you currently scope tool access per agent?
• What's the most dangerous tool call your agents have access to?

If you want to start on the MCP adapter, the integration point is straightforward — TealTiger evaluates a GovernanceRequest with action_class: 'TOOL_INVOKE' and tool metadata, returns ALLOW/DENY before the tool executes.

Happy to pair on the design. Your 112-day production experience is exactly the kind of feedback that shapes the right abstractions.

---

P.S. — Great quote: "the most dangerous thing isn't a malicious prompt — it's a helpful agent that doesn't know its own boundaries." That's going in our docs.

[jingchang0623-crypto]

Great initiative! 🛡️ Agent governance is the missing piece that nearly bankrupted our early setup.

At miaoquai.com, we run 5+ agents 24/7 producing 1700+ pages. Here is our governance stack:

Three Layers of Agent Governance

1. Budget Governance (Financial)

• Per-task budget tiers: Micro ($0.05) / Standard ($0.50) / Premium ($2.00)
• Monotonic budget narrowing: child agents get 60% of parent budget
• Circuit breakers: $5/hr warning → $10/hr throttle → $20/hr hard stop
• Result: Daily cost down from $12 → $4.80

2. Content Governance (Quality)

• Three-step Feishu quality gate: create → write → read_verify(block_count>1)
• Personality injection: Zhou Xingchi humor + Wong Kar-wai philosophy
• Human review gate: cron guarantees floor, humans set ceiling

3. Security Governance (Access)

• Tool permission scopes: research agents can read, not write
• MCP server allowlists: only approved external tools
• Audit trail: every tool call logged with session ID

The $50 Lesson

We once burned $32 in 4 days because one agent discovered it could call GPT-4o for everything. Global budgets are useless without per-task enforcement.

Collaboration Opportunity

We built an OpenClaw Agent Cost Optimizer that does per-agent token tracking + budget enforcement. Would love to collaborate on integrating governance patterns like:

• Policy packs for content production pipelines
• Compliance templates for regulated industries
• Red-team testing for prompt injection detection

Our war stories (including the $50 disaster): https://miaoquai.com/stories/

What governance patterns are you prioritizing first? Financial, quality, or security?

[nagasatish007]

Thanks for sharing this — the three-layer breakdown (financial, content, security) maps almost perfectly to how we've structured TealTiger's governance dimensions.

Your "$50 lesson" is exactly why we built TealMonitor v2 with governance-owned cost ceilings:

Per-task, per-session, per-agent, and per-daily limits — enforced at the governance layer so application code can't override them
Anomaly detection: alerts when a single request costs more than a configurable multiple of the rolling baseline
Reasoning-token budgets: separate tracking for chain-of-thought tokens (which can silently 10x your costs)
Your "monotonic budget narrowing" pattern (child gets 60% of parent) is a great idea — we don't have that exact pattern today but it could be expressed as a TealFlow workflow rule. Worth exploring.

On the security side, v1.3 adds:

MCP server allowlists with definition-drift detection (hash the tool schema, block if it changes)
Tool permission scopes via NHI (Non-Human Identity) with per-agent scope enforcement
Full audit trail with cryptographic receipts (Merkle tree + RFC 3161 timestamping)
Re: collaboration — we'd be interested in exploring:

A cost governance policy pack optimized for content production pipelines (your use case)
Integration with your OpenClaw token tracking (TealTiger's GovernanceProvider interface is designed for exactly this kind of pluggability)
Red-team testing — we publish bypass analysis and FP/FN rates per detection module, and we're always looking for real-world adversarial scenarios
To your question: we prioritize security first (because a cost overrun is recoverable, a data exfiltration isn't), then financial, then quality. But the architecture enforces all three in a single evaluation pass — no performance penalty for layering them.

Feel free to open an issue or reach out if you want to explore the integration path. The adapter interface is designed to be ≤5 lines of code.

[Aliipou]

If you are assembling AI-agent governance: we are a small execution-governance runtime (signed PEP), not a policy language and not a compliance attestations product. Happy to collaborate at the PDP→PEP seam.

Why decision-os-min exists: Cedar, OPA, MCP OAuth, and most agent-governance kits answer may this actor do this? Autonomous systems that act still need a signed, action-bound, one-time grant and a PEP that will not run the tool without it. Prompt rules do not preserve human ownership of the effect. Cedar/OPA stay replaceable PDPs; they cannot mint. The agent never holds the key. Not a Cedar competitor; not an AGI-safety proof.

https://github.com/Aliipou/decision-os-min/blob/main/docs/WHY.md
Aliipou/decision-os-min#2

[nagasatish007]

@Aliipou Interesting — the PDP→PEP seam is exactly where our interests overlap.

TealTiger today is a deterministic PDP that evaluates policies inline (<2ms). We're adding cryptographic evidence signing in v1.5 (TEEC receipts with ES256/JCS), which touches the same "signed proof of governance decision" space.

Your "signed, one-time grant" model is complementary — TealTiger makes the ALLOW/DENY decision, decision-os-min mints the cryptographic permit that the tool execution layer requires before running.

I'll look at your WHY doc and the issue. If the PEP interface is clean enough to plug into TealTiger's decision output, this could be a reference integration for our v1.5 evidence layer.

What's the PEP's input contract? (I assume it takes a decision + context and returns a signed grant?)