Every software vendor demo is engineered to show you one perfect moment.

The single sliver of the workflow where the stars align, the data is clean, the prompt lands, and the AI agent does something slick enough to make the room go quiet. It's a great trick. And like every great trick, the whole point is that you don't see the scaffolding behind the scenes...

Nobody walks you through the dozen things that have to be true for that result to appear on screen. And they definitely don't say the uncomfortable part out loud: Left unconstrainted, AI Agents are guessing machines.

Large Language Models (LLMs) are statistical engines. They predict the next most-likely action, the next most-likely answer based on their training data. On a good day, with the right inputs, that "guess" is brilliant. On a bad day, with messy inputs, that same machinery produces confident nonsense.

So here's the real question: what has to be in place to make the demo-quality result repeatable and compliant at scale, in production, on a Tuesday, when you're not in the room?

AI agents genuinely can change the game for procurement teams. That part is real. But delivering on the promised business outcomes at scale depends on a few underlying elements that no demo bothers to explain. That's where the details live. We'll cover them in three parts:

This Deep Dive in partnership with…

Think of it this way. In a sea of possibilities, an unconstrained agent will happily swim in any direction, including straight into a waterfall.

Your job isn't to make the agent smarter. That’s the LLM provider’s job. Your job is to pre-define the lanes it's allowed to swim in, so that high-quality results become the default rather than the lucky exception.

You control the inputs. You control the field of play. And a big part of being able to do that comes down to something most teams treat as an afterthought: the technology platform you build your agents on. Choose a platform that hands you all the tools to draw those lanes, and repeatable results are on the table. Choose one that doesn't, and you're left grasping at straws, having to explain why you can’t reproduce the demo at scale...

Let's break down what success actually requires.

We've defined an AI agent before in this newsletter, and the definition still holds:

That's the formal version. But here’s a more accessible way to think about the raw materials you're actually configuring when you build one.

Skills are the instructions for the task at hand. The process itself, from redlining a contract to resolving an invoice exception.

Picture the standard operating procedure you'd draft for a new analyst on their first week. Where does the task start (the trigger)? What are the high-level steps in the middle? And what does "done" look like (the outcome)? A skill is that SOP for a specific task, written so an LLM can execute it, and pulled in only when it's actually relevant... not dumped on the agent all at once.

If you can't define the trigger and the outcome with precision, you don't have an agent. You have a wish for a shortcut.

The context library is what the agent knows. It's the reference material the agent can draw on to shape how it makes decisions and executes processes: your policies, your playbooks, your business rules, your spend category strategies, your templates.

This is the part teams consistently underinvest in. An agent with strong skills but no context will execute the wrong process beautifully. It'll resolve an invoice exception in a way that technically works but quietly violates your three-way-match policy. The context library is how you turn "a plausible answer" into "your organization's answer."

Actions are what make agents agentic. They're the permissions and system access that let the agent do things rather than just talk about them. Without tools, an agent can only talk. With tools, it can act: updating the PO, flagging the supplier, routing the exception.

Channels are where the agent shows up to work alongside you and your colleagues. This can be inside the procurement application itself (in-app chat and comments), in enterprise chat tools like Slack or Teams or even via email; wherever the “human-in-the-loop” actually works day-to-day.

Here's a quick way to hold all four in your head:

Now the honest gut-check.

If the tools you're using to build agents don't let you configure and administer this raw material, be clear-eyed about what you actually have. You may just be configuring a chatbot dressed up in agent language.

Or worse: you might be running one you can't configure at all. A black box provided by your software provider that guesses, acts, and leaves you to explain the results afterward. That's not automation. That's exposure.

Having the raw materials to build agents is absolutely necessary. However, it is nowhere near sufficient to get the results you want.

Remember what we established at the top: LLM-supported AI agents are statistical creatures. They are always, on some level, guessing. So beyond constraining them with good skills and context, you have a second lever that most buyers never think to pull: minimizing the complexity of the platform they're built on.

The simpler and more coherent the environment, the fewer chances the machine has to guess wrong. Three platform characteristics do most of the heavy lifting here.

Start with the data. Not because it's exciting, but because it quietly influences everything else.

A data model is simply the underlying database structure that defines how your procurement platform stores and relates pieces of information to one another: what a "supplier" is, what fields describe it, and how it connects to contracts, purchase orders, and risk profiles. Get this right and every task the agent performs starts from solid ground.

