Your SOP reads fine to a human.Can an agent actually run it?
A person fills the gaps in a procedure with judgement and asks when stuck. An autonomous agent loops, fakes success, or runs past a failure it was never told to stop on. This gate grades an existing SOP step by step and returns RUNNABLE, TIGHTEN, or NOT EXECUTABLE — and one step with no success test or no stop condition holds the whole thing.
The SOP that runs your team won't run your agent.
with no stop condition is enough. The agent runs past a failure a human would have caught, and you find out downstream.
is the kind of instruction a person reads past and an agent can't. Ambiguity a human absorbs is a halt for an agent.
means the agent can't tell whether it's done — so it loops, or declares a false win and moves on.
An overall "this looks clear" read is exactly what misses it, because the failure is local — one step with no checkable success or no stop path. This gate forces you to look at every step and won't let a high average hide the one that strands the agent.
Grade an SOP step by step — and watch one open-ended step hold the whole thing.
| Step | Action | Tool | Branches | Success* | Stop* | Refs | Score | Verdict |
|---|---|---|---|---|---|---|---|---|
| S1-lookup-order | 100 | READY | ||||||
| S2-verify-eligibility | 100 | READY | ||||||
| S3-check-refund-window | 100 | READY | ||||||
| S4-issue-refund | 82 | BLOCKER ⛔ | ||||||
| S5-notify-customer | 92 | READY | ||||||
| S6-log-outcome | 100 | READY |
* = gate signal. A step with no success criterion or no stop/escalation blocks the whole SOP. The full kit ships this engine, a workbook that reproduces it, two playbooks, and a worked sample. A readiness aid for your own SOP documents — it grades the document, never people, and never runs an agent. Not legal advice.
REFUND-SOP score 96/100 [ NOT EXECUTABLE ]
steps: 6 READY 5 / GAP 0 / BLOCKER 1
GATE FIRED: a step has no defined success criterion or no stop/escalation path.
fix first: S4-issue-refund
S1-lookup-order 100/100 READY
S2-verify-eligibility 100/100 READY
S3-check-refund-window 100/100 READY
S4-issue-refund 82/100 BLOCKER <- gate
S5-notify-customer 92/100 READY
S6-log-outcome 100/100 READYThe refund SOP scores 96/100 and still reads NOT EXECUTABLE: step S4 (issue the refund) scores 82 on its own but gives the agent no way to stop and escalate if the payment fails. The score is context; the gate is the verdict.
One engine, one workbook, two playbooks, one worked SOP.
A zero-dependency Python CLI: feed it a steps CSV and it returns per-step READY / GAP / BLOCKER, the SOP verdict, the keystone gate, and the one step to fix first. Multiple SOPs roll up to a library posture. Runs anywhere Python does; nothing uploaded.
Start Here → Dashboard → Step Grader. Enter the six marks per step; the same score, the same gate, the same verdict — live formulas, weights summing to 100. Opens in Excel, Google Sheets, or Numbers.
How to break an SOP into agent-sized steps and mark each one honestly — the reviewer discipline that makes two graders agree on what's runnable.
What to do with a NOT EXECUTABLE: add the success test, define the stop/escalation trigger and owner, name the tool and the branches — and re-grade.
Three rules keep the verdict honest.
A step with no success criterion or no stop/escalation forces NOT EXECUTABLE regardless of score. The gate does work the average can't: it finds the one step that strands an agent, even in an otherwise polished SOP.
Action clarity, named tool, decision branches, and resolvable references shape the score. Success criterion and stop/escalation are the gate — a zero on either is fatal for that step, because an agent can't run what it can't verify or halt.
No AI grades your SOP, no benchmark is baked in, nothing connects to your systems. The engine applies the same scoring and the same gate every time, so the result is reproducible and defensible.
A readiness gate for SOP documents, not an agent builder.
- A deterministic, offline gate for existing SOPs — the upstream check before you wire one to an agent.
- A step-by-step verdict with a keystone gate that catches the one step an agent can't safely run.
- The agent-era companion to the AI-First SOP Engine (which authors human-run procedures).
- Not an agent builder, an orchestrator, or a runtime — it grades the document, it doesn't execute it.
- Not a grader of people; it scores the SOP's executability, never the author or operator.
- Not a safety certification. A readiness aid for your own SOPs; not legal, safety, or compliance advice.
Anyone about to put an agent on a real process.
Author it, gate it, run it.
Authors a new SOP from a screen recording. Write the procedure with this; gate it for an agent with the readiness gate.
ViewThe operator's go/no-go on the agent's guardrails (approval, logging, rollback). This gates the procedure the agent runs.
ViewEvaluates a running agent's trajectory in CI. This is the upstream check: is the SOP even runnable before you wire it up?
ViewAnswers before you buy.
Because the score is context and the keystone gate is the verdict. The Agent-Executable SOP Readiness Gate grades every step, but a single step with no checkable success criterion or no stop/escalation path forces NOT EXECUTABLE no matter how high the average is. The shipped refund-SOP sample scores 96/100 and still reads NOT EXECUTABLE because step S4 (issue the refund) gives the agent no way to stop and escalate if the payment fails. A high average can't paper over the one step that strands the agent — and that's the point: the failure is local, so the gate makes you look at it.
A human fills gaps with judgement and asks when stuck; an agent loops, fakes success, or runs past a failure it was never told to stop on. So the kit grades each step on the six things an agent needs and a human improvises around: an unambiguous action, a named tool or system, explicit decision branches, a checkable success criterion, a stop/escalation path, and resolvable references. Two of those — success criterion and stop/escalation — are the gate, because an agent literally cannot run a step it can't verify or safely halt.
Grade it, fix the gate steps, re-grade. Break the SOP into agent-sized steps and mark each on the six signals (0/1/2). The engine returns per-step READY / GAP / BLOCKER, the SOP verdict (RUNNABLE / TIGHTEN / NOT EXECUTABLE), and the one step to fix first. For any BLOCKER, the fix-the-step runbook walks you through adding the success test, defining the stop/escalation trigger and owner, naming the tool, and spelling out the branches — then you re-grade until it clears. The included playbooks make two reviewers agree on what's runnable.
Per step: READY (an agent can run it), GAP (it works but something's underspecified), BLOCKER (no success test or no stop path — fatal). Per SOP: NOT EXECUTABLE if any step is a BLOCKER; RUNNABLE if the score clears 85 and every step is READY; TIGHTEN for everything in between. Grade several SOPs and they roll up to a library posture so you can see which procedure to harden first before you wire any of them to an agent.
No. It grades the SOP document you describe, entirely offline — the Python engine and the workbook both run on your machine with nothing uploaded and nothing connected to your systems. It's not an agent builder, orchestrator, or runtime; it's the upstream readiness check before you wire a procedure to an agent. Pair it with the AI-First SOP Engine (which authors procedures), the AI Agent Go-Live Readiness Gate (which grades the agent's guardrails), and the Agent Reliability Harness (which evaluates a running agent in CI).
You get a runnable zero-dependency Python readiness engine, a workbook that reproduces it (Excel / Google Sheets / Numbers), a step-review playbook, a fix-the-step runbook, and a 6-step worked SOP — a one-time purchase with lifetime access and 12 months of updates. It's a readiness aid for your own SOP documents; it grades the document's executability, never people, and never runs an agent. It is not a safety certification and not legal, safety, or compliance advice — use it alongside your own review before putting an agent on a real process.
Find the step that strands the agent
before the agent does.
Grade your SOP step by step before you wire it up. One purchase, lifetime access, 12 months of updates. $79, once.
Sold by RedHub AI LLC · Secured by Stripe · redhub.ai