CrewAI Integration - TealTiger Docs

Integrate TealTiger with CrewAI to add policy enforcement and governance to your multi-agent systems.

Why integrate TealTiger with CrewAI?

CrewAI enables powerful multi-agent collaboration, but lacks built-in governance. TealTiger adds:

Agent-level policies - Control what each agent can do
Cross-agent coordination - Track decisions across the crew
Cost attribution - Know which agent spent what
Audit trails - Complete visibility into multi-agent workflows

Quick start

Install both packages:

pip install tealtiger crewai

Wrap your CrewAI agents with TealTiger:

from tealtiger import TealEngine, PolicyMode
from crewai import Agent, Task, Crew

# Initialize TealTiger
engine = TealEngine({
    "policies": {
        "tools": {
            "web_search": {"allowed": True},
            "file_write": {"allowed": False}
        },
        "budget": {
            "maxCostPerAgent": 10.00,
            "maxCostPerCrew": 50.00
        }
    }
})

# Create agents with governance
researcher = engine.wrap_agent(Agent(
    role='Researcher',
    goal='Research AI trends',
    tools=[web_search_tool]
))

writer = engine.wrap_agent(Agent(
    role='Writer',
    goal='Write blog posts',
    tools=[write_tool]
))

# Create crew
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task]
)

# Run with governance
result = crew.kickoff()

Integration patterns

Pattern 1: Agent wrapping (recommended)

Wrap each agent to add governance:

from tealtiger import TealEngine
from crewai import Agent

engine = TealEngine({
    "policies": {
        "tools": {
            "researcher_tools": {"allowed": True},
            "writer_tools": {"allowed": True},
            "admin_tools": {"allowed": False}
        }
    }
})

# Wrap agents individually
researcher = engine.wrap_agent(Agent(
    role='Researcher',
    goal='Research topics',
    tools=[search_tool, scrape_tool]
))

writer = engine.wrap_agent(Agent(
    role='Writer',
    goal='Write content',
    tools=[write_tool, edit_tool]
))

Pros:

Per-agent policies
Clear cost attribution
Independent governance

Cons:

Need to wrap each agent

Pattern 2: Crew-level governance

Apply policies at the crew level:

# Wrap the entire crew
crew = engine.wrap_crew(Crew(
    agents=[researcher, writer],
    tasks=[task1, task2]
))

# All agents inherit crew policies
result = crew.kickoff()

Pros:

Single integration point
Consistent policies across agents

Cons:

Less granular control

Pattern 3: Tool-level interception

Govern specific tools used by agents:

from crewai_tools import BaseTool

class GovernedTool(BaseTool):
    def __init__(self, engine: TealEngine, base_tool: BaseTool):
        self.engine = engine
        self.base_tool = base_tool
    
    def _run(self, *args, **kwargs):
        # Check policy
        decision = self.engine.evaluate({
            "action": "tool.execute",
            "tool": self.base_tool.name,
            "arguments": kwargs
        })
        
        if decision["action"] == "DENY":
            raise Exception(f"Tool blocked: {decision['reason_codes']}")
        
        # Execute tool
        return self.base_tool._run(*args, **kwargs)

Pros:

Fine-grained control
Can govern third-party tools

Cons:

More code to write

Complete example: Multi-agent research crew

Here’s a complete example of a CrewAI research crew with TealTiger governance:

from tealtiger import TealEngine, PolicyMode
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool, FileWriterTool

# 1. Initialize TealTiger with agent-specific policies
engine = TealEngine({
    "policies": {
        # Agent-specific tool access
        "agents": {
            "researcher": {
                "tools": {
                    "web_search": {"allowed": True},
                    "file_read": {"allowed": True},
                    "file_write": {"allowed": False}
                },
                "budget": {
                    "maxCostPerTask": 5.00
                }
            },
            "writer": {
                "tools": {
                    "file_write": {"allowed": True},
                    "file_read": {"allowed": True},
                    "web_search": {"allowed": False}
                },
                "budget": {
                    "maxCostPerTask": 3.00
                }
            },
            "editor": {
                "tools": {
                    "file_write": {"allowed": True},
                    "file_read": {"allowed": True}
                },
                "budget": {
                    "maxCostPerTask": 2.00
                }
            }
        },
        
        # Crew-level policies
        "crew": {
            "maxCostPerRun": 50.00,
            "maxDuration": 300,  # 5 minutes
            "requireApprovalFor": ["file_delete", "api_call"]
        },
        
        # Security policies
        "security": {
            "detectPII": True,
            "redactPII": True,
            "blockPromptInjection": True
        }
    },
    
    # Audit configuration
    "audit": {
        "enabled": True,
        "outputs": ["console", "file"],
        "trackAgentActions": True,
        "correlateCrewRuns": True
    },
    
    # Start in MONITOR mode
    "mode": {
        "defaultMode": PolicyMode.MONITOR
    }
})