Now picture the opposite. Your platform carries three separate supplier tables in its technical layer because it was cobbled together by acquisition over the years… Each of the three supplier master record types has a different set of fields, each capturing supplier information a slightly different way. Every time an agent needs a clean answer about a supplier, it first has to reconcile those three definitions on the fly.

What does that cost you?

That's the trap. Complexity in the data layer doesn't just slow agents down. It makes them cost more and perform worse at the same time. (If you've ever tried to manually reconcile supplier masters from multiple different systems yourself, you already feel this pain in your bones…)

A single, unified data model, ready for agentic AI, is the foundation the rest of this rests on.

Here's where a lot of otherwise-capable platforms fall down. They can run an agent. They can't govern one.

Real governance means treating an agent as two things at once: a user AND a workflow.

As a user, the agent has to be a first-class citizen inside your platform, not a script borrowing a human's login. That comes down to a handful of non-negotiables:

That's the user half. The workflow half is the one teams forget.

An agent is a living business process, and it evolves. The version you deploy in Q1 will need to change by Q3. So the platform also has to give you flexible drafts and versioning: track changes to an agent's configuration, save updates as drafts, test them, and revert to a previous version when something goes sideways.

If you can't test a change to an AI agent before it hits production, you're not governing agents. You're gambling with them.

Once you've got a single, optimized data model and agentic administration capabilities, a native orchestration layer is what lets you build the rails your agents run on: workflows, branches, out-of-the-box integrations, business rules, the works.

This matters because agents come in wildly different sizes.

Some run a business process end to end. Others play one small part in a much larger process, one that also involves human stakeholders and plenty of steps that should be deterministic where it matters: the math-based, rules-based functionality where "guessing" has to be removed entirely. You don't want an LLM re-deriving a tax calculation or improvising a system integration. You want it handing off those critical actions to deterministic logic that's right every single time, which is what drives consistency and reliability.

Great orchestration is the lifeblood that makes this blend possible. It's how you decide, deliberately, where the agent guesses and where the system computes. Get that division of labor right and you get the best of both: judgment where you need flexibility, and certainty where you need control.

If you want high-quality, repeatable outcomes, the governance and control your platform unlocks is every bit as important as configuring the agents well in the first place. You cannot out-configure a weak foundation.

Say you've done it. Your agents run on a solid foundation inside procurement, on a platform with a clean data model, purpose-built administration, and native orchestration. Good. Now for the part that changes the shape of the function itself.

You can unlock an entirely new level of value by truly integrating with the rest of the enterprise. But only if your procurement platform is genuinely open by design.

Openness gets claimed by everyone and proven by almost no one. Here's what it actually looks like when it's real:

Miss any one of these and the integration story stays a story. Your platform vendor is relying on “locking you in” to their ecosystem by trapping your data… But, hit all three and something genuinely new becomes possible.

This is the holy grail, and it's worth saying plainly.

For decades, procurement's central problem has been the same: getting involved early enough to matter. We build beautiful processes and then wait, hoping the business remembers to loop us in before the deal is basically done. Sometimes they do. Often they don't.

An open procurement platform flips the direction of that relationship.

When you expose your platform, along with the policies, processes, and data inside it, to the enterprise LLM your colleagues already use (Claude, Microsoft Copilot, ChatGPT, whatever it is), you stop waiting for the business to come to procurement. You bring procurement to the business.

The user doesn’t even need to know what procurement means…

The user gets a clean experience. You get compliance at scale, produced naturally, at the exact moment of intent.

That's the ball game we’re working towards with Agentic AI!

Strip it all back and the organizations that win in the era of AI agents will do three things.

Here's why we're comfortable being this specific.

Everything laid out above isn't a wish list we dreamed up...

It’s exactly what Zip is building with Superagents: AI agents configured with your business context, and scaled with real governance and control:

The demos were never the hard part. Providing the scaffolding and the expertise to help you deliver is where this shift is won and lost. Zip is building both.

See how Zip's Superagents work in practice.

👀 In Case You Missed It:
Episode 12 of the ProcureTech Unpacked podcast is LIVE!

👀 In Case You Missed It…
The Last 3 Newsletters:

1/ How to Choose a ProcureTech Implementation Partner
2/ Why "Purpose-Built" Procurement Platforms Win... Every Time
3/ Death by Supplier Punch-Out Catalogs

See you next week {{FIRST_NAME|readers}},

— The Pure Procurement Newsletter Team