16 Min. Lesezeit

How Quality Gates Make AI Agents Reliable in Production

By submitting, you consent to our use of your data. Privacy Policy.

Kategorie

KI-Agenten

Artikel teilen

Why agents that pass a pilot fail at volume, how much a check on every step changes that, when a gate pays for itself, and how Beam runs the gate loop.

📌 Key takeaways

  • Five steps that are each right 95% of the time finish only 77% of tasks right. To reach 98% on an eight-step workflow with no checks, every step would need to be right 99.75% of the time.

  • A quality gate on each of those five steps takes uncaught errors from 226 to 38 per 1,000 tasks in our model, and 952 of the 1,000 go through with no person involved.

  • What the gate can catch matters far more than how good the reruns are. Raising the catch rate from 70% to 95% cuts uncaught errors from 99 to 20 per 1,000; raising the rerun fix rate from 40% to 80% only takes them from 49 to 30.

  • A gate costs 2 to 4 cents a task. It pays for itself if it stops one $30 error in every 800 tasks, and a 95% step hands it one error to stop in every 24.

  • In Beam, a gate is a setting on the step: written criteria, a pass mark and Auto-run. After the last rerun the workflow continues with the best output and flags the miss, so we put Consent required on the step that sends, pays or files.

Most companies I talk to have an AI agent that works in a pilot. The step from there to running claims, onboarding or payments without a person checking every task is where they get stuck, and in my experience the reason is rarely the model. It is that small misses at each step add up to a process nobody can trust.

Quality gates are what make autonomous agents reliable in production. A quality gate is a check that the platform runs after a step of a workflow, every time. It scores the output against written criteria, then lets the work move on, reruns the step with the specific error, or hands the task to a person. So instead of asking which model is accurate enough, we built a model of the workflow itself: why agents that work in a pilot break in production, how much a gate changes that, and whether a gate pays for itself. The last section is a decision guide you can use this quarter.

This piece covers checks that run inside a workflow after each step: the arithmetic of compounding errors, a worked model of gates on five steps, the break-even against the cost of an error, and how the gate loop runs on Beam. It does not cover how to write the criteria themselves or how to test an agent before it has real data; both have their own posts, linked below. Every number is either published, with a source, or modelled from assumptions stated in the text. Figures as of 15 November 2026.

A quality gate checks each step before the work moves on. One step of a workflow runs, the gate checks it against written criteria, and one of three things happens: the output passes and the work moves on, the step reruns with the failed criterion and its reason, up to three times, or a person decides what a rerun cannot fix.

One step, one gate, three outcomes. The rerun carries the failed criterion and its reason back to the step.

Why do agents that work in a pilot fail in production?

Because small misses at every step multiply across the workflow, so a process built from good steps still gets nearly one task in four wrong. In a pilot of 50 tasks that is a handful of errors someone fixes by hand. At 10,000 tasks a month it is a team whose job is finding the agent's mistakes, usually after a customer does.

The arithmetic is short. If each step is right 95% of the time and the next step trusts its output, the misses multiply. Five steps finish 0.95 to the power of 5, or 77%, of tasks right. Here is how that moves with step accuracy and workflow length (modelled, errors assumed independent):

Each step right

3 steps

5 steps

8 steps

12 steps

90%

73%

59%

43%

28%

95%

86%

77%

66%

54%

98%

94%

90%

85%

78%

99%

97%

95%

92%

89%

Compounding errors across a workflow. A chart of tasks finished right against number of steps, for step accuracies of 90, 95, 98 and 99 percent. At 95 percent per step, five steps finish 77 percent of tasks right and twelve steps finish 54 percent.

A workflow built from 95% steps is a 77% workflow at five steps and a 54% workflow at twelve.

Turn the table around and it shows why a better model alone does not close the gap. To finish 98% of tasks right on an eight-step workflow with no checks, every step has to be right 99.75% of the time. That is less than one miss in 400 runs, which is a high bar for any step that reads a document or makes a judgment call. Public tests put agents further away still: on τ-bench, a 2024 benchmark of customer-service agents, even state-of-the-art function-calling agents such as gpt-4o succeeded on under half of the tasks (Yao et al., 2024). Anthropic's own guidance on building agents names the same risk plainly: "the potential for compounding errors" (Anthropic, Building effective agents, Dec 2024).