# 2. Create tools
search_tool = SerperDevTool()
file_tool = FileWriterTool()

# 3. Create agents with governance
researcher = engine.wrap_agent(Agent(
    role='Senior Research Analyst',
    goal='Research and analyze AI trends',
    backstory='Expert at finding and analyzing information',
    tools=[search_tool],
    verbose=True
), agent_id='researcher')

writer = engine.wrap_agent(Agent(
    role='Content Writer',
    goal='Write engaging blog posts',
    backstory='Skilled writer with SEO expertise',
    tools=[file_tool],
    verbose=True
), agent_id='writer')

editor = engine.wrap_agent(Agent(
    role='Editor',
    goal='Review and improve content',
    backstory='Detail-oriented editor',
    tools=[file_tool],
    verbose=True
), agent_id='editor')

# 4. Create tasks
research_task = Task(
    description='Research the latest AI trends in 2026',
    agent=researcher,
    expected_output='Detailed research report'
)

writing_task = Task(
    description='Write a blog post based on the research',
    agent=writer,
    expected_output='Blog post draft'
)

editing_task = Task(
    description='Edit and finalize the blog post',
    agent=editor,
    expected_output='Final blog post'
)

# 5. Create crew with governance
crew = engine.wrap_crew(Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.sequential,
    verbose=True
))

# 6. Run the crew
try:
    result = crew.kickoff()
    print("Crew completed successfully!")
    print(result)
    
    # Get cost metrics per agent
    metrics = engine.get_crew_metrics()
    print(f"\nCost breakdown:")
    print(f"  Researcher: ${metrics['agents']['researcher']['cost']:.2f}")
    print(f"  Writer: ${metrics['agents']['writer']['cost']:.2f}")
    print(f"  Editor: ${metrics['agents']['editor']['cost']:.2f}")
    print(f"  Total: ${metrics['total_cost']:.2f}")
    
except Exception as error:
    print(f"Crew failed: {str(error)}")

What gets governed?

TealTiger governs these CrewAI components:

Agent actions

Every agent action is evaluated:

Tool usage
LLM calls
Inter-agent communication
Task execution

Crew coordination

Crew-level governance:

Total crew cost
Execution duration
Agent collaboration patterns
Resource allocation

Tool executions

Every tool call is checked:

Tool allowlists per agent
Approval requirements
Cost attribution
Audit logging

Policy examples for CrewAI

Example 1: Role-based access

Different policies for different agent roles:

policies: {
    "agents": {
        "researcher": {
            "tools": {
                "web_search": {"allowed": True},
                "database_read": {"allowed": True},
                "database_write": {"allowed": False}
            }
        },
        "writer": {
            "tools": {
                "file_write": {"allowed": True},
                "web_search": {"allowed": False},
                "database_read": {"allowed": False}
            }
        },
        "admin": {
            "tools": {
                "database_write": {"allowed": True},
                "file_delete": {
                    "allowed": True,
                    "requireApproval": True
                }
            }
        }
    }
}

Example 2: Cost control per agent

Limit spending for each agent:

policies: {
    "agents": {
        "researcher": {
            "budget": {
                "maxCostPerTask": 5.00,
                "maxTokens": 4000
            }
        },
        "writer": {
            "budget": {
                "maxCostPerTask": 3.00,
                "maxTokens": 2000
            }
        }
    },
    "crew": {
        "maxCostPerRun": 50.00,
        "maxDuration": 600  # 10 minutes
    }
}

Example 3: Approval workflows

Require approval for sensitive operations:

