Skip to content

Build Reports disagree2 publishers 2 min read Published

AWS puts agent evaluation on OpenTelemetry, and on exactly three span roles

Bedrock AgentCore Evaluations promises to score agents built on LangGraph, LlamaIndex, OpenAI's SDK, Google ADK or the Claude Agent SDK. The catch sits in the instrumentation.

The Engineer · Build desk

How we use AI Send a correction

What happened

  • AWS says Bedrock AgentCore Evaluations can score an agent regardless of the SDK underneath it, provided the agent's telemetry flows through OpenTelemetry.
  • The stated problem: most evaluation tooling assumes a particular SDK, model client and tracing pattern, and breaks outside it.
  • The service reads only three span roles: the top-level agent turn, individual model calls, and each tool invocation with its inputs and result.
  • Retrieval, reranking, guardrail and memory spans are accepted as extra context, and span kinds the service does not recognise are skipped rather than erroring.

Why it matters

  • capability A team can keep different frameworks per project and still grade them on one surface, instead of rebuilding the eval harness each time the orchestration choice changes.
  • constraint Portability now depends on instrumentation fidelity rather than SDK choice: whoever wrote the tracing library decides which attributes reach the grader, and a missing tool result degrades a score...
  • exposure Neutrality is claimed at the wire format, not at the destination; the collection path in the post terminates in CloudWatch, so telemetry lock-in replaces framework lock-in.
  • precedent With two competing span conventions in play, the party writing the span classifier gets to define what counts as an agent turn for everyone downstream.

The load-bearing sentence in the AWS post is not about frameworks at all. It is the assertion that every major framework supports OpenTelemetry, either natively or through a community instrumentation library [11]. If the spans arrive, the scorer runs. If they do not, decoupling evaluation from the SDK buys nothing, and "community instrumentation library" is carrying a lot of weight in that sentence.

The reading surface is deliberately small. AWS says the evaluators need three span roles: an invoke agent span holding the user prompt and final response, inference spans holding message history and model replies, and execute tool spans holding tool name, input parameters and result [13]. Set that against the ten OpenInference span kinds the same post enumerates, and seven kinds are collected but never read by the evaluators [9]. Retrieval, reranking, guardrail and memory spans are described as context the evaluators do not require [4]. That is a defensible boundary, and it also fixes what a score can possibly mean: a retrieval that returned the wrong documents is only visible to the grader if it reached the model's message history [13].

Then comes the part that decides whether any of this is portable. Frameworks and instrumentation libraries record those same three roles under different attribute names, different nesting structures and different span-naming conventions [5]. So the agnosticism is not in the wire format, which everyone already shares; it is in whatever normalisation layer maps six named frameworks [10] onto three roles. AWS's forward-compatibility argument covers the easy failure: an unfamiliar span kind is skipped rather than treated as an error [4]. The harder failure is a role that is present but recorded under an attribute the classifier does not expect, which does not announce itself as an error either. It just produces a thinner transcript and a score computed from it.

Worth noting where the neutral standard ends. AgentCore runtime handles hosting, scaling, memory and observability [6], and on that runtime the collector is the AWS Distro for OpenTelemetry, routing spans and event records into Amazon CloudWatch [12]. Framework choice becomes cheap to change; the telemetry destination named in the post is AWS's own.

For a team already running LangGraph for orchestration or LlamaIndex against a retrieval pipeline [3], the question this raises is narrow and answerable: does your instrumentation actually write tool results into the execute tool span, and does the top-level span carry the real final response rather than an orchestration artefact. Those two attributes are what the evaluators grade [13]. Everything else in the trace is decoration as far as the score is concerned.

What to watch

  • Whether AWS publishes the per-framework attribute mappings and a conformance test, so teams can verify their spans before trusting a score.

Clarity's read

What the record supports and how the coverage leans. The claims behind it follow.

Reality

Evidence52
Adoption20
Hype gap+28
Incentives78
Confidence48
Why these scores

Claim ledger

Ranked by verification strength, evidence, and original report placement.

  1. [1]

    AWS states that most evaluation systems assume an agent was built a specific way (a specific SDK, LLM client and tracing pattern), and that the evaluation pipeline breaks the moment a team steps outside that compatibility zone.

    Reported Supported Source: AWS Machine Learning blog2 sources— create a free account to open themView cited source
  2. [2]

    Amazon Bedrock AgentCore Evaluations decouples evaluation from framework choice: as long as an agent's telemetry flows through OpenTelemetry, the evaluation service can score it regardless of the underlying SDK.

  3. [3]

    The post names teams building on LangGraph for workflow orchestration, LlamaIndex for retrieval pipeline integration, the OpenAI Agents SDK where the organisation standardises on GPT models, Google ADK for multi-agent coordination, the Claude Agent SDK for native Anthropic capability, and Strands Agents for its model-driven loop.

Sources

2 independent publishers whose own reporting we read for this story.

  1. aws.amazon.com

    1 article · August 26, 2026

    Evaluate any agent framework with Amazon Bedrock AgentCore Evaluations
  2. dev.to

    1 article · August 26, 2026

    AgentCore Evaluations: How AWS Built a Framework-Agnostic Eval Layer Using OpenTelemetry as the Contract

Share your take

Let Clarity write the post for you.

Signed-in readers get a short post drafted on this story in the register they choose — narrative, analytical, or a direct position — editable to the last word before it goes anywhere. The share buttons at the top of this story work without an account.

Topics and entities

Follow any of these and your For You feed starts watching them — no settings page required.

Topics

Loading related stories