OpenInference
OpenTelemetry conventions and instrumentation for tracing models, agents, retrieval, and tool calls.
The evidence presents an instrumentation layer that sends AI-application trace data to OpenTelemetry-compatible backends. Tests concretely show that inputs, outputs, messages, tool calls, reasoning content, documents, and metadata may become span attributes, and they verify hideInputs redaction. Release workflows limit declared permissions to contents and pull-request writes, disable persisted checkout credentials, and submit changes through pull requests. Deductions apply because the README does not centrally document the complete data flow, default capture scope, transport or retention behavior, and the sources do not demonstrate output redaction, a field-level sensitive-data policy, runtime least-privilege requirements, or confirmation before export. Rollback is only indirectly supported by the PR workflow. Repository and Arize resource attribution is visible, but the supplied provenance says publisher identity is unverified, so identity is not treated as established.
The README's semantic-convention, instrumentation, and OpenTelemetry claims align closely with tests for attribute construction, span kinds, synchronous and asynchronous calls, context nesting, and exception recording, justifying full self-consistency credit. Failure paths preserve thrown errors, mark spans as ERROR, record exception events, and release automation emits notices for invalid tags, providing thorough failure-message evidence. Package listings, PyPI version references, and workflows that wait for released packages support dependency availability; points are deducted because the evidence lacks a complete compatibility matrix, offline operation guidance, and degradation behavior when third-party SDKs or packages are unavailable.
The project covers Python, JavaScript, many model and agent frameworks, and OpenTelemetry-compatible backends, with examples labeled by scenario complexity. Generic wrappers, specialized span kinds, custom input/output processors, and explicit tracer selection demonstrate useful adaptability. Deductions apply because the materials do not provide a complete supported-version matrix, deployment requirements, or unsupported scenarios; this is observability instrumentation rather than an executing agent, and its boundaries are conveyed mainly through descriptions and API naming. Trigger precision is supported by explicit wrappers and strict semver validation for release events, but enablement and filtering controls for every automatic instrumentor are not shown.
The README separates specification, languages, libraries, span processors, and examples; package and semantic-convention names are clear and stable. Numerous framework-specific examples with complexity labels, commit-pinned workflow actions, and explicit semver-tag automation provide strong information architecture, examples, naming, and versioning evidence. The complete Apache-2.0 text matches the supplied metadata, earning full license credit. Deductions apply because the provided README lacks concrete installation commands, configuration steps, and an FAQ, while known limitations appear only indirectly through a skipped generator test and TODO. Repository, community, and automated update paths are visible, but named maintainers and support commitments are absent, and publisher identity remains unknown.
Structured attributes, unified semantic conventions, explicit AGENT, TOOL, LLM, and RETRIEVER span kinds, and handling for synchronous, asynchronous, exceptional, and nested execution make the output directly usable by OpenTelemetry backends. Normalizing AI traces across many frameworks supplies clear marginal value, so those criteria receive full credit. Cost-benefit is deducted because the evidence does not quantify or guide latency, storage, network traffic, sampling, attribute cardinality, or sensitive-data governance costs, leaving production overhead unaddressed.
Core claims are traceable to the README's package and capability inventory, release workflows, and focused tests covering serialization, redaction, exceptions, nesting, and span kinds. These independent source types strongly corroborate the main product description, supporting full traceability and cross-source scores. A deduction remains for fact/inference separation because broad compatibility claims, including use with any OpenTelemetry-compatible backend, are not individually substantiated in the supplied files and are not explicitly labeled as design intent versus verified compatibility.
- Trace attributes may contain prompts, model outputs, tool arguments, retrieved documents, metadata, session identifiers, and reasoning or encrypted content; validate every hide/redaction setting, exporter endpoint, access control, and retention policy before deployment.
- The supplied evidence does not show that outputs and all nested fields can be redacted, nor does it document default sampling, data minimization, or high-cardinality controls; do not infer comprehensive privacy protection from the hideInputs tests alone.
- The large set of third-party SDK and framework integrations expands compatibility and supply-chain exposure; verify each selected instrumentor's version constraints, published artifact, and dependency-audit status before adoption.
- This is a low-confidence static assessment: tests were not executed, and PyPI artifacts, backend interoperability, runtime overhead, and production behavior were not independently verified.
What does this agent do, and when should you use it?
OpenInference is a collection of semantic conventions, instrumentation libraries, and span processors for AI observability; it is not an inference engine or autonomous agent. Its specification describes LLM invocations and surrounding context such as vector-store retrieval and external tool or API use while remaining transport- and file-format-agnostic. The repository supplies components for Python, JavaScript, Java, and Go, with integrations spanning OpenAI, Anthropic, LangChain, LlamaIndex, MCP, Bedrock, Vertex AI, and many other SDKs and frameworks. Instrumented applications emit spans through OpenTelemetry to Arize Phoenix, Arize AX, or another OpenTelemetry-compatible collector. It is a strong fit for engineering and operations teams standardizing AI telemetry, provided they are prepared to select language-specific packages and configure an observability backend.
An application adds the OpenInference package corresponding to its language and SDK. That instrumentation creates tracing data around supported SDK or framework operations and describes LLM, Agent, Chain, Tool, retrieval, and related application context using openinference-semantic-conventions. In Python, openinference-instrumentation supplies reusable utilities, decorators, configuration, and helpers; JavaScript offers similar foundations through @arizeai/openinference-core, while Java and Go include their own semantic-convention and base-instrumentation libraries. Separate adapters cover components such as the OpenAI SDK, OpenAI Agents SDK, Anthropic, Claude Agent SDK, LangChain, MCP, Bedrock, VertexAI, and PydanticAI. The openinference-instrumentation-openlit and openinference-instrumentation-openllmetry span processors normalize traces produced by those other instrumentation systems. An OpenTelemetry pipeline then exports the resulting spans to Phoenix, Arize AX, or another compatible collector.
- A platform team running several model providers wants one semantic model for comparing OpenAI, Anthropic, Bedrock, and Vertex AI traces.
- An engineer operating a RAG application needs model calls, vector retrieval, and external search or API tools represented in the same distributed trace.
- A team using LangChain, LlamaIndex, Haystack, PydanticAI, or the OpenAI Agents SDK wants packaged instrumentation instead of implementing every span manually.
- An observability team already using OpenLIT or OpenLLMetry wants to normalize its existing traces through dedicated span processors.
- An organization maintaining Python, JavaScript, Java, and Go services wants to send AI telemetry from multiple runtimes to one OpenTelemetry-compatible backend.
- A team building MCP client or server integrations needs OpenInference instrumentation for MCP activity.
What are this agent's strengths and limitations?
- The specification is transport- and file-format-agnostic and can feed any OpenTelemetry-compatible collector rather than requiring an Arize backend.
- It covers Python, JavaScript, Java, and Go, with dedicated instrumentation for many model providers, agent SDKs, RAG frameworks, and MCP.
- The semantic scope explicitly includes vector-store retrieval and external search or API tools, not only model requests.
- Dedicated OpenLIT and OpenLLMetry processors can normalize traces created by other instrumentation libraries.
- The repository lists beginner and intermediate examples involving streaming, tool calls, handoffs, group chats, and RAG.
- This is a telemetry specification and library collection, not a model runtime, agent orchestrator, or standalone observability backend.
- Each language and framework uses separate packages and still needs OpenTelemetry export configuration, increasing dependency and version-management work in heterogeneous stacks.
- The supplied material lacks a unified, copyable setup and first-run example for Python, JavaScript, or Java and does not state their minimum runtime versions.
- The Go libraries require Go 1.25+, which may force projects on older versions to upgrade their toolchain.
- Migration from another tracing schema may require processors or field mapping, and the supplied material does not quantify conversion completeness or compatibility limits.
How do you install or deploy this agent?
The supplied material does not define one installation command covering every language and adapter. Python packages are published through PyPI, JavaScript packages through npm, and Java artifacts through Maven Central, but no copyable pip, npm, or Maven commands or minimum runtime versions are provided here. The Go libraries require Go 1.25+ and can be fetched individually: go get github.com/Arize-ai/openinference/go/openinference-semantic-conventions; go get github.com/Arize-ai/openinference/go/openinference-instrumentation; go get github.com/Arize-ai/openinference/go/openinference-instrumentation-anthropic-sdk-go; or go get github.com/Arize-ai/openinference/go/openinference-instrumentation-openai-go. Adoption also requires an OpenTelemetry exporter or compatible backend. The material does not specify universal API-key names or credential settings.
How do you use this agent?
Choose the semantic-conventions, core, and adapter packages matching the application's runtime and SDK—for example, openinference-instrumentation-openai for Python, @arizeai/openinference-instrumentation-anthropic for JavaScript, openinference-instrumentation-langchain4j for Java, or openinference-instrumentation-openai-go for Go. Connect that instrumentation to the application's OpenTelemetry tracing pipeline and configure a span destination. Documented destinations are Arize Phoenix, Arize AX, and any OpenTelemetry-compatible collector; the Go section gives http://localhost:6006/v1/traces as a Phoenix OTLP/HTTP endpoint example. Running the instrumented model, agent, retrieval, or tool operation then produces spans following OpenInference conventions. Beyond the Go retrieval commands and Phoenix endpoint example, the supplied material does not include one complete first invocation that applies to every package or enumerate hosted-service credentials.
How does this agent compare with similar options?
Unlike a telemetry format tied to one vendor, OpenInference can export through any OpenTelemetry-compatible collector. Arize Phoenix and Arize AX provide native support but are not mandatory. For teams already instrumented with OpenLIT or OpenLLMetry (Traceloop), dedicated span processors offer a normalization path without requiring an immediate replacement of the existing instrumentation.