> ## Documentation Index
> Fetch the complete documentation index at: https://developers.agentx.so/llms.txt
> Use this file to discover all available pages before exploring further.

# Platform Detection

> Tracing is platform agnostic - every trace says which agent framework produced it, whether AgentX has an integration for it or not

AgentX traces agents on **any** platform: LangChain, CrewAI, the OpenAI Agents SDK, Google ADK,
Moveworks, an in-house runner nobody else has heard of. Every trace carries a `framework` label
saying which platform produced it, and that one label powers the Live Traces framework filter,
the framework badge on every trace row, and Monitor's **Platforms** chart (root traces per
platform over time).

The label resolves in priority order - strongest wins:

## 1. Explicit: name your platform yourself

Any string is a valid platform. This is how platforms without an AgentX integration get
first-class treatment:

```python theme={null}
with client.tracer.trace("support-agent", framework="my-inhouse-runner") as span:
    span.output = run_agent(query)
```

`my-inhouse-runner` now appears in the framework filter, on trace rows, and as its own series
in the Platforms chart - exactly like a built-in. Labels are folded to lowercase and truncated
to 64 characters on ingest, so `"LangChain"` and `"langchain"` group as one platform.

## 2. Integrations: automatic literals

Every AgentX integration stamps its platform automatically - no parameter needed:

| Integration                                          | Label           |
| ---------------------------------------------------- | --------------- |
| `AgentXCallbackHandler` (LangChain / LangGraph)      | `langchain`     |
| `AgentXCrewObserver`                                 | `crewai`        |
| `AgentXTracingProcessor` (OpenAI Agents SDK)         | `openai-agents` |
| `patch_openai_client`                                | `openai`        |
| `patch_nim_client` (NVIDIA NIM)                      | `nvidia-nim`    |
| `patch_anthropic_client`                             | `anthropic`     |
| `patch_genai_client`                                 | `google-genai`  |
| `AgentXADKPlugin` (Google ADK)                       | `google-adk`    |
| `AgentXLiteLLMLogger`                                | `litellm`       |
| `AgentXLlamaIndexHandler`                            | `llamaindex`    |
| `AgentXAutoGenObserver`                              | `autogen`       |
| `MoveworksImporter` (`agentx-moveworks` sync)        | `moveworks`     |
| `DatabricksTraceImporter` (`agentx-databricks` sync) | `databricks`    |

A patched provider client running *inside* a span you opened yourself stamps its provider
literal onto that span too (an explicit `framework=` or a framework integration's label always
wins over it).

For OpenTelemetry ingest, the label comes from the OTel signal itself:
`gen_ai.provider.name`, then `gen_ai.system`, then the instrumentation scope name, then
`service.name`, then the literal `otel`. See [OpenTelemetry](/trace/opentelemetry).

## 3. Auto-detection: plain traces label themselves

A plain `@tracer.trace(...)` with no `framework=` and no integration in play looks at which
known orchestration framework is actually **imported** in the process (imported, not merely
installed) and labels the span when exactly one is loaded:

LangChain/LangGraph, CrewAI, LlamaIndex, AutoGen, OpenAI Agents SDK, Google ADK, Semantic
Kernel, Haystack, Pydantic AI, smolagents, DSPy.

Ambiguous (several loaded) or unknown means **no label** - the trace still ingests normally
and buckets as "Other / custom" in the dashboard. The SDK never guesses: unlabeled beats
mislabeled. Raw provider SDKs (`openai`, `anthropic`, ...) are deliberately not detected this
way - they are dependencies of nearly every framework, so their presence proves nothing about
what orchestrates the agent.

## Where the label shows up

* **Live Traces**: a framework badge on every row, plus a multi-select framework filter, and a
  server-side `GET /ingest/traces?framework=...` filter.
* **Monitor → Platforms chart**: root traces per platform per time bucket
  (`byFramework` on each bucket of `GET /agent-monitoring/metrics`, `frameworks` window
  totals, `facets.frameworks` suggestions, and a `framework=` query filter). Unlabeled and
  beyond-top-N platforms chart as "Other / custom" - every trace is always accounted for.
* **Custom evaluator webhooks**: the sampled trace's `framework` rides along in the payload.