Integrations

Anthropic

→

Capture Claude calls, token usage and latency.

AWS Bedrock

→

Trace model calls through Amazon Bedrock.

Trace non-streaming .NET chat calls to the Azure v1 endpoint.

CometAPI

→

Trace chat completions through the OpenAI client.

Gemini Go

→

Trace Gemini generation and embedding calls from the Go Gen AI SDK.

Google GenAI

→

Trace Gemini requests with the Google GenAI SDK.

Groq

→

Capture model calls made with the Groq SDK.

Mistral AI

→

Instrument Mistral model requests and responses.

Novita AI

→

Trace Novita chat completions from your Python app.

Ollama

→

Trace local model calls through the OpenAI client.

OpenAI

→

Instrument OpenAI client calls in your application.

OpenAI C#

→

Trace non-streaming OpenAI .NET chat calls.

OpenAI Go

→

Trace Chat Completions from the official Go SDK.

Trace Python predictions, streamed output and errors.

Together AI

→

Trace Together AI through its OpenAI-compatible API.

Trace System One decision calls from the Python client.

Vertex AI

→

Instrument Gemini calls through Google Cloud.

Trace embedding and rerank calls from the Python client.

Trace Python chat completions on the general-platform endpoint.

Trace Go agent-to-agent calls on clients and servers.

Trace agent turns, model calls and tools with AG2 native middleware.

AG2 Classic

→

Trace native autogen 0.14.x conversations, model calls and tools.

AgentScope

→

Export native agent, model and tool spans.

AI SDK for Python

→

Export native Python AI SDK generation, agent and tool spans.

Apollo Router

→

Export native federated GraphQL gateway spans over OTLP/HTTP.

Apollo Server

→

Trace GraphQL operations and resolvers in Server 4.

AutoGen

→

Trace conversations between AutoGen agents.

Trace Python project and Responses calls with native instrumentation.

Bedrock AgentCore Runtime

→

Trace hosted LangChain agents or export native Strands spans.

Trace Python tools and model calls with OpenInference.

Claude Agent SDK (TypeScript)

→

Trace Node.js agent conversations, tools and subagents.

Trace awaited HTTP generateText turns through a collector.

Trace deployed AIChatAgent chat turns through a collector.

Forward native Worker agent spans through a privacy-filtering collector.

Trace Eino graphs, agents, model calls and tools in Go.

Export native memory-operation spans with a privacy filter.

CrewAI

→

Trace crews, standalone agents, Flows and model calls.

DSPy

→

Capture DSPy module and language model calls.

Export JVM agent spans with the observability starter.

Eve

→

Send agent-turn spans from Vercel’s Eve framework.

Export version-scoped memory-server spans to self-hosted Future AGI.

Trace search, contents and answer calls from the Python client.

FastMCP Python

→

Export native Python MCP client and server spans.

Trace native Genkit flow, model and tool spans with a maintained processor.

Trace Python web scraping, search, crawl and browser operations.

Flue

→

Connect durable Node.js agents with Flue’s adapter.

Google ADK

→

Instrument agents built with Google ADK for Python.

Google Discovery Engine

→

Trace Vertex AI Search queries and grounded-answer requests.

Trace synchronous chat callbacks through their model client.

Graphite (grafi)

→

Export Python agent spans through ExecutionServices.

Guardrails AI

→

Capture validation and guard execution spans.

Haystack

→

Trace component execution in Haystack pipelines.

Hugging Face smolagents

→

Trace agent execution and tool calls in smolagents.

Trace structured-output requests and validation.

Koog

→

Export Kotlin JVM agent spans with Koog’s OTel feature.

Exercise handler reuse and bounded flush attempts locally.

LangChain

→

Trace chains, retrievers, tools and model calls.

LangChain Deep Agents

→

Trace model calls, filesystem tools, task subagents and sessions.

Langfuse SDK

→

Send new traces with Langfuse SDK instrumentation.

LangGraph

→

Follow agent graph execution and tool calls.

Forward supported LangSmith SDK traces over OTLP.

LiteLLM SDK

→

Instrument LiteLLM calls in your Python application.

LlamaIndex

→

Trace retrieval and generation in RAG applications.

LlamaIndex Workflows

→

Capture steps in event-driven agent workflows.

Mastra

→

Trace TypeScript agents and workflows in Mastra.

MCP for Python

→

Export native MCP 2.x client requests and server tool spans.

mcp-use

→

Trace Python agent runs, model calls and MCP tools.

Map native Python agent, model, tool and workflow spans.

Mirascope

→

Send Mirascope 2.x model spans with your own exporter.

Export current MLflow traces with OTLP/HTTP.

Model Context Protocol

→

Propagate context with TypeScript and existing Python MCP integrations.

Open Agent Spec

→

Trace Agent Spec agents through the LangGraph adapter.

OpenAI Agents SDK

→

Trace agent runs, handoffs and tools.

Send native Python, TypeScript, Java and Go OpenInference spans over OTLP.

Export synchronous Python OpenAI spans with OpenLIT.

Forward Traceloop SDK traces with OTLP/HTTP.

Trace non-streaming agent loops and tools through lifecycle hooks.

