Agent frameworks

The SDK ships dedicated patches for every major Python agent framework in production use. After egisai.init() runs, supported frameworks are patched in place: their entry point is wrapped to attribute identity, and policy enforcement cascades to the inner provider call (OpenAI, Anthropic, Google, Bedrock, …) — so a single set of policies covers your direct LLM calls and your framework-orchestrated agent runs. This page is an index of how to enable each framework. The dedicated pages for special tiers — Claude Agent SDK and AWS Bedrock — cover their unique enforcement seams.

What “enforced” means here

For every framework on this page:

Tool / MCP dispatch is enforced. A deny_tool_call, deny_mcp_call, or semantic_guard verdict on a tool call physically prevents the tool from running.
Tool result PII is enforced on the next call’s input phase. Tool results round-trip Python and the next call’s prompt-side evaluator scans them. A pii_scan / deny_output_regex / semantic_guard match on a tool’s response either masks the result (sanitize) or refuses it (block) before the model is shown it.
Input-side policies always fire pre-LLM. PII detection, regex denylists, model allow-lists, prompt-size caps, and semantic_guard on the prompt always run before the upstream provider is called.

For the full per-framework matrix — including which tier each one is in and which enforcement_status flag it stamps — see the Enforcement matrix in the SDK README.

OpenAI Agents

openai-agents Runner.run is wrapped for identity attribution. Tool gating cascades to the OpenAI patch.

import asyncio
import egisai
from agents import Agent, Runner

egisai.init(app="orchestrator", env="production")

async def main():
    agent = Agent(name="Triage", instructions="You triage incoming requests.")
    result = await Runner.run(agent, "How do I reset my password?")
    print(result.final_output)

asyncio.run(main())

LangChain (classic + 1.x)

Both classic langchain.agents.AgentExecutor and the 1.x langchain_classic.agents.AgentExecutor are patched. The modern langchain.agents.create_agent path is covered transparently via the LangGraph patch on the returned CompiledStateGraph.

import egisai
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_openai import ChatOpenAI

egisai.init(app="langchain-bot", env="production")

llm = ChatOpenAI(model="gpt-4.1")
agent = create_openai_functions_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools)
result = executor.invoke({"input": "Find the latest sales report."})

LangGraph

Pregel.invoke and Pregel.stream are wrapped for identity attribution.

import egisai
from langgraph.graph import StateGraph, END

egisai.init(app="planner", env="production")

graph = StateGraph(...)
# build nodes, edges, …
compiled = graph.compile()
result = compiled.invoke({"input": "Plan the launch."})

CrewAI

Agent.execute_task is wrapped per-agent so each Crew member is attributed independently on the dashboard.

import egisai
from crewai import Agent, Task, Crew

egisai.init(app="research-crew", env="production")

researcher = Agent(role="Senior Researcher", goal="...", backstory="...")
task = Task(description="Summarize today's news", agent=researcher)
crew = Crew(agents=[researcher], tasks=[task])
result = crew.kickoff()

AutoGen

AssistantAgent.run is wrapped for identity attribution.

import asyncio
import egisai
from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient

egisai.init(app="autogen-bot", env="production")

async def main():
    model = OpenAIChatCompletionClient(model="gpt-4.1")
    assistant = AssistantAgent("triager", model_client=model)
    result = await assistant.run(task="Triage this support ticket.")
    print(result.messages[-1].content)

asyncio.run(main())

Agno

Both Agent.run and Agent.arun are wrapped.

import egisai
from agno.agent import Agent
from agno.models.openai import OpenAIChat

egisai.init(app="agno-bot", env="production")

agent = Agent(model=OpenAIChat(id="gpt-4.1"))
response = agent.run("Hello!")

Strands Agents

Agent.__call__ is wrapped.

import egisai
from strands import Agent

egisai.init(app="strands-bot", env="production")

agent = Agent()
response = agent("Hello!")

smolagents

The agent entry point is wrapped for identity attribution.

import egisai
from smolagents import CodeAgent, OpenAIServerModel

egisai.init(app="smolagent-bot", env="production")

agent = CodeAgent(tools=[], model=OpenAIServerModel("gpt-4.1"))
result = agent.run("How many seconds in a leap year?")

LlamaIndex

FunctionAgent, ReActAgent, CodeActAgent, and AgentWorkflow.run are wrapped. The patch detects LlamaIndex’s WorkflowHandler pattern (run() returns a handle whose internal _result_task does the actual LLM work) and keeps the run context open until the workflow’s asyncio task finishes — so inner LLM calls attribute to the correct Agent row.

import asyncio
import egisai
from llama_index.core.agent.workflow import FunctionAgent
from llama_index.llms.openai import OpenAI

egisai.init(app="llamaindex-bot", env="production")

async def main():
    agent = FunctionAgent(llm=OpenAI(model="gpt-4.1"))
    handle = await agent.run("What's the weather today?")
    print(await handle)

asyncio.run(main())

Pydantic AI

Agent.run is wrapped.

import egisai
from pydantic_ai import Agent

egisai.init(app="pydantic-ai-bot", env="production")

agent = Agent("openai:gpt-4.1", system_prompt="You answer concisely.")
result = agent.run_sync("Hello!")
print(result.data)

Google ADK

The ADK entry point is wrapped.

import egisai
from google.adk.agents import LlmAgent

egisai.init(app="adk-bot", env="production")

agent = LlmAgent(name="planner", model="gemini-2.0-flash")
# Invoke per ADK docs; egisai attributes the run automatically.

When a call is blocked

Every framework above honors the global on_block mode. By default a blocked call raises PermissionError from inside the framework’s agent loop; with on_block="stub", the inner provider call returns a refusal-shaped response so the loop can keep running.

egisai.init(..., on_block="stub")

What’s next

OpenAI

Direct OpenAI integration — what every cascade above flows through.

Anthropic

Direct Anthropic integration.

Claude Agent SDK

Subprocess-loop framework with PreToolUse + PostToolUse enforcement.

AWS Bedrock

Bedrock Converse + managed Bedrock Agents.

Get started

Core concepts

Integrations

Gateway

Coverage

Guides

Operations

Agent frameworks

What “enforced” means here

OpenAI Agents

LangChain (classic + 1.x)

LangGraph

CrewAI

AutoGen

Agno

Strands Agents

smolagents

LlamaIndex

Pydantic AI

Google ADK

When a call is blocked

What’s next

OpenAI

Anthropic

Claude Agent SDK

AWS Bedrock

​What “enforced” means here

​OpenAI Agents

​LangChain (classic + 1.x)

​LangGraph

​CrewAI

​AutoGen

​Agno

​Strands Agents

​smolagents

​LlamaIndex

​Pydantic AI

​Google ADK

​When a call is blocked

​What’s next

OpenAI

Anthropic

Claude Agent SDK

AWS Bedrock

What “enforced” means here

OpenAI Agents

LangChain (classic + 1.x)

LangGraph

CrewAI

AutoGen

Agno

Strands Agents

smolagents

LlamaIndex

Pydantic AI

Google ADK

When a call is blocked

What’s next