Procurement is an approval process wearing a spreadsheet

Someone needs a new tool for the team. Say it’s a license, a service, a piece of hardware, it doesn’t matter. What happens next is the same in almost every company: a person becomes a courier. They email three vendors for quotes. They wait. They nudge. They paste the numbers into a spreadsheet nobody will open again. They route it to whoever signs. They forget to chase the one vendor who went quiet. Three weeks later the thing arrives, or doesn’t, and a year after that it auto-renews at a price nobody re-checked.

That whole pageant is treated as one job called “procurement.” It isn’t one job. It’s four jobs of chasing and watching wrapped around a single decision, and the decision takes ten seconds.

Procurement is an approval process wearing a spreadsheet. The human approves; the agent assembles and chases.

This post takes that sentence apart. Because once you see procurement as an approval process, not a research project, not a negotiation, not a heroic feat of follow-up, you can see exactly which parts a person should keep and which parts were never a good use of a person at all.

The naive version: a human is the integration layer

Here is how buying works in most companies, and it works, in the sense that things eventually get bought.

A request comes in. A person reads it, figures out who might sell the thing, and writes the same email three times with three different greetings. The quotes trickle back over days, in three different formats, two of them as PDFs. The person transcribes them into a comparison, price, terms, what’s actually included once you read the footnotes. They send that comparison to the approver, who asks a question, which sends the person back to a vendor, which adds another day. Eventually someone says yes. A purchase order goes out. And then the chasing begins again: did they receive it, did they invoice us, did the thing actually ship.

It works. But look at what the person is in that story. They’re not deciding anything. They’re a router. They move information between a requester, three vendors, an approver, and a finance system that don’t speak to each other, and they do it by hand, by copy-paste, by remembering to follow up.

The bottleneck isn’t the buying. The bottleneck is that a human is the integration layer between four parties who never agreed on a format. And the cost of that isn’t only the hours. It’s that the most forgettable parts, the third nudge to a silent vendor, the renewal date eleven months out, are exactly the parts a busy human drops. You don’t lose money on the decision. You lose it in the chasing nobody had time for.

So the naive fix is to hire someone to do the chasing, or to buy a procurement tool that gives you a nicer spreadsheet to do the chasing inside of. Both leave the human as the router. Neither one speaks first, chases on its own, or watches the date. They just reorganize the courier work.

The reframe: which clause needs a human, and which doesn’t

Let’s do what we did with other “complex” company jobs and break procurement into its actual clauses. There are four.

Selection. Find the vendors who can sell the thing, get comparable quotes, lay them side by side on real terms.

Approval. Someone with authority looks at the comparison and says yes, no, or “ask them about X.”

The PO chase. The order goes out, and now you wait, on the confirmation, the invoice, the delivery, and nudge whoever goes quiet.

The renewal watch. Eleven months from now, a contract auto-renews, and someone should have re-checked the price and the need before it did.

Read those four and one thing jumps out. Only the second one, approval, actually requires human judgment. Selection is assembly. The PO chase is follow-up. The renewal watch is a calendar that reads contracts. Three of the four jobs are chasing and watching. One is deciding.

The naive setup makes a person do all four. The whole trick is to keep the human on the one clause that needs them, the yes, and give the other three to something that doesn’t get tired, doesn’t forget the date, and doesn’t mind sending the fourth follow-up.

This is the load-bearing idea, so let’s say it the way it’ll keep coming back. Procurement is an approval process wearing a spreadsheet. The human approves; the agent assembles and chases.

Selection: assemble the comparison, don’t make the call

Start with the part everyone thinks is the hard part: choosing the vendor.

The naive version treats selection as a decision, so it hands the whole thing to a person. Go find vendors, get quotes, weigh them, pick. That framing is why selection feels heavy, you’ve bolted “do the research” and “make the judgment” together and given both to one tired human.

Pull them apart and most of selection turns out to be assembly, not judgment. Finding the vendors who sell this thing is a search. Getting three comparable quotes is three emails and a wait. Putting price, terms, and what’s-actually-included into one honest table, so the cheap quote that excludes support doesn’t look cheaper than the one that includes it, is formatting. None of that needs a person. It needs someone who’ll do it carefully and never skip the footnotes.

So that’s the job the agent takes. It reaches the vendors, collects what comes back, normalizes the three quotes onto the same axes, and surfaces a comparison where the differences are real differences, not formatting noise. What it does not do is pick. It assembles the table and hands it up with the one thing the person actually needs to decide on already laid out: here are the three, here’s where they genuinely differ, here’s the one we’d flag.

The human’s job shrinks from “run a research project” to “read a clean comparison and make a call.” That’s not the agent being smarter than you. It’s the agent doing the part that was never judgment in the first place, so the part that is judgment is all that’s left on your plate.

Approval: the human turn is the whole point

Here is the clause we do not automate, on purpose, and it’s worth being loud about why.

The decision to spend the company’s money is the one place a human belongs. Not because the agent couldn’t pick the cheapest quote, it could, trivially. But because “cheapest quote” is almost never the actual question. The real question is whether this is the right vendor for reasons that live in your head and nowhere else: a relationship, a strategic bet, a quiet “we don’t want to depend on them,” a “say yes fast, this team is blocked.” That’s judgment, and judgment is exactly the thing you keep.