Trace Python Search and Extract calls, result counts and errors.

Prompt Flow

→

Trace OpenAI calls inside Prompt Flow pipelines.

Restate

→

Connect durable invocation, attempt and model spans.

RubyLLM

→

Trace RubyLLM calls with the third-party OTel gem.

Trace Node.js executeTool calls as privacy-conscious tool spans.

Trace native Python agent, tool and model spans.

Swiftide

→

Send typed Rust agent, model and tool spans through an OpenTelemetry Collector.

Send otelMiddleware chat, model-call and tool spans from Node.js.

Trace Python search, extraction, mapping, crawling and research calls.

Temporal

→

Follow Python workflows, activities and model calls.

Temporal Go

→

Trace Go workflows and activities with the official OTel interceptor.

Temporal TypeScript

→

Trace TypeScript workflows and activities with the native plugin.

Vercel / Next.js

→

Export native Next.js request spans directly over OTLP/HTTP.

Vercel AI SDK

→

Capture model and tool calls from the Vercel AI SDK.

Trace test runs and workers with native OpenTelemetry.

Map native agent, model, tool and memory spans to Future AGI.

watsonx Orchestrate ADK

→

Forward Agentic SDK spans through a collector.

Trace version-scoped macOS CLI conversations with lifecycle hooks.

Trace new macOS CLI sessions and stop causes with lifecycle hooks.

Forward native CLI telemetry through a privacy-filtering collector.

Trace macOS IDE agent sessions through observation hooks.

Trace local Node.js agent runs, tools and usage with the Cursor SDK.

Gemini CLI

→

Trace non-sandbox CLI sessions through a privacy-filtering collector.

Export native CLI agent-turn traces with scoped credentials.

Forward CLI spans with privacy filtering and model-only usage totals.

Trace macOS CLI sessions, turns and tools through Grok hooks.

Trace CLI turns, model attempts and tools with content capture off by default.

Trace macOS CLI sessions, turns and completed tools through hooks.

Trace omp sessions with the version-scoped local hook.

OpenAI Codex SDK

→

Trace SDK turns, tools and token usage with private content hidden by default.

Export supported CLI and Gateway agent-turn traces.

Trace terminal agent sessions, model steps and tools.

Trace upstream Pi sessions through a local extension.

Trace embedded Pi sessions, model calls, tools and compaction.

Forward application spans through a Consumption-tier egress policy.

Map gateway exports through a privacy-filtering collector.

Envoy AI Gateway

→

Export the gateway’s OpenAI-endpoint spans over OTLP.

Gravitee APIM

→

Forward APIM request spans, not AI Gateway traces.

Trace OpenAI-client calls through a self-hosted Helicone gateway.

Kong AI Gateway

→

Export GenAI spans with Kong’s OpenTelemetry plugin.

LiteLLM Proxy

→

Export request spans from the proxy server’s callback.

Forward native Broadcast traces through a privacy-filtering collector.

Instrument Portkey client calls in your application.

Trace Python client calls, not native gateway exports.

Vercel AI Gateway

→

Trace gateway calls from your app, not Trace Drains.

Forward post-call conversation traces, turns and tool calls.

Gemini Live

→

Trace Python Live sessions, conversation turns and tool calls.

LiveKit

→

Trace voice agent sessions and model interactions.

OpenAI Realtime

→

Trace server-side OpenAI Realtime sessions from Python.

Pipecat

→

Capture spans from conversational voice pipelines.

Retell

→

Connect calls using the shared voice observability guide.

Vapi

→

Connect calls using the shared voice observability guide.

Anthropic for Java

→

Export native Claude SDK spans without wrapping the client.

Export JVM HTTP server spans with an explicit error-detail filter.

AWS Bedrock for Java

→

Wrap Bedrock clients to capture model requests.

Cohere for Java

→

Trace Cohere requests from your Java client.

Google ADK for Java

→

Export ADK’s native spans without a new instrumentor.

Connect LangChain4j and Semantic Kernel applications.

Trace Qdrant, Milvus, ChromaDB and other vector stores.

Set up GenAI, Vertex AI, Azure OpenAI and other clients.

OpenAI for Java

→

Wrap the OpenAI Java client to capture requests.

Pinecone for Java

→

Capture vector queries and upserts in Java.

Export synchronous JVM AI-service spans to a self-hosted collector.

Spring Boot & Spring AI

→

Set up tracing with the Spring Boot starter.

LibreChat

→

Forward agent runs and backend spans from LibreChat.

LobeHub

→

Export server-side agent runs from self-hosted LobeHub.

n8n

→

Use Future AGI prompts in visual n8n workflows.

Trace self-hosted chat turns through the version-scoped filter Function.

Langfuse import

→

Import existing traces and scores from your account.

Archive trace data in S3, Azure Blob or Google Cloud.

Datadog

→

Forward logs and metrics to your monitoring stack.

Stream events to Amazon SQS or Google Pub/Sub.

Mixpanel

→

Connect LLM usage events with product behavior.

PagerDuty

→

Route Future AGI alerts to your on-call team.

PostHog

→

Send LLM usage events to product analytics.