Deterministic AI
A skill library gives you prompts. A Business Process Engine gives you results.
A vault of Claude skills is still a model reading instructions. On a real client job, skills slid from 95% to 85% correct as the job grew to 300 steps. Our Business Process Engine held at 97.5%. If the goal is results, not prompting, put the path in code.
What our research showed
The model is good. The process is the problem.
Our dev team codes the engine for real-world work. Our Red Dev Test team builds the tests to push it as hard as real work would: same model, same brief, frozen source files, planted failures and bars set before anyone looks at the data.
97.5%
Correct at 300 steps on a real client job with Pressfit BPE, against 85% for Claude + skills and hooks
6x
As many wrong results from Claude + skills and hooks as from Pressfit BPE at 300 steps
3.4x
Swing in tokens from one run to the next for Claude alone on the same 70-step job
27x
Fewer tokens for Pressfit BPE than Claude alone on a 30-minute, 14-step job
Why a skill library stalls
More skills means more prompts. Not more control.
Skill libraries are everywhere right now, and we built one too. They help, and we still use skills. But a skill is a prompt with a name. Load up a library and you get the model's opinion faster, not your method run the same way every time.
If you deliver Claude's opinion to customers and call it your work, nobody needs you for that. That is why we are engineers, not prompters.
- A skill is still an instruction
- A model reads instructions. It doesn't execute them the way code does. Every run reads the same skill a little differently, and every team writes its own.
- The model still runs the process
- With a skill library, the model decides the order of the work. Across more than 200,000 simulated conversations, Microsoft and Salesforce researchers saw performance drop 39% when a task was spread over several turns.
- It rewrites the work every run
- On our 70-step job, Claude alone wrote a new program to run it every time, 344 to 552 lines long. The engine ran the same 162 lines of code every run.
- Consistency gets bought with tokens
- Retries, rereads and restarts are how a skill-driven run catches up. Telling Claude to read every file twice used 2.7 times the tokens of Claude alone.
Skill library vs BPE
Same model. Same brief. A different result at scale.
Skills hold up on a short job. On our short test, Claude + skills and hooks matched the engine with one ranking order in ten runs. The gap opens as the job grows, and real business processes are long.
| Claude + skills and hooks | Pressfit BPE | |
|---|---|---|
| What runs the process | The model, reading your skills | LangGraph and Python, server side |
| Short job, ten runs | One ranking order | One ranking order |
| Real job at 20 steps | 95% correct | 100% correct |
| Real job at 300 steps | 85% correct | 97.5% correct |
| How the output is checked | Hooks check the format against a template | The deliverable runs against acceptance criteria and test cases before delivery |
| Where the data comes from | A subset of documents handed to the model | Each step pulls the data the job needs and reuses the cache from earlier jobs |
Longer jobs
The longer the job, the wider the gap.
We took a real Playbook job for a national equipment rental company and ran it at 20 steps and again at 300. Pressfit BPE barely moved. Both Claude setups slid. At 300 steps, Claude + skills and hooks got six times as many results wrong, and Claude alone twelve times as many.
Every extra step is another chance for the model to lose the thread. In the graph, code holds the thread.
Share of results correct
Pressfit BPE
Claude + skills and hooks
Claude alone
The token spin
You can't budget for a model that improvises.
When the model runs the process, it decides how much to read, what to rewrite and when to retry, so spend swings from run to run. When code runs the process, the same path costs about the same every time.
The real cost is the rerun. A run that comes back with a different answer means another full run, and someone to decide which answer is right.
Lowest to highest tokens per run
Two-hour, 70-step job
Both got all 60 results right in every run.
Long vendor review
The engine used more tokens here, about 1.8 times Claude alone, but the same amount every run, and it made the same calls every run.
For the executives and CFOs
Stop tracking tokens spent and track cost per accepted deliverable. Take a workflow where the output must be redone 30% of the time. That is about 1.43 executions for every accepted deliverable. Bring the redo rate down to 5%, and it is about 1.05, roughly 26% fewer executions before you gain any efficiency inside each run.
The redo rates are an illustration, not a result from our test.
Redone 30% of the time
1.43
executions per accepted deliverable
Redone 5% of the time
1.05
executions per accepted deliverable
The deterministic path
Engineers encode the method. The graph runs it. Tests gate it.
Our Business Process Engine is a LangGraph path written in Python and run server side. Code does most of the work. Claude only gets the steps that need writing or judgement. Before anything is delivered, it has to pass the tests we wrote for it. If it fails, it doesn't ship. It goes back to the dev team.
Here is discovery, the first phase of a Playbook, built as a graph from our client-discovery skill. It ran unattended to the first approval gate for four clients.
- 103
- Code steps
- 13
- AI agent steps
- 15
- Stops answered automatically
- 4
- Fan-outs, one agent per item
Start from the skills you already have
Your skills hold the method. Turn each one into a graph spec: the steps, the order, the state that passes between them and the decisions along the way.
Split the work into code, content and decision
Every step that can be deterministic runs as Python. Prose an LLM needs to write goes to the model. Judgement calls go to a decision model.
Put the path in LangGraph, on the server
The graph controls the order of operations, keeps an explicit state and decides exactly where models and outside tools belong. It runs server side, not in a chat session.
Write the tests before the first run
Set acceptance criteria for every deliverable and the pass mark before you look at the data. Nothing ships until the deliverable passes.
Let it pull data, not just read documents
Don't harness the model to a fixed set of files. A coded path can still pull what each job needs and reuse what earlier jobs gathered.
Measure cost per accepted deliverable
Tokens per run hide the reruns. Count what it costs to get a deliverable that passes.
A real job
Same client. Same phase. Skills vs the engine.
In October we ran the equipment rental company's discovery with headless Claude, using MCP to drive our skills. In November we ran the same phase through Pressfit BPE. The graph pulled fresh data, 20,000 ranking keywords up from 12,000, and handed the approval gate far less to sort by hand.
| At the first approval gate | Claude driving skills | Pressfit BPE |
|---|---|---|
| Keywords left undecided | 4,484 | 68 |
| Sites approved that don't rent equipment | 7 | 2 |
| Competitors rated direct | 11 | 19 |
Start with our toolkit
Already have a skill library? Turn it into a graph.
We want you to learn from our testing. Check our numbers, copy our templates and turn your own skills into a deterministic path. See the results on one page.
Work with us
If the goal is results, not prompting, we can build the path with you.
Our dev team and Red Dev Test team will take your skills, map the process, build the coded path and write the tests your deliverables must pass before they ship. Fill out the form and we will send you the starter kit and get in touch.
Prefer email? Reach the team at redevteam@pressfit.ai.