If your board is telling you to put agentic AI everywhere, I have bad news. You are going to hit a wall, and you are going to hit it with the token bill climbing and the headcount staying exactly where it was.
We found that wall by testing for it before our clients ran into it, and spent weeks measuring it. Here is why I believe most AI implementations are failing: a probabilistic system is running business processes that need predictable execution, and nobody is controlling the process. This post is the story and the data.
If you sign the checks, the first half is for you. If you build the systems, skip to the test.
Prefer the numbers at a glance? View the research as an infographic.
Part 2 is out. Stop Prompting and Start Engineering (Part 2) holds this research up against Anthropic's updated Claude Code playbook, with new repeatability and cost data. Every term from both posts is in our glossary.
The Pitch Everyone Bought
Everyone is talking about AI productivity. Fewer people, faster work, lower cost. Agents that do the research and the writing while the rest of us sleep.
It sounds fantastic, and we wanted it too. Pressfit.ai had a real business problem, and we weren't shopping for another demo.
Here is the problem. Our platform reads a customer's website and studies their competitors. It checks search rankings and finds the content gaps, then builds a strategy for getting seen in traditional search and in AI answers. That is not a generic SEO report. The output must be specific to the customer and defensible, and it has to come out the same way every time.
That last part turned out to be the hard one.
The Bill Nobody Wants to Discuss
Here is how the AI productivity story plays out inside most companies. A model produces the first draft. Then somebody reviews it and catches what's missing. Somebody fixes what's wrong and reruns what failed. Every rerun costs more tokens, and every review costs the same salary it always did.
Tokens spent are a bill. Calling it a productivity number doesn't make it one.
A company with tens of thousands of people doing repeatable work can trim teams with good prompting and good skills. Most of us can't. An accounting team will finish faster, work fewer hours and still get paid for all eight. For most of us, the result is a bigger token bill and the same work.
Before you dig in, here is some AI jargon you need to know: see the useful terms.
Claude. Anthropic's AI model. Every test uses the same model, so the only thing that changes is what surrounds it.
Prompt. The written instructions you give the model.
Agent. A model that decides its own next step. It reads, calls tools and writes, and it keeps going until it thinks the job is done.
Template. A fixed outline for the deliverable: which sections it has, which fields it needs and how long each part can be.
Skill. A saved set of instructions for one part of a job, which Claude loads when it needs it. Think of it as a playbook page written for the model.
Hook. A check that runs automatically at a set point, for example after Claude writes a section, to make sure the output matches the template before the work moves on.
MCP (Model Context Protocol). A standard way to plug a model into tools and data, like a universal adapter. With MCP, Claude can search, read files or call another system. MCP gives the model access. It doesn't decide the order of the work.
HITL (human in the loop). A person checks the AI's work before it moves on or goes out the door. Teams do it because the model's output isn't reliable enough to ship on its own: someone has to catch what's missing and fix what's wrong. It raises quality, but every deliverable still waits on a person, so you don't get the time savings you were promised.
Headless. Running Claude with no person at the keyboard, on a server or in a container in the cloud.
Deterministic. The same input produces the same steps and the same result every time. Code is deterministic. A model on its own is not.
Business Process Engine (BPE). Software that runs a business process as a defined series of steps: what happens first, what comes next, what to do when something fails, and when a person needs to approve. The process lives in code, not in a prompt.
LangGraph. An open-source framework for building that kind of workflow as a graph. Each step is a box, the paths between the boxes are written in code, and the graph keeps track of where the job is, so a stopped run can pick up where it left off.
Graph. The workflow itself, drawn as steps and the paths between them. In this post, "the graph" and "the engine" both mean Pressfit BPE.
Tokens. The units AI usage is measured and billed in, roughly pieces of words. More tokens means a bigger bill.
Run. One full pass of a job, from start to finish.
These are the names we use in every chart:
Claude alone. Claude gets the brief and the source files, and nothing else. It decides how to do the job, step by step. This is how most teams use AI today.
Claude + template. Claude alone, plus a template that sets the structure of the deliverable.
Claude + skills and hooks. The template, plus our skills for each part of the job, plus hooks that check Claude's output against the template before it moves on. This is Claude with everything turned on.
Pressfit BPE. Our Business Process Engine: our own code execution, running on LangGraph, with MCP connecting it to tools and data. Code runs the steps in a fixed order and keeps the state, while still pulling the data each job needs and reusing what earlier jobs gathered. Claude works only at the steps that need judgment or writing, and every result has to pass the Red Dev Test team's tests before it is delivered.
We Tried Everything on the List
Step one: laptops, Claude and a human in the loop. We started where most teams do, on our laptops with Claude. There was no reason to build out a whole system before we had paying customers. So we built skills and saved them. Part of the team owned one set of deliverables, and another part owned the rest.
A Pressfit Playbook isn't a list of top queries about your company. We look at your website, several of your competitors, your content and theirs, and the search keywords for every key player. Then we give you a plan to rank in AI Overviews and in search, and show you how to do it. For large customers, one of these jobs could run up to 10 hours.
We kept a human in the loop to review the work. And you know what? It was decent. Sometimes really decent. Some reports were excellent. Others missed something important or made a recommendation without the evidence behind it. We weren't dealing with an AI that couldn't do the work. We were dealing with a system that couldn't do the same work to the same standard every time, and that is a very different problem.
The human in the loop raised quality. But that wasn't the holy grail we're all chasing in our companies. As a bootstrapped company, we had to scale quality deliverables through code. If someone still had to read every deliverable before it went out, we weren't going to get there. If your AI workflow needs an experienced person to inspect every output, how much productivity have you actually unlocked?
Step two: take the human out. As soon as we nailed the process and had a few dollars from customers, we went big. We took the human out and ran the skills autonomously on our desktops. We were getting somewhere, but nowhere fast. If a 10-hour job running on a desktop failed, there was no way to recover. We just started over. Clearly not the best plan.
Step three: Claude headless in the cloud. The next best plan, or so we thought, was Claude running headless in the cloud. Our skills ran inside a container, connected to our tools and data through MCP, the Model Context Protocol. The idea was simple: give the model good tools and good data, then let it build the deliverables. And we could build in checkpoints for failures.
The checkpoints were great. We still hit failures, just different ones, and now we also had to wrangle APIs, containers and MCP usage. That is all good stuff to get dialed in if you want a repeatable, scalable process. It led us to break every function into phases, with phase orchestration so we could retry no matter where a run failed.
Next, our certified AI architects took more control of the environment. They split the work into three buckets: code (deterministic), content (prose an LLM needs to write) and decisions (calls our decision model, Jev, can make). We added templates, plus hooks that check the output against those templates. Things improved again.
Then we hit the next problem: the model's effective context. Information got dropped or compressed, and the same instructions got read differently from one run to the next. A document being available did not mean the model would use the right part of it at the right moment. Instructions that looked perfectly clear to us did not always turn into consistent execution. We were deep in the bowels of Claude: where it placed files, how memory compaction treated its Python scripts, and how it picked up context and went off the rails.
We aren't the only ones seeing this. Researchers at Microsoft and Salesforce ran more than 200,000 simulated conversations across the top models. When a task was spread over several turns instead of given all at once, performance dropped 39% on average, and most of that drop was unreliability rather than lost skill. Once a model takes a wrong turn, it gets lost and doesn't recover. (LLMs Get Lost in Multi-Turn Conversation)
So we cleaned up the documents and tightened the memory strategy. Fingers crossed.
Less slop? Yes. No slop? Close, but no cigar. Less slop isn't no slop, and your customers will notice the difference.
All this wrangling of retries and output, and checking Claude's results against our skills and hooks, still wasn't as good as we wanted. And we weren't delivering anything the customer couldn't just prompt for themselves. We wanted our knowledge from years in marketing and engineering to shine through. That was the only way to deliver on our original thesis: replace half of an agency's repetitive deliverables with code, and free the team for the work AI doesn't do well. Headless wasn't the answer either. We wanted something more cost-efficient that delivered the same results every time. Relying on the LLM alone gave us good results, but varied ones.
Step four: graphs. That is where we moved to graphs. A graph isn't deterministic on its own, but it let us define the code path. We got the results we wanted, and the results got better as we ran more Playbooks. The graph still gets smarter as it runs: more data and more runs keep improving the work. What it doesn't do is run on its own, where an agent either gets better or fails and forces the dreaded restarts and do-overs that run up token usage. And dealing with paused jobs, executing retries and wrangling containers went away.
Why Prompt Engineers Alone Are a Disservice
Here is where I say something that will annoy people. Using Claude or ChatGPT alone, or leaning on prompt engineers alone, to deliver work to customers is a disservice to those customers. They get the model's opinion instead of your expertise, and they could have gotten that on their own.
If you are using Claude or ChatGPT to deliver to customers and calling it your work, you're delivering Claude's opinion, not yours. Nobody needs you for that.
It gets worse inside your own walls. Give five people the same tool and the same data for the same decision, and they can come back with different answers. Templates and skills with hooks help, and we use them, but they are instructions. A model reads instructions. It doesn't execute them the way code does. Every team writes its own, and every run reads them a little differently, so in our experience the variation still shows up across teams.
We gave Claude the same brief and the same files on the same model, and across ten runs it gave us seven different answers. We know that pattern is real because we've seen it with our clients while helping them fix their company-wide prompts.
Deterministic results backed by testing are required if you want consistent work, and consistent work is where the time savings and the efficiency gains come from.
Stop Prompting and Start Engineering
Our certified AI architects and I had a spirited discussion about this. It was my version of heated, which isn't very heated.
During the Boeing DCAC/MRM days in the 1990s, I worked on computer-aided process planning: automating the workflow of building an airplane, and accounting for every part and every step to keep deliveries on time. Nobody asked a system to improvise how to assemble a part. We asked the workers how it was done, documented the process and coded it. Yes, everything old is new again. For what it's worth, the teams hated the automation then too. But it didn't take anyone's job, and it did help.
We decided to treat every deliverable the same way, so we built our own business process engine on graph orchestration, using LangGraph.
Our engineers encode the methodology, and the graph runs it. It controls the order of operations, keeps an explicit state, and decides exactly where models and outside tools belong. Every deliverable is tested against acceptance criteria before it ships.
The model still does what models are good at. It just doesn't get to decide the whole process.
Here is what that looks like for discovery, the first phase of a Playbook. We built the graph from our client-discovery skill and its real runs. It has 135 steps: 103 are code, 13 are AI agents, 15 are decision points the graph answers on its own, and 4 fan out with one agent per item. After a few rounds of fixes, it ran unattended to the first approval gate for four clients. Seventeen steps never ran at all. Most of those are recovery paths for failures that didn't happen.
The Wall
This section is for the executives and the CFOs who are pushing for agentic AI everywhere.
You are going to hit a wall, and the models aren't the reason. They are very good. A model on its own is a probabilistic system, and you are asking it to run business processes that need predictable execution. Today's tools alone can't deliver that without a real workflow engine around them. If your AI program isn't paying off the way the board was promised, that is probably why.
I think Anthropic and OpenAI know this. I think whichever of them first ships a true workflow engine, one that runs a long job the same way every time and can prove it, will unlock the real gains everyone has been promised. Until then, you need deterministic compute. Otherwise, you are paying a probabilistic system to guess and paying people to check the guess. Google is already doing this with its Agent Development Kit workflows, and it sees the writing on the wall. Can it get the adoption Anthropic and OpenAI have?
Do the math your CFO should be doing. 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. Those rates are an illustration, not a result from our test.
Cut the unnecessary model calls and the retry loops, and the savings compound. A deterministic workflow can carry more orchestration overhead and still cost less per accepted deliverable when it avoids the reruns. That is the case we are testing now. Stop tracking tokens spent and start tracking cost per accepted deliverable.
The Part Nobody Is Counting
There is a cost here that never shows up on your invoice. Every rerun is compute. Every time a sloppy autonomous prompt loads the same context again or wanders off to rewrite code it already wrote, a data center somewhere spins a little harder.
Multiply that across every company chasing agents everywhere, and you get a lot of demand that exists only because the work wasn't controlled. The infrastructure we have today has to absorb all of it, and that creates friction for everyone trying to scale, including the people who are doing it right.
I need to be straight about what we've measured. The details are in the tests below. On the short job, a defined path finished about 45% faster and gave one answer instead of seven. On the long vendor review, the engine used more tokens per run than Claude alone, but the same amount every run, and it made the same calls every run. On the script-heavy jobs, it used 3 to 27 times fewer tokens. And at 300 steps, it got 97.5% right, against 85% for Claude + skills and hooks and 70% for Claude alone. What we haven't measured yet is cost per accepted deliverable across counted runs. I believe the demand for data centers will not be as great if more of this work runs on defined paths. That is a belief, and we are going to test it.
How We Tested
The rest of this post is for the people who build the systems.
These results come from two teams. Our dev team codes the business process engine for real-world work. Our Red Dev Test team builds the tests, and its job is to push the engine as hard as real work would: frozen source files, planted failures, real-world variables and bars set before anyone looks at the data. When a test finds something, that is the test doing its job, and it goes back to the dev team. That is how we learn, and it is why we publish what we find.
Every test runs on the same model, with the same brief and the same source files. The setups are the four defined in Useful Terms at the top: Claude alone, Claude + template, Claude + skills and hooks, and Pressfit BPE.
On one long test, we also ran Claude, fixed-prompt script: a script that sends Claude the same rulings prompt every time, to see how far fixing one prompt gets you.
Why our own code instead of MCP alone. We tried MCP alone and saw the issues firsthand, so we went with LangGraph and our own code. The real job below shows why. Our next experiments and tests will bring in Google as well.
The Test
The discovery graph's results were good enough that I was fine calling it the right approach. Our Red Dev Test team wanted proof, so they built the tests. We compared four approaches on the same job: Claude alone, Claude + template, Claude + skills and hooks, and Pressfit BPE.
Each one got the same brief and the same frozen source files, run on the same model.
Engineers, here is the full setup: eight fictional competitors and 42 frozen source files, about 21,000 words, with 24 facts planted for the system to find. Ten runs per approach, 40 scored runs in all.
| Approach | Distinct ranking orders in 10 runs | Average minutes per run |
|---|---|---|
| Claude alone | 7 | 5.1 |
| Claude + template | 1 | 2.9 |
| Claude + skills and hooks | 1 | 2.9 |
| Pressfit BPE | 1 | 2.8 |
Claude alone gave us seven different ranking orders across ten runs of the same job. Every constrained approach gave us exactly one: 85.7% fewer distinct answers once the work ran on a defined path. All three constrained approaches also ran faster than Claude alone: about 2.9 minutes a run for the template and for skills with hooks, and 2.8 for the engine, against 5.1. That makes the engine about 45% faster than Claude alone.
Read that again. Same brief, same files, same model, and seven answers. This is why I believe AI on its own is overhyped. Companies whose executives are shouting "use AI and agentic workflows" will make Anthropic and OpenAI rich, and I believe many of them will gain very little from the tools.
Now the part tech teams can dig into. Facts were rarely the problem: Claude alone got 99% of the planted facts right and stated none wrongly. What moved was judgment. Templates and skills with hooks also got to one ranking order on this job, and the engine tied skills with hooks: 0.99 agreement on the comparison table and one ranking order each. The hooks never had to block anything in ten runs, because Claude followed the template on its own. Fixed rules do most of the work on repeatability when the job is short.
We set the bar before we looked at the data: the engine had to beat Claude alone by 0.15 on the comparison table and on the ranking. It beat it by 0.11 and 0.07. On this short job, it didn't clear that bar, and the Red Dev Test team set it high on purpose.
Claude alone also produced highly rated reports. Its recommendations just weren't the same twice. In fact, its reports scored higher in our blind quality ratings: 4.84 out of 5, against roughly 3.4 to 4.2 for the constrained setups. This was a test, so we built in real-world variables, based on what we had learned, to make sure we were testing real-world use cases. The template we built for the test capped the summary at 200 words with no section for uncertainty, and every constrained setup worked inside those limits.
AI should be used to write the code that makes a process deterministic, not to sprinkle "AI magic" on the problem and skip the hard work of understanding the process.
Consistency by itself also didn't fix the recommendation. In every setup, one free Claude step picks the big bet, so the main recommendation still changed from run to run, engine included. A deterministic path makes good results testable, but quality still depends on the engineers and product people who define the work.
Long Jobs Are a Different Test
Those were short jobs that finished in minutes. They are the easy case, and even there Claude alone gave us seven different answers. We could have stopped there and assumed longer jobs would be worse. We didn't. We tested it.
On a long job, a small drift early in the run can become a big problem later. Context gets compacted, working files change, and the model writes new code to solve a problem it already solved. That was our expectation going in. Here is what the first long tests actually showed.
The biggest test is a full annual vendor review: 64 vendors, about 480,000 words of files, 28 policy rulings (12 of them with no right answer), and a board decision at the end that either releases payments or stops them. At real speed, it is about a 10-hour job. We sped it up to about 45 minutes for testing.
On the 12 open rulings, Claude alone agreed with its own earlier runs 0.78 of the time. Our engine agreed 0.97 of the time, and its board decision came out the same in 5 of 5 runs.
To be fair, the engine isn't the only way to get the rulings right. A script that held the rulings prompt fixed matched the engine's 0.97, at half the tokens. Its board decision still split 4 to 1, because Claude judged one refund case its own way. Later judgment calls are next on the test plan.
Then we ran a job built to break things: a two-hour payment run of 70 steps across five regions, where each region starts from the last one's result. We planted 25 failures in it: scripts that hang, crash, finish late, write half a result, or lose the reply after the money has already moved. Same brief and same setup every time, six runs for Claude alone and six for the engine.
Both got all 60 results right in every run and handled all 25 failures. The difference was how they got there. Claude alone never ran the job step by step. Every run, it wrote its own program to run the job, a new one each time, between 344 and 552 lines long. The engine ran the same 162 lines of code every time. Claude alone was a little faster, 112 to 117 minutes against 125. But its token use swung from 1.7 million to 5.7 million between runs, about 3.4 times. The engine stayed between 0.56 and 0.63 million, within 13%, and used roughly 3 to 10 times fewer tokens.
The rest of the long tests told the same story:
A 14-step job of about 30 minutes: both got 12 of 12 right. Claude alone used 3.2 million tokens; the engine used 0.12 million, 27 times fewer.
Killed partway and restarted: Claude alone recovered 4 of 4. The engine recovered 4 of 5. The one it missed traced back to our graph code, which is exactly what the Red Dev Test team is there to find, and it went straight back to the dev team.
Failures that nothing announces: both handled 5 of 5. Claude alone named all five in its report. The engine named one. Claude alone wrote the better reports here.
Twenty dependent steps, 301 records judged: both got 20 of 20. Claude alone kept to the rules through three memory resets.
A board decision by five votes: Claude alone made the same pick 6 of 6 times, the engine 5 of 6. A tie.
On the twenty-dependent-step job, Claude alone also split the work across 30 subagents and finished in 8 minutes, against 29 for the engine. These are early runs, one to a few each, and none of them are counted runs yet.
So here is what we can say. On the shorter long jobs, accuracy mostly tied, and Claude alone runs scripts and recovers well. As the job grows, that changes, and the clearest proof is a real job, which comes next. On top of that, the same code runs every time, so you review it once, and on script-heavy jobs it used a fraction of the tokens, and the same amount each run. The test we still have to run is a 10-hour job with branches, loops and judgment calls. It is designed, not built.
How Big a Real Job Gets
The vendor review is a test. Here is a real one. One of our Playbook customers is a national equipment rental company, and its Playbook tells the whole story.
October: headless Claude. We ran the discovery phase of its Playbook with headless Claude, using MCP to drive our skills. It got the job done, up to a point. Claude left more than a third of the keywords undecided, 4,484 of them, for someone to sort out by hand. It also approved seven sites that don't rent equipment at all, including Yelp, MapQuest, Zillow and U-Haul.
November: Pressfit BPE. We ran the same phase through our Business Process Engine. The graph pulled fresh data: 20,000 of the keywords the company already ranks for, up from 12,000 in October. It found 33 competitors, researched 30 and brought 20 to the approval gate. It left 68 keywords undecided, cut the sites that don't rent equipment to two and replaced them with real rental rivals, because it rated 19 competitors as direct where October rated 11.
Then we ran the same job again, at 20 steps and at 300. Each of our tests was a follow-up to the one before it, so we could see how every change moved the result. Our hypothesis going in: Claude alone isn't great even on short runs, and it gets worse as runs get longer. Claude + skills and hooks, with everything turned on, does better. And as the runs get longer, the graph is the place to go. So we took this exact job and ran it at 20 steps and again at 300 steps, three ways: Pressfit BPE, Claude + skills and hooks, and Claude alone.
At 20 steps, Pressfit BPE got 100% right, Claude + skills and hooks got 95%, and Claude alone got 82.5%. At 300 steps, Pressfit BPE held at 97.5%. Claude + skills and hooks fell to 85%, and Claude alone fell to 70%. Put the other way, at 300 steps Claude + skills and hooks got six times as many results wrong as Pressfit BPE, and Claude alone got twelve times as many.
That is the hypothesis, held up step by step. Claude alone wasn't great at 20 steps and was the worst at 300. The template and hooks helped, but they couldn't stop the slide. The graph barely moved. Every extra step is another chance for the model to lose the thread. In the graph, code holds the thread, so the length of the job hardly mattered.
It is the same pattern the Microsoft and Salesforce researchers found. Once a model takes a wrong turn, it gets lost and doesn't recover, and a longer job gives it more turns to take. Google reached the same conclusion. Its Agent Development Kit builds agents into workflows, and the reason it gives is to "ensure tasks run in the required order or pattern consistently." For new code, Google now points developers to graph-based workflows. (Google ADK workflows)
Why we believe a Business Process Engine is the right way to go. It isn't autonomous: it doesn't pick its own path. It isn't tied down either, harnessed to look only at a predefined set of documents. Making MCP do all the work meant forcing Claude to look at a subset of the documents. It is a coded execution path that is still free to pull the data the job needs and reuse what earlier jobs gathered from the cache, so every step can keep getting better data, instructions and checks. And before anything is delivered, it has to pass the Red Dev Test team's tests.
What one phase takes. Judging the competitors alone took 51 copies of Claude running side by side for about three hours. Start to gate took 6 hours and 17 minutes, and the Claude usage for that one phase came to $248.44. October ran faster, at 4 hours and 47 minutes, but we didn't record its Claude usage.
Where we go next. Where both runs made a call, they agreed 62.5% of the time. The graph judged the company's own brand name as not relevant, treated nearly identical portable toilet terms differently, and left the gate's "approved by" field empty. The runs were also two weeks apart, and search data moved in between, so some differences would show up even with identical decisions. And Claude still makes the competitor and keyword judgments in both runs. That is the next thing we are fixing.
That is one phase of one Playbook. A deliverable this size is not something you prompt once and hope for the best.
Why the Engine Is the Better Bet for Token Spend
The honest number first. On the vendor review, the engine used about 1.8 times the tokens of Claude alone, around 16.5 million a run. A version where we told Claude to read every file twice used 2.7 times as many.
So why do we still think it is the better bet for a token budget? Three reasons.
It's predictable. Five Pressfit BPE runs landed between 16.4 and 16.6 million tokens. Five runs of Claude alone ranged from 5.6 to 13.0 million, more than double from one run to the next. You can budget for the first. You can't budget for the second.
It gets consistency from code, not from more tokens. Reading twice spent the most of anything we tested to make Claude consistent. The engine makes the same calls because the path is fixed, not because it reads the files again. And when code does the waiting, the engine is lighter: on the two-hour, 70-step job, it used roughly 3 to 10 times fewer tokens than Claude alone, and 27 times fewer on the 30-minute job.
It's built to avoid the rerun. A run that comes back with a different board decision means another full run, and someone to decide which answer is right. That is where the real cost lives, and it is why we will report cost per accepted deliverable, not tokens per run.
What We Are Doing About It
Through all the testing, researching other methodologies and looking at Google's workflow engine and our own, we have put every learning back into our product to create a unique Playbook our customers can use. As we deliver new features, they will go through the same testing methodology to make sure the code execution path delivers the results we intended. The Playbook is spot on for 99.5% of our target audience. We do have a few clients with really old websites or who are starting from scratch. For the largest enterprise companies, it will blow the doors off of everything out there, and I do mean everything. Joking, of course. It's good, and it keeps getting better as we iterate and test.
As we roll out more features and more deep dives, we will keep publishing our work. And of course, you can support our research by dropping your URL and getting your first reports.
The Research Behind This Post
Everything in this post comes from our own testing, and we want you to be able to check it and use it.
- The full research report. Every test, every number and every caveat, including what the tests told us to work on next. Read the research.
- The infographic. The same results on one page. View the infographic.
- The Graph Workflow Starter Kit. A workflow spec template, acceptance criteria, rules for the graph, a LangGraph skeleton, a prompt that turns your skill into a graph spec, and a test plan. Read it, copy it or download the markdown. Get the starter kit.
- The outside research. LLMs Get Lost in Multi-Turn Conversation, Microsoft Research and Salesforce Research, and Google's Agent Development Kit workflows.
Need help putting it to work? Contact our team at redevteam@pressfit.ai.