AgentRun: How Grep.ai Turns Agents Into Cheap, Auditable Workflows

Most "agent replaces a job" pitches stop at replacing it. Grep.ai's AgentRun, published September 19, 2026, does something more specific: it has an agent do a repetitive job the expensive, general way once — then writes itself out of the loop for most future cases, compiling what it learned into a small, inspectable program instead of running a full agent session every time.

The company built this for a real problem it's had since 2023: enterprise agents that made good demos, then needed static workflows bolted around them to actually work in production, then needed agents again once harnesses like the Claude Agent SDK got good enough to matter. AgentRun's pitch is that this back-and-forth was solving the wrong problem — the fix isn't picking agent or workflow, it's having the agent author the workflow.

TL;DR — what people are actually asking

The seam AgentRun is built around

AgentRun's design leans on a framing from 12-Factor Agents: take a tool call apart and there are two different things inside it — a decision (which action, with what arguments) and an action (the code that carries it out). Nothing about the decision actually needs a text generator; it needs something that can pick an option well and say how confident it is in that pick. Follow that seam through a long compliance procedure and it's everywhere: mostly decisions and mechanical steps, with only occasional places where a person — or an agent — genuinely has to go look something up.

AgentRun builds three kinds of program step along that seam: an agent where something has to be found or done in the world, a typed question (a Jev call) where something has to be decided, and plain code where the step is purely mechanical. Historically, all of that — the searching and the deciding — ran through the same instrument: a language model with a prompt. That's where most of the cost and most of the opacity came from. Giving decisions their own engine is the actual innovation here, not a new agent loop.

How the compilation actually happens

The workflow-authoring process runs in three stages:

1. Learning mode. The agent does the job by the book, using whatever tools and reasoning it needs, and leaves notes as it works — not about the specific case, but about the job itself. Which pages mattered, which didn't, what would have let it finish faster.
2. Workflow authoring. After several runs, the agent uses its own traces and notes to write a workflow in AgentRun's own DSL — a small language of agents, code, typed questions, and the control-flow shapes (map/reduce, loop-until, escalate) that hold them together.
3. Progressive routing. As the workflow takes shape, AgentRun routes a growing share of new cases through it instead of the full agent, continuing to tune the workflow as more traces arrive, until most cases never touch a general-purpose agent session at all.

Grep.ai's own AML example is concrete about what this looks like end to end. An analyst reviewing a sanctions-screening alert opens every one of 24 name-matched profiles, checks age, location, occupation, and family against the customer, and writes up a determination — about an hour of work, or 826 tool calls and 51 minutes for a first-pass agent doing the same thing by the book. The agent's own notes from that run — "cards 9 and 21 decided the whole case," "card 3 was clearly not our customer, I didn't need to open it" — get compiled into a workflow: a Jev classify node asks whether each card could stop the customer at all under the bank's rules; only the cards that could are researched; a code step tracks whether anything left open could still change the verdict; anything genuinely ambiguous escalates to a judge agent. Same 24 cards, second time through: 2 cards opened, about 30 tool calls, roughly 3 minutes.

Where Jev fits, specifically

AgentRun is described as the first harness built around TypeSafe's Jev, and the fit is direct rather than incidental. A Jev question never sees the full 508-line procedure — it gets one narrow question with the bank's specific criteria written into it, plus one record, and answers in about 150 milliseconds for a few hundred-thousandths of a dollar with a calibrated confidence attached. That last part matters more than the speed: a 0.97 and a 0.44 get treated differently downstream, with the threshold living as a number in code rather than a feeling buried in a model's free-text reasoning.

Four typed-question shapes carry most of the decision load in the AgentRun DSL — Route (choose a branch), Classify (fill in a structured output's fields, each with a probability), Sift (yes/no over every item in a list at once), and Pick (choose one item from several, or none). A fifth pattern, verify, turns any agent's own output schema into a post-hoc checklist: when an agent submits an answer, Jev checks each claimed field against the evidence actually cited for it, and anything unsupported gets kicked back to the same agent session rather than silently shipped. For more on that verification pattern generally, see Jev as a cheap verification checkpoint in agent pipelines and how Jev actually computes an answer.

The numbers, and why the saving isn't just "a smaller model"

Grep.ai tested five arms on the same 100 alerts before running the full 1,000-alert tuning pass:

The gap between the second row and the fourth is the actual point: swapping in a cheaper model that reads the same pages (row 2) barely moves the number. The real saving comes from not reading pages whose content couldn't change the outcome in the first place — 30% of card look-ups never ran at all in the tuned workflow, and a full identity lookup on the customer was only needed in 8% of cases instead of 100%. Accuracy didn't pay for that saving; the compliance judge scored the tuned workflow at 95%, up from 90% on the full-agent baseline, because each tuning pass removed a place where the agent could wander into an irrelevant page and get distracted, not because it started skipping real work.

Scaled to volume: the full 1,000-alert tuning run cost $1,049 in model usage against a $2,884 cost for running the same 1,000 alerts on Opus 5 alone — recovered by roughly alert 150. Grep.ai says the same pattern at 100,000 alerts (a bank's real monthly volume, not a demo size) comes out to about $26,000 on the tuned workflow versus $290,000 on the frontier-model-only approach.

Why the audit trail matters as much as the price

For regulated industries, AgentRun's more interesting claim isn't the cost line — it's that a workflow answers the four questions a model-risk team asks of any automated decision (which model made it, on what inputs, under which policy version, can you show me) by construction, because each step names its own model, inputs, and the specific questions and probabilities behind it. A model swap becomes a change to one node, evaluated on that node's own inputs with a before/after kept — swapping the research model doesn't touch the judgment logic, and a replay proves it without re-running the whole investigation. That's a genuinely different governance posture than a single long agent session whose reasoning has to be read out of a chain-of-thought transcript after the fact.

What this means if you're running agents on repetitive work

• If your team has an agent doing the same category of task thousands of times, the AgentRun pattern — do it once expensively, compile what worked, keep the agent for exceptions — is worth evaluating against your own cost-per-completed-task, not against a generic benchmark. The saving here came from routing and early-stopping logic specific to this procedure, not from a universally better model.
• If you need to explain a decision to an auditor or regulator, a workflow of named, typed steps with retained probabilities is a fundamentally easier artifact to hand over than an agent's chain-of-thought transcript, independent of whether cost is a concern at all.
• Treat "smaller model, same prompt" and "different routing logic" as separate levers. Grep.ai's own numbers show the first lever alone barely moves cost; the second lever is where the actual saving lives.

Related on explainx.ai

• How Does Jev Actually Work? RLCD and the "System One" Mechanism
• Jev as a Cheap Verification Checkpoint in Agent Pipelines
• What Is Harness Engineering for AI Agents?
• How to Integrate Jev for Agent Routing
• What Is a System One Model? AI, Explained
• TypeSafe AI: Jev and System One Models Launch
• AI Evals for Engineers and PMs, Explained
• Loop Engineering for Coding Agents

Primary source: Miguel Ríos Berríos, "AgentRun: a harness for repetitive knowledge work" (September 19, 2026)

This post reflects Grep.ai's own September 19, 2026 announcement and self-reported benchmark figures. Cost and accuracy numbers (the $2.89-to-$0.25 AML figures, the 90%-to-95% accuracy range) come from Grep.ai's own testing, not an independent audit. Follow @explainx_ai for updates.