One limit of this model is worth stating. It treats each step's errors as independent. In practice one bad document can trip several steps at once. That makes the unchecked numbers look a little better than they are, and it means a single gate often catches several problems together.

The way out is to stop each miss at the step where it happens, before the next step builds on it.

How much more reliable does a quality gate make a workflow?

In our model, a gate on each of five 95% steps raises the tasks done right from 774 to 962 in every 1,000. The errors nobody caught fall from 226 to 38. That is the difference between a process you re-check by hand and one you can run at volume, since 952 of those 1,000 tasks go through with no person involved.

Here is what the gate does at each step, with the assumptions I used:

  • It catches 90% of wrong outputs. That assumes written criteria a stranger could score, such as "every figure matches the claim form", not "is this a good email?".

  • When it catches one, it reruns the step with the failed criterion and its reason. I assume 60% of those reruns come back right, since some misses, like a figure missing from the source, no rerun can fix.

  • It reruns up to three times, the limit Beam sets, and after that the task goes to a person.

Take one step that is right 95% of the time. Of 100 tasks, 95 pass first time, 4 are fixed by a rerun, 0.2 go to a person and 0.8 carry an error nobody caught (0.5 the gate missed the first time, 0.3 wrong reruns it missed). Across five steps, that gives 952 tasks right with no person involved, 10 fixed by a person and 38 errors nobody caught.

Per 1,000 tasks on five 95% steps, without and with gates. Without gates: 774 right, 226 with an uncaught error. With a gate on every step: 952 right with no person involved, 10 fixed by a person, 38 with an uncaught error.

Same five steps, same model. The gates take uncaught errors from 226 to 38 per 1,000 tasks (modelled).

The second result matters more for where you spend effort. I varied both assumptions, and what the gate can catch matters far more than how good the reruns are. Moving the catch rate from 70% to 95% cuts errors nobody caught from 99 to 20 per 1,000 tasks. Moving the rerun fix rate from 40% to 80% only takes them from 49 to 30. So put the effort into the criteria before the retries. This matches Beam's own guidance to "Start with 2-3 max retries" (Beam docs, Evaluation Framework): past that, a rerun is mostly repeating a miss the criteria should have described better.

Sensitivity of uncaught errors per 1,000 tasks to the gate's catch rate and to the rerun fix rate. Catch rate from 70 to 95 percent: errors fall from 99 to 20. Rerun fix rate from 40 to 80 percent: errors fall from 49 to 30.

The catch rate moves the result five times as far as the rerun fix rate. Criteria first, retries second.

A gate also changes what you can show an auditor or a regulator. Every check leaves a line with the criterion, the score, the reason and the attempt. Take an illustrative claims reply: "Figures: fail, limit in note €5M, claim form says €3M, attempt 1", then a pass on attempt 2, is evidence that a control ran on that task. An agent's own log can only say what it did, not what was checked.

🧭 How we see it at Beam

We publish 98% accuracy across more than 10 million agent tasks. Read as tasks done right, that still leaves 20 in every 1,000 to find, and the gate log is how you find them.

Do quality gates pay for themselves?

In our model, yes, on almost any step where a miss costs more than a few dollars. A gate costs 2 to 4 cents a task, and it pays for itself if it stops one error in every 800 tasks. On a step that is right 95% of the time it stops one in every 24: the step gets 1 task in 20 wrong, and the gate stops about 85% of those.

Start with the model calls, because that is where people expect the cost to be. OpenRouter measured an LLM judge at $0.114 per 1,000 judgments on short checks, about a hundredth of a cent each (OpenRouter, Jev vs LLM-as-a-Judge, Sep 2026). A claims file is longer than their test, so I also priced the judge at 100 times that. Add the judge's extra calls on reruns and the reruns of the step itself, and the model cost per task comes to between 0.2 and 1.5 cents (modelled).

The larger cost is people. Tasks that still fail after three reruns go to a person, and at 10 minutes of a specialist's time ($10), that adds 2.1 cents per task. That time is not wasted: it replaces fixing the same error later, after it has reached a customer or a ledger.

On the other side is the cost of one error nobody caught, which I modelled at three levels:

One error nobody caught costs

Example

Gate pays if it stops one error in every

$30

30 minutes of rework

800 tasks

$250

