How to Test a Retell Agent Without Code (2026 Guide)

Pointing the platform at my Retell agent

There was nothing to install. TestMu AI Retell AI testing reaches an agent through the same phone endpoint a real caller dials, so getting started came down to three inputs and no SDK.

• I gave it the agent's phone number, the one customers actually call
• I pasted the agent prompt so the platform knew what a good call looks like, the refund policy, the escalation rules, and the tone the brand expects
• I added the two rules I cared about most, that the agent must confirm an order number before touching an account and must never state a refund term that is not in the policy

That second rule is the whole reason this approach works. The platform scores every call against the prompt and the constraints I hand it, so I never have to predict the exact words the agent will pick and pin an assertion to them.

The first call I described

For the first check I recreated the exact call that started all of this. Before a platform like this, placing one test call to a Retell agent meant opening the SDK and writing something close to this:

import Retell from "retell-sdk";
const client = new Retell({ apiKey: process.env.RETELL_API_KEY });

// place one outbound test call to the agent
const call = await client.call.createPhoneCall({
  from_number: "+14155550100",
  to_number: "+14155550142",
  override_agent_id: "agent_9f3c1a",
});

// poll until the call ends
let result = await client.call.retrieve(call.call_id);
while (result.call_status !== "ended") {
  await new Promise((r) => setTimeout(r, 3000));
  result = await client.call.retrieve(call.call_id);
}

// then read the transcript by hand and hope your assertion is right
const said = result.transcript.toLowerCase();
if (!said.includes("refund")) {
  throw new Error("agent never mentioned the refund policy");
}

That is around twenty lines to dial once, wait for the call to end, and confirm the word refund showed up in the transcript. It proves nothing about whether the agent understood the request, whether the speech-to-text held up, or whether the policy it quoted was real. A person still has to sit and listen to the recording to learn any of that.

Described for an AI testing agent instead, the same call reads like the notes I would leave for a colleague covering my shift:

• Call the agent as a customer whose order never arrived
• Ask for a refund on order 48213
• Confirm the agent treats this as a refund request
• Confirm it states the refund policy without inventing a window
• Confirm it repeats the order number back before acting on the account
• Confirm it closes the call without pulling in a human

No SDK, no polling loop, no brittle string match. An AI testing agent places the call, plays the caller, and scores the recording for me.

What the first run sent back

I ran it and watched the call go out. About a minute later the result came back as a scorecard rather than a transcript. The agent had caught the refund intent and confirmed the order number, both green. One check failed. It offered a fourteen-day refund window, and the policy I had pasted says thirty days from delivery. The platform pointed at the exact turn where it happened and quoted the line back to me as the evidence.

Every call gets scored across 30+ voice metrics, among them Intent Recognition Accuracy, Speech-to-Text Accuracy, and Containment Rate, and each score arrives with a confidence level and the moment in the call that produced it. The scores roll up into one Green, Yellow, or Red production-readiness verdict. Mine landed on Yellow, with a single named fix standing between the agent and a clean result.

The calls I was actually worried about

The happy path was the easy part. The calls that keep me up are the ones a real person makes on a bad day, so I added four more, each about two minutes to write.

The first was the accented caller from the original complaint. I ran the same refund scenario through a heavy regional accent over a call center floor, then again on a poor cellular connection. This is the coverage that voice agent testing is built for, and I reused the same 200+ voice profiles, 50+ accents and dialects, and 15 background noise presets without touching the scenario text. The agent handled the accent fine, then dropped the order number twice under floor noise, which is the precise failure that had reached the customer.

Then I made the caller angry. I wrote up someone billed twice who keeps interrupting and wants a person right away. I was watching for two things, whether the agent held an even tone under pressure and whether it handed off with the context of the call intact. It did both, and the Escalation Quality score backed that up.

Next came privacy. I had the test caller ask the agent to read back a different customer's account details, then, on a separate call, ask a billing question that requires a regulatory disclosure. The agent refused the first request and delivered the disclosure early in the second, both of which I had set as pass conditions.

Last, I sent the caller off script with a question well outside the agent's scope, to see whether it stayed grounded instead of guessing. It offered a sensible next step rather than a confident invention.

Making the session run without me

By now I had six scenarios describing how the agent should behave over a real line. The last job was making them run without me in the chair. Retell agents drift even when the prompt sits still, because the model underneath gets upstream updates and the knowledge base ages, so a call that passes today can fail next month with nobody having touched it.

• I scheduled the full suite to run every morning on a cron expression, so an overnight model change gets caught before the first customer dials in
• I wired the same scenarios into CI with the testmu-a2a CLI, so a change to the agent prompt or model kicks off a run and the pipeline stops on a failing result
• I sent the alerts to Slack, so a verdict sliding from Green to Yellow reaches the team the moment it moves

When a call fails now, the report skips the stack trace. It gives me the failing turn, the metric that dropped, and the line from the transcript that caused it, in plain English. Whoever owns the agent can act on it and edit the scenario, because changing a scenario means rewriting a few sentences, not a test file.

The same plain-English approach reaches the team's other agents through the wider AI agent testing surface. A Vapi voice agent or a support chatbot gets scored the same way, all from one place.

By the end of the afternoon I had a repeatable way to test a Retell agent without touching a test file. The refund miss that opened this session is a check that runs every morning now. If the agent ever quotes a window the policy does not carry, I will know about it before the next caller does.

Note: Test your Retell agent over real phone calls without writing a line of code. Get started with TestMu AI for free.