policies: {
    "crew": {
        "requireApprovalFor": [
            "database_write",
            "file_delete",
            "api_call_external",
            "email_send"
        ],
        "approvers": ["admin", "supervisor"]
    }
}

Monitoring multi-agent workflows

View crew metrics

metrics = engine.get_crew_metrics()

print({
    "total_cost": metrics["total_cost"],
    "total_duration": metrics["duration"],
    "agents": {
        "researcher": {
            "cost": metrics["agents"]["researcher"]["cost"],
            "tasks_completed": metrics["agents"]["researcher"]["tasks"]
        },
        "writer": {
            "cost": metrics["agents"]["writer"]["cost"],
            "tasks_completed": metrics["agents"]["writer"]["tasks"]
        }
    }
})

View agent audit logs

logs = engine.get_agent_logs(agent_id="researcher")

for log in logs:
    print(f"{log['timestamp']}: {log['action']} - {log['decision']}")

Track crew execution

# Get crew execution trace
trace = engine.get_crew_trace(crew_id="crew-123")

print(f"Crew: {trace['crew_id']}")
print(f"Duration: {trace['duration']}s")
print(f"Total cost: ${trace['total_cost']:.2f}")
print(f"\nAgent timeline:")
for event in trace['timeline']:
    print(f"  {event['timestamp']}: {event['agent']} - {event['action']}")

Best practices

Wrap agents individually - Better cost attribution and control
Set per-agent budgets - Prevent any single agent from overspending
Use crew-level limits - Cap total crew cost and duration
Enable audit logging - Track multi-agent interactions
Test in MONITOR mode - Validate policies before enforcing
Use correlation IDs - Link related agent actions

Common issues

Issue 1: Agents bypassing policies

Problem: Some agent actions aren’t being governed Solution: Ensure all agents are wrapped:

# ❌ Bad: Only some agents wrapped
researcher = engine.wrap_agent(Agent(...))
writer = Agent(...)  # Not wrapped!

# ✅ Good: All agents wrapped
researcher = engine.wrap_agent(Agent(...))
writer = engine.wrap_agent(Agent(...))

Issue 2: Cost attribution unclear

Problem: Can’t tell which agent spent what Solution: Use agent IDs:

researcher = engine.wrap_agent(
    Agent(...),
    agent_id='researcher'  # Explicit ID
)

Issue 3: Crew exceeds budget

Problem: Total crew cost exceeds limits Solution: Set crew-level budget:

policies: {
    "crew": {
        "maxCostPerRun": 50.00,
        "stopOnBudgetExceeded": True
    }
}

Next steps

Policy overview

Learn how to write policies

Cookbook examples

See real-world examples

API reference

Explore the Python API

Other integrations

View all integrations

​Why integrate TealTiger with CrewAI?

​Quick start

​Integration patterns

​Pattern 1: Agent wrapping (recommended)

​Pattern 2: Crew-level governance

​Pattern 3: Tool-level interception

​Complete example: Multi-agent research crew

​What gets governed?

​Agent actions

​Crew coordination

​Tool executions

​Policy examples for CrewAI

​Example 1: Role-based access

​Example 2: Cost control per agent

​Example 3: Approval workflows

​Monitoring multi-agent workflows

​View crew metrics

​View agent audit logs

​Track crew execution

​Best practices

​Common issues

​Issue 1: Agents bypassing policies

​Issue 2: Cost attribution unclear

​Issue 3: Crew exceeds budget

​Next steps

Policy overview

Cookbook examples

API reference

Other integrations

Why integrate TealTiger with CrewAI?

Quick start

Integration patterns

Pattern 1: Agent wrapping (recommended)

Pattern 2: Crew-level governance

Pattern 3: Tool-level interception

Complete example: Multi-agent research crew

What gets governed?

Agent actions

Crew coordination

Tool executions

Policy examples for CrewAI

Example 1: Role-based access

Example 2: Cost control per agent

Example 3: Approval workflows

Monitoring multi-agent workflows

View crew metrics

View agent audit logs

Track crew execution

Best practices

Common issues

Issue 1: Agents bypassing policies

Issue 2: Cost attribution unclear

Issue 3: Crew exceeds budget

Next steps