So approval stays a human act. The agent’s job is to make that act take ten seconds instead of an afternoon, to arrive with the comparison already done, the question already framed, the one thing to look at already flagged, so that when the person opens it, the only thing left is the part that needed them.

This is the line that separates a coworker from a robocaller. An agent that buys things on its own is a liability with a credit card. An agent that assembles everything and waits for a yes is a chief of staff. The difference isn’t capability. It’s where the brake is. Apollo is built so the agent does all the work up to the decision and then stops, every spend waits on a human yes, and the human spends their attention only on the yes.

The agent does everything except the one thing money should never do without a person: commit it.

That’s also why this works as a system instead of a demo. A demo automates the whole flow and looks magical until it buys the wrong thing. A real one automates the three clauses that were always assembly and follow-up, and routes the fourth, the irreversible one, through the person whose call it actually is.

The PO chase: the follow-up nobody has time for

Approval isn’t the finish line. It’s the start of the part that quietly loses the most money: the chase.

The order goes out, and now four things have to happen that nobody’s tracking. The vendor has to confirm. They have to invoice you correctly. The thing has to actually ship. And someone has to notice when one of those stalls. In the naive version, “someone” is a person juggling forty other things, and the silent vendor is precisely the one who falls off the list, not through carelessness, but because chasing a thing that lives nowhere is a job humans are bad at. The order that quietly never confirmed surfaces three weeks later as “wait, where’s our thing?”

The agent’s version is that the chase has an owner that never forgets it. The order goes out with the expected steps attached, confirm, invoice, deliver, and the agent watches for each. No confirmation by day two? It nudges. Invoice in the wrong amount? It flags the mismatch to a human instead of paying it. Delivery date slipped? You hear about it on Tuesday, not when the thing fails to show up.

Notice this is the same shape as selection: assembly and follow-up the human was never the right tool for. The PO chase isn’t a decision either. It’s a watch. And a watch that runs on its own, surfacing only the exceptions, the vendor who went quiet, the invoice that doesn’t match, turns a person from a courier into someone who only gets pulled in when something’s actually wrong.

The renewal watch: the date that bites a year later

The first three clauses are about getting the thing. The fourth is about the cost nobody sees coming, because it arrives a year after everyone stopped paying attention.

You bought the license. It was the right call in the moment. Then it auto-renewed eleven months later at a higher price, for a team that stopped using it in month four, and nobody re-checked because the renewal date lived in a clause in a contract nobody reopened. This is the same family as every “the cancel never took” and “the bill quietly crept up” story, a date that sits silently in a document and bites precisely because nothing was watching it.

The naive defense is a calendar reminder someone remembers to set, which means it doesn’t get set, or gets set and then ignored because by the time it fires the context is gone. The renewal isn’t forgotten out of carelessness. It’s forgotten because remembering a date eleven months out, attached to a decision you have to re-make, is something a human will lose every time the present is busy. And the present is always busy.

The agent’s version reads the date where it actually lives, in the contract, and watches it the way it watches the inbox: continuously, silently, until there’s something to say. A few weeks before the renewal, it speaks first. Not “this renewed” as a postmortem, but “this renews in three weeks at this price; the team’s usage looks like this; renew, renegotiate, or cancel?” The date surfaces while there’s still time to act, with the context already reassembled, and the human makes the one call that was theirs all along.

That last clause is the one that pays for the whole system. Selection saves hours. The chase saves a few orders from slipping. But the renewal you’d have paid on autopilot and didn’t, the contract you renegotiated because something flagged it with three weeks to spare, that’s real money the naive setup was always going to leak, quietly, forever.

The turn: stop being the router

Strip the spreadsheets away and here’s what procurement actually is in most companies. It’s a capable person spending their week as a courier, moving quotes between parties who won’t talk to each other, chasing vendors who went quiet, and trusting that someone, somewhere, remembers a renewal date a year out. They call it diligence. It’s a tax.

And it’s a tax paid by exactly the wrong person. The operator who could be fixing the thing customers complain about is instead transcribing a third PDF quote. The founder who should be deciding what the company chases is nudging a vendor for the fourth time. You became the router because no system would do the routing, and the routing was never the part that needed you.

The promise here isn’t a faster spreadsheet or a chatbot that drafts vendor emails. It’s that three of procurement’s four clauses, the assembling, the chasing, the watching, get done by something that doesn’t forget and doesn’t tire, so the only clause left on a human’s plate is the one that was always theirs: the yes. You stop being the integration layer between four parties and go back to being the one who decides whether the thing is worth buying at all.

Procurement is an approval process wearing a spreadsheet. The human approves; the agent assembles and chases. That’s the whole reframe, and it’s what we’re building at Apollo Space, a company OS where the agent does every job that was assembly and follow-up dressed up as judgment, and a person keeps the one job that was judgment all along.

---

If you’ve ever signed off on a purchase and then spent two weeks chasing the vendor who went quiet, you already know which part of buying needed you and which part never did. The yes took ten seconds. Everything else was the tax, and the tax was never yours to pay.