A customer-facing correction with a supervisor's sign-off

7,000 tasks

$2,000

A wrong payout that is partly unrecoverable

56,000 tasks

All three use the higher judge price, so they are conservative. At the $30 level, each gate on a 95% step saves about $1,200 per 1,000 tasks after its own cost.

Break-even for a quality gate. The gate costs 2 to 4 cents a task. Against a $30 error it pays if it stops one error in 800 tasks; against $250, one in 7,000; against $2,000, one in 56,000. A 95% step hands the gate one error to stop in every 24 tasks.

A 95% step gives the gate one error to stop every 24 tasks. It needs one in 800 to break even on a $30 error.

The same model shows where gates stop paying. With $30 errors, a judge gate loses money once a step is right more than 99.95% of the time, which is about one miss in 2,000 runs. That describes cheap, reversible steps, such as tagging a CRM record, and steps that a plain rule can check for less, such as "policy record found". OpenRouter measured a model built for closed yes-or-no questions at $0.021 per 1,000 judgments, and a plain rule costs close to nothing. Save the judge for the steps that need one.

How does the Beam platform run the gate loop?

Each step carries its own criteria, and when one fails, Beam reruns the step with the error. After the last rerun, the workflow continues with the best output and marks the miss. This is a short detour into the product, so you can see the gate as a setting rather than code. Skip it if you only want the argument.

🧭 How we see it at Beam

You write evaluation criteria for a step in plain language, switch on Auto-run, set the pass mark (the docs call it the accuracy score) and choose up to three reruns. After the last rerun, in the docs' words, the "Workflow continues with best output". The task list then shows a "Validation Failure", so the miss is visible even though nobody stopped it. In the five-step model above, that is 10 tasks in 1,000 that carry on with a known miss.

That is why we recommend Consent required on the step that sends, pays or files: a person approves before anything leaves the company. The docs make the same call, listing "Final output nodes (may need human review)" among the places not to rely on Auto-run alone.

The Beam gate loop. A step runs, its evaluation scores the output against the step's criteria, a score below the accuracy score triggers Auto-run, which reruns the step with the failed criterion, up to the configured limit. After the last rerun the workflow continues with the best output and the task shows a Validation Failure. Consent required pauses the step that sends, pays or files until a person approves.

In Beam the gate is three settings on the step: criteria, an accuracy score and Auto-run. Consent required is the stop.

Two rules of thumb from our docs keep the loop cheap. A gate should fire on fewer than 1 task in 10, and if more than 3 in 10 need a rerun, fix the step's instructions rather than adding retries. A gate that fires that often is telling you the step itself is unclear. The failed cases then feed Optimize Outputs, where you "Mark what went wrong in failed outputs, and AI uses examples to rewrite prompts with better context" (Beam docs, Optimize Outputs). That way the next thousand tasks start better.

Where should you put your first quality gates?

On the one or two steps where a miss is most expensive or travels furthest, usually extraction and the final send, and then where the logs tell you. Gating everything wastes money on steps that rarely fail and buries your team in flags; gating nothing leaves you with the 77%.

Which steps need a gate?

Ask two questions of each step: how much does a miss cost, and does a later step treat this output as fact? Then match the check to the step.

If the step...

Check it with

Why

Fetches data or calls a system

A plain rule: arrived, complete, record found

A rerun will not change an API's answer

Extracts figures from a document

A gate comparing each field to the source

Every later decision trusts these numbers

Classifies or applies policy rules

A gate with the rules as the answer key

A wrong label reads as a right one

Drafts text or makes a judgment call

A gate with a written rubric

The miss is plausible, so people skim past it

Sends, pays or files

A rule on recipient and amount, plus a person's consent

It cannot be undone

Is cheap to fix later

Nothing

The gate costs more than the miss

How do you start small?

  1. Pick one workflow you already run at volume, and one step in it, usually extraction.

  2. Write five to ten criteria from real failures, one check per field, each one a stranger could score.

  3. Run the gate in scoring-only mode for two weeks: it scores every task but does not rerun or block. Compare its verdicts with your team's on a sample.

  4. Turn on reruns once its verdicts match your team's. Add Consent required on the step that sends or pays.

  5. Track four numbers per gate every week: fail rate, rerun rate, share sent to a person, and how often a person disagrees with the gate. Add the next gate where the misses show up.

