Agents think every time. What if you only thought once?

Every time an AI agent handles a task, it re-reads its instructions, reasons, calls its tools, checks its work and answers. That is what makes agents so flexible. It is also what you pay for, on every single run: in time, in tokens and in money.

For a one-off question, that is the right tool. But a good share of the work inside a company is not one-off. Checking this morning's orders, verifying an invoice, routing a request: the same task, with the same rules, hundreds of times a month. An agent does it as if it were the first time. A thousand runs, a thousand rounds of reasoning, to reach the same conclusions a thousand times.

We wanted to measure what that choice costs, and what happens if you do it differently.

The idea: think once, then run

At AgentMaurice we call this other approach compiled AI. It fits in one line: your assistant designs, Maurice compiles.

The person who knows the task describes it, in their own words, to the assistant they already use. Maurice turns it into a tool: a workflow whose rule-based steps become code. The AI reasons once, at design time. After that, the tool runs without calling a model again, except for the steps that genuinely need judgement.

On paper, that sounds obvious. We wanted numbers.

The test

We picked a deliberately ordinary small-business task: checking a customer order before it is picked. The company is fictional, a fresh-produce distributor called Breizh Primeurs. Each order is checked against ten rules: known customer, address, delivery date, item, quantity and pack size, unit, price, origin, free-shipping threshold, and a free-text customer remark to interpret. Nine rules are exact; the tenth requires judgement on text.

We generated 1,000 orders, plus 250 extra runs to check whether results stay identical from one run to the next. Both approaches received exactly the same inputs.

• On one side, an agent: a standard tool-use loop on Anthropic's API, with the ten rules as instructions and prompt caching turned on. We ran it on two models, Claude Sonnet 5.5 and Claude Haiku 5.5.
• On the other, Maurice: the text of the same rules, preceded by a short business brief, was given in plain language. Writing included, that took about 9 minutes. Maurice built six workflows, deployed without a single manual edit. The nine exact rules run as code. For the free-text remark, Maurice itself chose to keep a call to a judgement model.

The results

Three things struck us.

Cost. Seven cents for a thousand checks, against just over one euro with the cheapest model and more than sixteen euros with the most capable one. Building the tool cost $1.64; it pays for itself after 92 runs compared with the Sonnet agent, and after about 1,400 compared with the Haiku agent.

Consistency. The compiled tool never got an exact rule wrong, and it returned the same result on every repetition. The agents made their mistakes exactly where you would not expect them: on the unit, the price or the origin, rules a program applies without hesitation. Maurice's 11 errors all came from the single rule that needs judgement: the judgement model it calls at that step flagged harmless remarks as problems. On that one rule, the Sonnet agent judges better. A more capable model for that single step would probably reduce those errors at a slightly higher cost; we did not measure it.

The lesson fits in two lines: to apply a rule, code beats an agent; to judge a text, you need a model, and Maurice only calls one there.

Speed. One second per check instead of seven. On a task a team waits for every morning, that shows.

What this test does not show

We would rather say it ourselves.

• It is one scenario, and a synthetic one. A thousand orders give an order of magnitude for this task, not a law. On a task made mostly of free text, the gap would be smaller, because more steps would keep a model call.
• Maurice is not "AI-free". In this test every run keeps one call to the judgement model, even for orders without a remark. A more precise instruction would have avoided that; we did not give one, and we measured the tool exactly as Maurice built it.
• This is execution cost, not a full bill. If you dedicate a server to this one tool, its fixed cost counts: the compiled tool then beats the Sonnet agent only above roughly 3,300 runs a month. On the computer of the person who uses it, that fixed cost disappears.
• The agent runs with default settings. A tuned agent, with less context or batch processing, would cost less. The cost of changing a rule was not measured either.

And there are cases where compiled AI is not the right tool: a question you will ask only once, a writing task, open-ended research. There, the assistant alone does the job very well.

Not against agents: behind them

This test does not say "agents are over". It says we often ask them to redo, in a loop, work that could be done once.

Compiled AI does not replace your team's assistant; it sits behind it. Maurice installs from the assistant or tool people already use: Claude Code, Codex, Cursor, Grok Bot, Hark… You start on one computer, with one task. When the tool is useful, you share it. And when several people adopt it, the company connects everything and stays in control of who uses what.

It is the idea we have defended from the start: the next generation of business software won't be built for your people, it will be built by them. This test adds a detail that matters: it can also cost next to nothing to run.

Run the test yourself

Take your own repetitive task, run it with your agent, then compile it with Maurice. And tell us what you find, especially if your numbers don't look like ours.

Mikael Morvan, founder of AgentMaurice