CrewAI

Install the integration extra:

pip install "agentx-python[crewai]" crewai

`observer.kickoff()`

Wraps crew.kickoff() for you. Each task is captured as a child span on the trace, with the task description as its input and the raw output as its output.

from agentx import AgentX
from agentx.integrations.crewai import AgentXCrewObserver
from crewai import Agent, Task, Crew

client = AgentX.from_env()  # AGENTX_API_KEY (+ AGENTX_API_BASE_URL for self-host)
observer = AgentXCrewObserver(
    tracer=client.tracer,
    name="support-crew",
    metadata={"env": "production"},
)

researcher = Agent(
    role="Policy Researcher",
    goal="Find relevant company policies",
    backstory="You look up policies from the knowledge base.",
    verbose=False,
)
writer = Agent(
    role="Support Writer",
    goal="Write clear, friendly support responses",
    backstory="You turn policy details into helpful customer replies.",
    verbose=False,
)
crew = Crew(
    agents=[researcher, writer],
    tasks=[
        Task(
            description="Look up the cancellation policy and summarize it.",
            expected_output="A concise policy statement.",
            agent=researcher,
        ),
        Task(
            description="Write a friendly support reply about cancelling a subscription.",
            expected_output="A clear, helpful response to send to the customer.",
            agent=writer,
        ),
    ],
    verbose=False,
)

result = observer.kickoff(crew, inputs={"query": "cancel subscription"})
print(result.raw)

client.tracer.flush(timeout=10)

What gets traced

Field	Source
`input`	`inputs` dict passed to `kickoff()`
`output`	`result.raw` (CrewOutput string)
`latencyMs`	Wall-clock time of the full crew run
`toolCalls`	Not populated - tasks are emitted as child spans instead, so the Tool-failure check and the Tool quality column do not see CrewAI tasks. Use `span.add_tool_call()` inside `observe()` if you need entries here
Child spans	One child span per task, with `description` as input, `raw` as output, and real start/end timestamps from CrewAI’s event bus
`framework`	Stamped `crewai` automatically - the platform label on the framework filter and Monitor’s Platforms chart
`error`	Exception message if `crew.kickoff()` raises. A task-level `TaskFailedEvent` error does not set this field - it lands in that task’s child span output as `ERROR: ...`

The root span is stamped span kind agent, and each per-task child span is stamped agent as well - a CrewAI task is an agent turn, not a model call. Token counts are not captured by this integration - the task-level events it listens to don’t carry per-call usage. Per-task timing comes from CrewAI’s event bus (TaskStartedEvent / TaskCompletedEvent / TaskFailedEvent, available on modern CrewAI versions) - observer.kickoff() registers temporary listeners for the duration of the call, keyed by each task’s real id so concurrent tasks (async_execution=True) are timed correctly rather than attributed to whichever task started most recently.

On older CrewAI versions that predate the event bus, kickoff() falls back to splitting the total latency evenly across tasks instead - still useful for task order, just not exact per-task duration on those versions.

`observer.observe()` context manager

Use this instead of kickoff() when you need to call crew.kickoff() yourself, for example to catch exceptions before they reach AgentX, or to run additional logic between kickoff and reading the result:

from agentx import AgentX
from agentx.integrations.crewai import AgentXCrewObserver
from crewai import Agent, Task, Crew

client = AgentX.from_env()
observer = AgentXCrewObserver(tracer=client.tracer, name="support-crew")

researcher = Agent(
    role="Policy Researcher",
    goal="Find relevant company policies",
    backstory="You look up policies from the knowledge base.",
)
crew = Crew(
    agents=[researcher],
    tasks=[
        Task(
            description="Look up the cancellation policy and summarize it.",
            expected_output="A concise policy statement.",
            agent=researcher,
        )
    ],
)

with observer.observe(name="support-crew", input={"query": "cancel subscription"}) as span:
    try:
        result = crew.kickoff(inputs={"query": "cancel subscription"})
        span.output = result.raw
    except Exception as e:
        span.set_error(str(e))
        raise

client.tracer.flush(timeout=10)

Unlike kickoff(), the observe() context manager doesn’t create per-task child spans - you get a single span for the whole run. Record individual tool calls yourself with span.add_tool_call(...) if you need that detail.

`AgentXCrewObserver` reference

AgentXCrewObserver(
    tracer: Tracer,
    name: str = "crewai-crew",
    metadata: dict | None = None,
    session_id: str | None = None,
)

Parameter	Description
`tracer`	`client.tracer` from your `AgentX` instance
`name`	Label shown in the AgentX UI
`metadata`	Static key-value metadata attached to every trace
`session_id`	Links traces from the same conversation thread

`observe()` parameters

observer.observe(
    name: str | None = None,
    input: Any = None,
    metadata: dict | None = None,
    session_id: str | None = None,
    sync: bool = False,
) -> _TraceSpan

observe() returns a _TraceSpan, which you use as a context manager. Inside the with block, assign span.output before exiting to set the trace output. Because you hold the span itself, span.trace_id is available - pass sync=True to send synchronously so it is populated once the block exits, e.g. to link the trace to an evaluation result.

Call tracer.flush() before your process exits in scripts or one-shot jobs. In long-running servers it is not required: traces drain automatically in the background.

Tracing

Framework Integrations

`observer.kickoff()`

What gets traced

`observer.observe()` context manager

`AgentXCrewObserver` reference

`observe()` parameters

​observer.kickoff()

​What gets traced

​observer.observe() context manager

​AgentXCrewObserver reference

​observe() parameters

`observer.kickoff()`

What gets traced

`observer.observe()` context manager

`AgentXCrewObserver` reference

`observe()` parameters