I've spent years writing about agentic procurement from the outside. Now I'm on the inside, and the first thing that struck me was a live deployment where a two-day manual review got done in seconds, at 95%+ accuracy, on real spend, at a company you'd recognise. Here's what that actually looks like, and why it matters more than the headline number suggests.
TL;DR
If you've got 30 seconds, here's the shape of it. The rest unpacks the why.
- Every large enterprise is doing an enormous amount of manual checking at the front of their purchasing process, before a single order is approved. That work is slow, and it gets done to a minimum viable quality level because there's no other way to keep up with the volume.
- A Fortune 500 enterprise ran that same work through a Requisition Alignment Agent. Two days became seconds.
- What actually mattered wasn't speed. It was accuracy. The agent cleared 95%+ on a genuinely complex global policy set before anyone trusted it with live decisions.
- It went live in stages: observer mode first (runs silently alongside the existing process), then advisor mode (its outputs feed real approvals). Trust was earned, not assumed.
- The real story isn't one faster process. It's what happens to everything downstream when the front of procurement is finally working properly.
Early in my procurement career, I used to sit down first thing in the morning and open up the purchasing system. Some days it was SAP. At other organisations it was Oracle. The tool changed. The job didn't.
The queue of purchase requests would be sitting there. And my job, alongside everything else, was to work through them. Right category code? Right budget code? Supplier set up correctly? Everything in order before it could move forward.
I'd clear through them one by one. Some took a couple of minutes. Others meant flicking between two or three systems to piece together whether everything was actually aligned. And I'd get to the end of a morning, sometimes a full day, having done nothing but that.
It wasn't complicated work. But it was constant. And it never stopped.
Years later, writing this from inside a company that runs an agent doing exactly that job, what strikes me isn't just the speed difference. It's how completely normal everyone found it that a process this important was being done this way at all.
What actually happens when a purchase request comes in
Here's the thing that surprises people outside procurement when you explain it: a single purchase request doesn't get one check. It gets dozens.
Before that request is allowed to move forward, someone has to work through a checklist that looks roughly like this:
- Is it coded to the right category?
- Is the supplier an approved vendor?
- Are they set up correctly in the system (tax details, payment terms, banking information)?
- Is there an existing contract this should be linked to?
- Does it fall inside a preferred supplier arrangement?
- Does the spend level require additional sign-off under the delegation of authority policy?
- Is there a competing bid requirement at this value?
- Does the statement of work actually describe what's being bought?
- Are there sustainability or diversity spend implications?
- Any sanctions exposure on the supplier?
- Does the commercial structure match what procurement negotiated?
That's before you get into the company-specific rules:
- Regional policies that vary by country
- Category rules that differ by what's being bought
- Approval flows that change depending on the combination of supplier, value, and category
- Escalation logic that lives in a shared document somewhere and has been updated three times in the last year
A large enterprise might have 50, 60, 70 individual checks that apply, in varying combinations, to every purchase request that comes through. And at a Fortune 500 company, "every purchase request" means hundreds of thousands of them a year.
The people doing this work
This review process gets handled in one of two ways. Some organisations run it internally, with a team sitting inside procurement whose job is to clear the queue. Others outsource it to managed services providers who specialise in exactly this kind of high-volume transactional work.
Either way, the shape of the problem is the same.
The team doing the reviews is working to a throughput target. There are SLAs. The standard at many enterprises is to clear a review within 48 hours. That sounds reasonable until you do the maths on the volume. When you're processing hundreds of requests a week, each one involving dozens of checks across systems that don't talk to each other, 48 hours is not a generous window. It's a sprint.
And when you're sprinting indefinitely, something has to give.
What gives is quality. Not catastrophically. This isn't a story about people being negligent. It's a story about what happens when the volume of work exceeds the capacity to do it carefully. You develop a sense, over time, of what to really look at and what to wave through. The checks that tend to surface real issues get attention. The ones that rarely flag anything get a quick scan. Edge cases get a judgement call based on whatever precedent comes to mind first.
The result is review work done to a minimum viable quality level. Good enough to keep the queue moving. Not as thorough as anyone would do it if they had twice the time.
It's not a criticism of the people doing it. It's just what happens when you ask humans to do work at a scale that humans were never designed to do.
What we put in its place
Pactum's Requisition Alignment Agent sits at that same point in the process and works through every check, all of them, every time, for every request, before anything moves forward.
The difference isn't just speed, though the speed is real. The difference is that the agent doesn't triage. It doesn't get tired halfway through a Friday afternoon queue and start skimming. It doesn't have a backlog that causes it to rush. It runs the full set of checks on every request, applies the policy logic correctly, and flags what it found. In seconds.
What it doesn't do is assume it's ready to be trusted on day one. Neither do we.
Deployment starts in shadow mode. The agent runs every check in the background, on real live requisitions, without touching the existing process. The customer watches the outputs alongside their current reviews and compares them. There's no risk, no disruption, and no "take our word for it." Just the agent proving itself on real data over time.
When that trust is established, it moves into advisor mode. Now the agent's outputs are part of the live approval process. The people in the approval chain are using what the agent found to make real decisions on real spend.
And beyond that, progressively more autonomous: escalating, routing, and eventually taking over the review work entirely, with people focused on the exceptions and judgement calls that need a human rather than the routine checks the agent handles itself.
This is what "procurement run with agents" means in practice. Not replacing the people doing this work. Giving procurement teams the capacity and scale to do it properly.
Check out this demo of the Requisition Alignment Agent.
The bit that actually matters
The customer this deployment is based on had a hard policy landscape. Not a handful of clean rules. A deep, interlocking web of global purchasing policies, category-specific checks, and escalation logic that varied by region, supplier type, and spend band. The kind of complexity that quietly breaks the tools that are really just a chatbot bolted onto a simple workflow.
Getting the agent to handle that well, not roughly but well, took real work. Every check, every category card, every edge case written into the policy logic properly.
And the bar was set where it should be: the agent had to match or beat the quality of the human review process. They pushed accuracy past 95% before the customer would green-light the move from shadow into advisor mode.
That's the number most people skip past. It's the one that counts.
The headline isn't "it's fast." The headline is that a Fortune 500 enterprise was willing to put this into their live approval chain, advising decisions on real money, because the accuracy was there.
Then there's the speed. The manual process targeted up to 48 hours. The agent does the equivalent checks in seconds.
"Two days to seconds" is easy to say and hard to feel. So consider what it actually changes.
A request that lands at 4:55pm on a Friday doesn't wait until Tuesday. It's checked before the requester has closed their laptop. A team that spent its days running through a queue spends them on the decisions that need a person to make the call. The business stops waiting on procurement. And the quality of the review, for the first time, isn't constrained by how many hours are in the working day.
Why this is bigger than one process
It's tempting to read this as a story about speeding up a slow review. It isn't. And the distinction matters.
When every purchase request is checked thoroughly and automatically, you've got reliable, accurate data at the exact moment a purchase enters the process. And that changes what's possible from that point forward.
Because the next question isn't just "is this compliant?" It's "should we be doing something smarter here?"
Take the single-supplier request that should be a competitive event. Right now, in most organisations, that either gets waved through because nobody has time to act on it, or it gets flagged by a reviewer and sits waiting for someone to pick it up. Either way, nothing happens with it.
When the Requisition Alignment Agent catches that, it doesn't just note it and move on. It can hand that directly to a negotiation agent that goes to work: sourcing alternative suppliers, identifying where there's leverage with the existing one, or running a process to find a better commercial outcome. The review and the action are connected. What was previously a missed opportunity becomes something the business can actually do something with.
The same logic applies to a price that's drifted from what the contract says, or a preferred supplier that should have been used and wasn't. Each one is a signal. And for the first time, there's something that can act on those signals at the speed and scale the volume demands.
We'll dig into that part in much more depth in a follow-up piece. But understanding the review step properly matters, because it's what makes everything else possible. Clean data in, useful action out. That's the chain.
Pactum works with Coupa and SAP Ariba. If you want to see what this looks like against your own purchasing process, let's talk.
