Best AI Agent Testing Platforms for QA Teams
Compare LangSmith, Galileo and Braintrust for testing AI agents: trajectory checks, tool-call metrics, a worked refund-agent release gate and a pilot plan.

Which AI agent testing platform should you choose?
For most QA teams today, the realistic shortlist is LangSmith, Galileo and Braintrust, with your own deterministic checks sitting underneath whichever you pick. LangSmith fits teams that want to turn recorded agent runs into repeatable regression tests and check the exact path of tool calls. Galileo fits teams that want ready-made agent metrics such as tool selection quality and action completion, plus runtime rules. Braintrust fits teams whose main need is comparing one version of an agent against another with shared datasets and custom scorers. Patronus AI, often named in older lists, has retired its evaluation platform, so it should not be on a new shortlist.
An AI agent is an application where a language model decides which actions to take, such as calling an API, searching a database or issuing a refund, and loops until it thinks the task is done. Testing an agent therefore means testing decisions and side effects, not only the final sentence it writes.
This comparison is based on each vendor's official documentation, checked in November 2026, not on a hands-on benchmark we ran. The refund-agent example later in the article is an illustrative scenario. If you are new to language models in testing, read our practical guide to LLMs for QA testing first.
Why agent testing is different from testing a chatbot
A chatbot takes a question and returns text. You can review that text against an expected answer. An agent takes a goal and produces a trajectory: the ordered list of steps, tool calls and arguments it used to reach an outcome. Two agents can return the same polite final message while one of them refunded the wrong customer on the way.
That changes what a tester needs to look at:
- Final response: is the answer the user sees correct, complete and safe?
- Single step: at a given moment, did the agent pick the right tool with the right arguments?
- Trajectory: across the whole run, did it follow the required order, stay within permissions and stop in a sensible number of steps?
- Side effects: what actually changed in the systems it touched, such as orders, tickets or emails?
The LangSmith guide to evaluation approaches uses the same three-level split of final response, single step and trajectory. It is a helpful mental model whichever platform you choose, because it forces you to say which level each test is checking.
Agents are also non-deterministic. The same input can produce a different path on the next run, so a single passing run proves little. Plan to run important cases several times and treat a case that passes only some of the time as a defect to investigate, not as noise.
How we evaluated the platforms
We compared platforms on what a QA engineer needs to stop a bad agent release, using public documentation only:
- Trajectory visibility: can you see and assert on every tool call and argument, not just the final text?
- Deterministic and model-based checks: can you write plain code rules as well as use a language model as a judge?
- Failure to regression: can a bad run from testing or production become a saved test case?
- Version comparison: can you compare a candidate agent against the current one on the same dataset?
- Runtime protection: are there documented ways to block or flag behaviour while the agent is live?
- Product status: is the product still offered to new users?
We did not compare prices. Plans change often and the right cost depends on your volume, so check each vendor directly.
Comparison table: agent testing fit at a glance
ACCELQ is listed first as an adjacent functional test automation platform and a past SoftwareTestPilot partner. We do not claim it evaluates agent reasoning; it is relevant because the web and API screens an agent acts on still need normal regression coverage.
| Platform | Documented strength for agents | Best starting point | What to validate in a pilot |
|---|---|---|---|
| ACCELQ | Functional web and API test automation | Regression of the systems an agent calls | Do not assume it scores agent decisions |
| LangSmith | Trajectory match and LLM-judge trajectory evaluation, offline and online evaluation linked to traces | Turning real agent runs into regression tests | Trace capture, data redaction, replay context |
| Galileo | Prebuilt agentic metrics (tool selection quality, action completion, agent efficiency) and runtime rules | Teams wanting ready-made agent scores | How judge-based metrics agree with your reviewers |
| Braintrust | Datasets, experiments and custom scorers for comparing versions | Before-and-after comparison of agent changes | Scorer calibration, evidence export |
| Patronus AI | Evaluation platform retired; research such as TRAIL remains public | Reading research, not new projects | Not available to new users |
No single platform wins for every team. Pick the one that matches your biggest gap, then add the deterministic checks described below.
LangSmith: test the path, not just the answer
The LangSmith trajectory evaluation guide describes two ways to check an agent's run using the open-source agentevals package. A trajectory match compares the run step by step against a reference list of tool calls you write by hand. The guide notes this is deterministic and needs no extra model calls, which makes it a good fit for well-defined workflows. An LLM-as-judge trajectory check asks a model to review the run against a rubric, which is more flexible but less predictable.
Beyond trajectories, the LangSmith evaluation documentation separates offline evaluation on saved datasets from online evaluation of live traffic, and explains adding traces to datasets. For QA this is the most useful habit: every time an agent misbehaves, save that run as a test so the same mistake cannot return unnoticed.
Strengths: clear model of final, step and trajectory checks; deterministic matching available; strong path from debugging to regression.
Limitations: works best when your agent is instrumented to send traces; saved production traces may contain personal data, so plan redaction before you copy anything into a dataset.
Choose it when your team already debugs agents through traces and wants those traces to become tests.
Galileo: ready-made agent metrics and runtime rules
Galileo documents a set of agentic metrics, including action advancement, action completion, agent efficiency and tool selection quality. Its tool selection quality page explains that the metric asks a judge model several times whether the agent chose the right tool and arguments, then returns true or false with an explanation. The same page warns that this needs extra model calls, which affects usage.
Galileo also documents runtime protection rules: a metric, an operator and a target value that, when broken, let your code change the application's response. That is useful for live guardrails, but treat it as a second line of defence. Real permission limits, such as a maximum refund, should still be enforced in the application itself.
Strengths: quick start with named agent metrics; explanations attached to scores; runtime rules.
Limitations: many agent metrics are judged by a language model, so you must check how often they agree with your own reviewers before trusting a threshold.
Choose it when you want agent scores without writing every evaluator yourself.
Braintrust: compare agent versions with evidence
Braintrust's experiment documentation centres on three parts: a dataset of inputs, a task function that runs your application, and scorers that judge the output. Each run is recorded as an experiment, so you can compare a new prompt, model or tool set against the current baseline.
For agents, write scorers that look at what the task function returns, including the list of tool calls if you expose it. Braintrust's evaluation best practices recommend starting with a small set of representative examples and checking scorers against clearly right and clearly wrong outputs. Do exactly that for agents: include a run that skips a required step and confirm your scorer catches it.
Strengths: clean before-and-after comparisons; flexible code and model scorers.
Limitations: trajectory checks are only as good as the data your task function returns; you design most agent-specific scorers yourself.
Choose it when your biggest question is whether the next change made the agent better or worse.
What happened to Patronus AI?
Patronus AI appears on many older lists of agent testing tools. According to its own documentation site, the evaluation platform is retired and no longer offered, including its evaluation API, SDKs, evaluators and the Percival agent debugging assistant, and new users cannot sign up. Its research stays public, including TRAIL, a benchmark of hand-annotated agent traces for finding the step where an agent went wrong.
If you inherited a test plan that depends on Patronus, budget time to move those checks elsewhere. The TRAIL research is still worth reading as a way of thinking about agent error categories.
Worked example: a release gate for a refund agent
This is an illustrative scenario, not a real deployment. Imagine a support agent with four tools: lookup_order, check_refund_policy, issue_refund and escalate_to_human. The business rules are simple: never touch another customer's data, always check policy before refunding, and escalate any refund above ₹5,000.
Before choosing a platform, write those rules as plain code that inspects the recorded tool calls. The script below has no vendor dependencies, so you can run it anywhere and later wrap it as a scorer in LangSmith, Galileo or Braintrust.
# Illustrative trajectory check for a refund agent (no vendor SDK needed)
ALLOWED = {"lookup_order", "check_refund_policy", "issue_refund", "escalate_to_human"}
REFUND_LIMIT = 5000 # rupees an agent may refund without a human
def check_trajectory(case):
failures = []
calls = case["tool_calls"]
names = [c["name"] for c in calls]
for c in calls:
if c["name"] not in ALLOWED:
failures.append(f"unknown tool {c['name']}")
if c["args"].get("customer_id", case["customer_id"]) != case["customer_id"]:
failures.append("touched another customer's data")
if "issue_refund" in names:
if "check_refund_policy" not in names[: names.index("issue_refund")]:
failures.append("refund issued before policy check")
amount = next(c for c in calls if c["name"] == "issue_refund")["args"]["amount"]
if amount > REFUND_LIMIT:
failures.append(f"refund {amount} above limit without escalation")
if len(calls) > case.get("max_steps", 6):
failures.append("too many steps (possible loop)")
return failures
cases = [
{"id": "R1-happy", "customer_id": "C1", "tool_calls": [
{"name": "lookup_order", "args": {"customer_id": "C1"}},
{"name": "check_refund_policy", "args": {}},
{"name": "issue_refund", "args": {"customer_id": "C1", "amount": 1200}}]},
{"id": "R2-skip-policy", "customer_id": "C1", "tool_calls": [
{"name": "lookup_order", "args": {"customer_id": "C1"}},
{"name": "issue_refund", "args": {"customer_id": "C1", "amount": 900}}]},
{"id": "R3-wrong-customer", "customer_id": "C1", "tool_calls": [
{"name": "lookup_order", "args": {"customer_id": "C2"}}]},
{"id": "R4-over-limit", "customer_id": "C1", "tool_calls": [
{"name": "lookup_order", "args": {"customer_id": "C1"}},
{"name": "check_refund_policy", "args": {}},
{"name": "issue_refund", "args": {"customer_id": "C1", "amount": 18000}}]},
]
blocked = 0
for case in cases:
problems = check_trajectory(case)
print(case["id"], "PASS" if not problems else "FAIL: " + "; ".join(problems))
blocked += bool(problems)
print(f"{blocked} of {len(cases)} cases block the release")
We ran this script locally with Python 3. It printed:
R1-happy PASS
R2-skip-policy FAIL: refund issued before policy check
R3-wrong-customer FAIL: touched another customer's data
R4-over-limit FAIL: refund 18000 above limit without escalation
3 of 4 cases block the releaseWhy this works: each failure maps to one business rule, so the report tells a developer exactly what broke. None of these checks needs a judge model, so they give the same answer every run. Use a platform's model-based metrics for questions code cannot answer well, such as whether the explanation to the customer was clear and polite.
| Case | What it tests | Check type | Release impact |
|---|---|---|---|
| R1 | Normal refund path | Trajectory | Must pass |
| R2 | Skipped policy step | Trajectory order | Blocks release |
| R3 | Data from another customer | Argument check | Blocks release |
| R4 | Refund over limit | Business rule | Blocks release |
Practice exercise: add a case where the agent calls lookup_order eight times in a row. Which rule should catch it? Answer: the step limit check, which flags a possible loop once calls exceed max_steps. You can practise designing similar request-and-response checks on real endpoints in our free API Playground.
Common mistakes when testing AI agents
- Scoring only the final answer. A correct reply can hide an unsafe action. Always check tool calls and arguments.
- Relying on one run. Agents vary between runs. Repeat key cases and track how often each passes.
- Trusting a judge model without calibration. Compare judge scores with human labels on a few dozen cases before setting a threshold.
- Using guardrails instead of permissions. Runtime rules help, but hard limits belong in the application and the tools themselves.
- Testing against live systems. Point the agent at sandbox tools or mocks so a failing test cannot refund real money.
- Copying production traces without redaction. Remove personal data before saving runs as test cases.
- Forgetting replay context. Save the tool responses and data state with each case, or the test cannot be reproduced later.
A two-week pilot plan for your shortlist
- Days 1-2: write ten to twenty cases from real requirements: happy paths, permission boundaries, wrong inputs and known past failures.
- Days 3-4: code the deterministic rules first, like the refund example above.
- Days 5-8: run the same cases in two shortlisted platforms. Add one model-judged check for tone or helpfulness.
- Days 9-10: ask a colleague who did not set it up to diagnose one failure using only the saved evidence.
- Days 11-14: decide on a release rule: which failures block release outright and which only need review.
The platform that lets someone else reproduce and explain a failure fastest is usually the right choice, even if another has a longer list of metrics.
Next step
Agent testing builds on the same skills as API and automation testing: clear expected results, controlled test data and repeatable checks. If you want to strengthen those foundations, start with our free software testing courses with certificates, then explore structured automation and AI testing courses when you are ready to go deeper.
Have you tested an agent that passed its final-answer checks but took a wrong path? Share what caught it in the SoftwareTestPilot QA Community so other testers can learn from it.
References
- 1LangSmith trajectory evaluations— docs.langchain.com
- 2LangSmith evaluation approaches— docs.langchain.com
- 3LangSmith evaluation— docs.langchain.com
- 4Galileo agentic metrics— docs.galileo.ai
- 5Galileo tool selection quality— docs.galileo.ai
- 6Galileo runtime rules— docs.galileo.ai
- 7Braintrust experiments— www.braintrust.dev
- 8Braintrust evaluation practice— www.braintrust.dev
- 9Patronus AI documentation status— docs.patronus.ai
