Key Takeaway
- AI agent evaluation is how you move from guessing whether your agent works to knowing, using structured scoring across accuracy, tool use, and goal completion.
- An AI agent can process requests, call tools, and return outputs without actually completing the task correctly. Output volume is not the same as outcome quality.
- Amazon Bedrock AgentCore Evaluations works across any agent framework that emits OpenTelemetry telemetry, including LangGraph, OpenAI Agents SDK, LlamaIndex, and Claude Agent SDK.
- Two evaluation modes exist: on-demand testing for CI/CD regression checks, and online sampling for continuous agent performance monitoring in production.
- For Malaysian businesses deploying AI agents on AWS, structured evaluation from day one avoids the cost of discovering quality problems after users have already lost trust.
Introduction
Running an AI agent is the easy part. Knowing whether it is doing the right thing is where most teams get stuck.
An AI agent can look perfectly busy: calling tools, returning responses, processing every request. But the answers can still be wrong, steps can be skipped, and tools can be misused in ways you will never catch by reading outputs one by one.
That is where having proper evaluation in place pays off. Instead of waiting for user complaints to surface problems, you have a scoring layer watching what the agent actually does (not just what it says) and flagging when things drift from what you need.
Why Watching Outputs Is Not Enough
Most teams start the same way: run the agent, read the outputs, decide if they look right. For simple agents, that works. For anything more complex (agents that use tools, access data, handle multi-step reasoning, or operate autonomously), it breaks down quickly.
Consider an HR assistant agent. It receives a question about leave policy, retrieves the right document, and returns an answer. That looks correct. But did it retrieve the right version of the policy? Did it use the right tool in the right sequence? Did it ignore a tool it should have called? Did it handle an edge case the way your business requires?
Human review of every agent turn is not a realistic production strategy. You need a scoring system that reads the agent’s full behaviour: not just its final answer, but the reasoning trace, the tool calls it made, the tools it skipped, and whether the whole sequence matched what you expected.
The gap between an agent that produces output and one that completes the right task is exactly what evaluation frameworks are built to measure.
How Amazon Bedrock AgentCore Evaluations Works
Amazon Bedrock AgentCore Evaluations scores agent behaviour based on OpenTelemetry (OTel) telemetry — a standard way for software to record what it is doing as structured activity logs called spans. Any agent that emits these logs can be evaluated, and the service is not tied to a specific SDK or framework.
Supported frameworks include LangGraph, OpenAI Agents SDK, LlamaIndex, Google ADK, Strands Agents, and Claude Agent SDK. Agents using custom frameworks that follow OTel or OpenInference instrumentation conventions are also picked up automatically.
If your team is still getting your Bedrock foundation in place, our guide to Amazon Bedrock in Malaysia covers what the service means for business AI projects before you add the evaluation layer.
The service reads three types of spans:
1. Invoke agent spans
These capture one full user turn, including the input prompt and the final response. They form the top-level unit of evaluation.
2. Inference spans
These record each model call within a turn, with the message history sent to the model and the model’s reply. This is where you see how the agent is reasoning at each step.
3. Execute tool spans
These log every tool call: the tool name, the input parameters passed, and the result returned. This is where tool misuse or missing steps become visible.
Together, these spans give evaluators a complete picture of what the agent actually did.
How AgentCore Scores Your Agent’s Behaviour
AgentCore Evaluations includes three built-in evaluators, plus support for custom LLM-as-a-judge scoring.
Goal Success Rate
This evaluator runs at the session level. It checks whether the agent’s tool-call history matched the expected trajectory for a task and whether the tools used were the ones declared as available. GoalSuccessRate is the primary signal for AI quality testing: it tells you whether the agent completed the right sequence of actions, not just whether the final output looked reasonable.
Correctness and Helpfulness
These run at the turn level and score each response for accuracy and usefulness. They provide a per-interaction signal that complements the session-level view from GoalSuccessRate.
Custom evaluators
Beyond the built-ins, you can define custom LLM-as-a-judge evaluators at any level (session, turn, or individual tool call) to enforce criteria specific to your business logic or compliance requirements.
LLM evaluation that scores only the final answer misses most of what can go wrong in a multi-step agent. Scoring the tool-call trajectory is where the real signal is.
When to Run Evaluation: Testing vs. Live Production
AgentCore Evaluations runs in two modes, and the right choice depends on where you are in the deployment lifecycle.
On-demand evaluation
On-demand mode runs after you invoke the agent. You pass reference inputs, which include expected tool trajectories, expected responses, and specific assertions, and the evaluator scores actual behaviour against those benchmarks. This mode suits development pipelines where you need regression testing (making sure a code change has not broken something that was working before): a code update should not degrade agent quality, and on-demand evaluation catches that before it reaches users.
Custom evaluators that use expected responses or assertion placeholders only work in this mode, because they need a known correct answer (ground truth) to compare actual behaviour against.
Online evaluation
Online mode runs continuously in production. You configure it with a CloudWatch log group pointing at your agent’s telemetry and set a sampling percentage (25%, for example). The service scores sampled sessions and writes results to a dedicated log path, where they can feed CloudWatch alarms and dashboards to track quality trends over time.
Online mode only runs evaluators that do not require a known correct answer, since live user traffic does not come with expected answers attached.
The two modes complement each other. On-demand catches regressions during development. Online surfaces quality drift after deployment.
How Malaysian Businesses Can Start Evaluating AI Agents on AWS
Businesses in Malaysia adopting AI agents on AWS are often moving quickly: prototyping fast, connecting agents to internal systems, and deploying to users before formal evaluation is in place. When quality problems appear, they surface through user feedback rather than structured measurement.
For teams rethinking how AI fits into their broader setup, our piece on AI infrastructure strategy in Malaysia is worth a read before agent deployment begins.
For teams already using Amazon Bedrock as the foundation for agent deployment, AgentCore Evaluations integrates directly into the Bedrock ecosystem and reads telemetry from Bedrock-hosted agents without additional instrumentation.
AgentCore Evaluations is designed to fit into the existing deployment workflow rather than requiring a separate evaluation project. Because it reads OTel telemetry that most instrumented frameworks already emit, adding evaluation to an existing agent is a configuration step rather than a rebuild.
For regulated industries such as finance, healthcare, and the public sector, structured evaluation records also provide an audit trail of how the agent behaved over time, which matters when decisions made with agent assistance have downstream consequences.
Frequently Asked Questions
1. What is AI agent evaluation and why does it matter?
This is the process of measuring whether an AI agent completes tasks correctly, not just whether it produces output. Without it, the only reliable way to detect quality problems is through user complaints, which is a slow and costly feedback loop for any production deployment.
2. Does Amazon Bedrock AgentCore Evaluations work with non-AWS agent frameworks?
Yes. The service evaluates any agent that emits OpenTelemetry (OTel) telemetry, regardless of the framework used to build it. LangGraph, OpenAI Agents SDK, LlamaIndex, Google ADK, and Claude Agent SDK are all supported. Agents using frameworks that follow OTel or OpenInference instrumentation conventions are also picked up without additional configuration.
3. What is the difference between on-demand and online evaluation in AgentCore?
On-demand evaluation runs after invocation and compares actual behaviour against expected outcomes, making it the right LLM evaluation mode for development and regression testing (checking that updates have not broken something that was previously working). Online evaluation runs continuously in production, sampling live sessions and scoring them without needing a pre-set correct answer. Both modes share the same underlying evaluators, but on-demand is the only mode that supports custom evaluators requiring expected responses or assertions.
4. What does GoalSuccessRate actually measure?
GoalSuccessRate checks whether the agent’s tool-call sequence matched the expected trajectory for a given task and whether the tools used were declared as available. Because it operates at the session level rather than the individual turn level, it is the most useful metric for evaluating agents that need to complete multi-step tasks correctly, rather than simply generate plausible responses.
5. How does agent performance monitoring work after deployment?
Online evaluation mode points at your agent’s CloudWatch log group and samples a configurable percentage of live sessions. Evaluation results are written to a separate log path and can feed CloudWatch alarms and dashboards. This gives your team continuous visibility into quality without reviewing every session manually.
AI agents that go unmonitored tend to degrade quietly. A model update, a change in a connected data source, or a shift in user query patterns can all affect output quality without triggering an obvious error. Structured AI agent evaluation, built in from deployment rather than added after the fact, is what gives your team the visibility to catch these changes before users do. VSTECS KU’s AWS professional services team can help you instrument your agents correctly, configure AgentCore Evaluations for your specific frameworks, and build the monitoring layer your production deployment needs.