What should you ask your team or vendor?

  • Which steps are checked, and against which written criteria?

  • When a check fails, what happens: a rerun with the reason, how many times, and then what?

  • What share of tasks fail a check, rerun or reach a person, per step, per week?

  • Can a person approve before anything is sent, paid or filed?

  • For any single task, can I see which criteria it passed and why?

  • How do failed cases make the step better next month?

  • What does a check cost per task, and who pays for the reruns?

What does this look like on a claims intake flow?

On an illustrative claims intake flow of eight steps, four get a judge gate (an AI model scoring the output against written criteria), three get a plain rule and one is left unchecked. Classification, extraction, the coverage decision and the drafted reply get gates, because each is a judgment a later step trusts, and the reply also needs consent before it sends. The intake, the policy lookup and the fraud threshold get plain rules, since a rerun cannot change a system's answer. The CRM log stays unchecked, because its misses are cheap to fix later.

At 10,000 claims a month, with the step accuracies in the figure (modelled), the checks raise claims handled right from 82.8% to 97.4%. Errors nobody caught fall from 1,721 a month to 260, and 218 claims a month reach a person with the failed criterion and its reason attached. The checks cost $2,300 to $2,800 a month, judge, reruns and review time included. If each error nobody caught costs only 30 minutes of rework, the 1,460 fewer errors are worth about $44,000 a month.

An illustrative eight-step claims intake flow with the check chosen for each step. Intake, policy lookup and fraud threshold get a plain rule. Classification, extraction, coverage decision and drafted reply get a judge gate, and the reply also needs consent. The CRM log is unchecked. At 10,000 claims a month the checks raise claims handled right from 82.8 to 97.4 percent.

Four judge gates, three rules, one step left alone. Claims handled right go from 82.8% to 97.4% (modelled).

How we use this at Beam

A pilot proves an agent can do a task. Quality gates are what let it do that task 10,000 times a month, with the misses caught at the step where they happen and a record of every check. We design every workflow on the assumption that some step will be wrong some of the time, so each step carries its own criteria, the pass mark decides whether it reruns, and the step that acts outside the company waits for a person. The model is a setting on each step too, so when a model changes, the step's criteria tell us whether the new one still clears the bar.

If you want to see which of your processes are ready for that, the place to start is the step where one wrong number costs the most. For the judge itself, read Moving Beyond LLM-as-a-Judge; for testing before real data, "It Works, I Think" Is Not a Test.

Quality gates make AI agents reliable in production by catching each miss at the step where it happens, for cents a task, and leaving a record that a control ran.

FAQ

What is a quality gate in an AI agent workflow?

A quality gate is a check the platform runs after a step, every time the step runs. It scores the output against written criteria and then lets the work continue, reruns the step with the failed criterion, or hands the task to a person. In Beam it is a setting on the step rather than extra nodes on the canvas.

Why do AI agents fail in production when the pilot worked?

Because errors compound across steps. Five steps that are each right 95% of the time finish only 77% of tasks right, and a pilot of 50 tasks hides that. At thousands of tasks a month the same rate becomes a stream of errors that reach customers or ledgers before anyone sees them.

How much does a quality gate cost per task?

In our model, 2 to 4 cents. The judge call is a fraction of a cent at OpenRouter's measured price, even at 100 times that for long documents. Most of the cost is the person who reviews the tasks that still fail after the last rerun, at about 10 minutes each.

Should every step in a workflow have a gate?

No. Steps that fetch data or call a system need a plain rule, since a rerun will not change the answer. Steps that are cheap to fix later need nothing. Put judge gates on extraction, classification and drafted text, and a person's consent on the step that sends, pays or files.

Figures as of 15 November 2026. Modelled values are labelled as such; vendor-reported figures are marked as vendor claims.

Heute starten

Starten Sie mit KI-Agenten zur Automatisierung von Prozessen

Nutzen Sie jetzt unsere Plattform und beginnen Sie mit der Entwicklung von KI-Agenten für verschiedene Arten von Automatisierungen

Heute starten

Starten Sie mit KI-Agenten zur Automatisierung von Prozessen

Nutzen Sie jetzt unsere Plattform und beginnen Sie mit der Entwicklung von KI-Agenten für verschiedene Arten von Automatisierungen