They Wanted a Platform. We Built One Checker.

Every year, one of the companies we work with gathers up several hundred near-identical agreements and checks them, one at a time, by hand.

Last cycle, two people on the team reviewed every single one. A third person checked again behind them. And the stack still came back with dozens of errors. The whole thing took about three weeks. When they went back and counted, roughly four out of every ten agreements had something wrong with it.

Here's the part worth sitting with: nobody on that team was careless. They're good at their jobs. The problem is that no human alive reads the 400th form as carefully as the first one. Attention is a muscle, and that muscle gets tired.

This is a builder story: what we chose to build, what we deliberately didn't, and the moment we had to slow down. If you've ever been tempted to solve an overwhelming problem with one big system that does everything, you'll recognize the tension.

The setup

The client is a residential homebuilder. Picture a company with several regions and a few legal entities under one roof. Once a year, when roles and pay get set for the coming period, every team member gets an agreement to sign. Hundreds of them land in a short window.

Each agreement starts from a template. A leader fills in the details: who it's for, the date, the team, the region, the company entity, the benefits, the compensation. Then they submit it through an off-the-shelf project tool, which creates a task with the signed document attached. The internal HR team and payroll check each one. If it's clean, it gets filed in their document storage and loaded into their payroll system. If a pay change is involved, it gets routed for processing. When something's wrong, somebody emails the agreement back and asks for a fix.

It works. It's just slow, and it leaks.

The real problem wasn't the agreement

When a team is drowning like this, the easy assumption is that the document is too complicated or the people are too slow. Neither was true here.

The real problem was attention at volume. The errors weren't dramatic. They were small, boring, and specific:

• Someone picked last year's compensation calculator, or started from an outdated saved template.
• A region or entity got selected wrong from a dropdown, which quietly changed the math even though every number on the page looked fine.
• A benefit got skipped, or a field like the cell-phone benefit got left sitting on "select."
• A signature was missing.
• A pay type didn't match the role, the kind of mismatch that only an experienced eye catches.

None of those is hard to spot on its own. All of them are easy to miss on form number 312 at four in the afternoon. That's the whole game. Boring, specific, repeated checks across a big pile are exactly where human attention fails and exactly where software shines. We've written before about how automating the wrong thing just speeds up the mess. The flip side is also true: find the right small thing, and the payoff is huge.

They asked for a platform. We didn't build one.

Now the interesting part. The client didn't come to us asking for an agreement checker. They came asking for a platform. A logged-in internal app, with roles and permissions, that would eventually house a whole shelf of tools and agents for the HR team. Checking agreements was one idea on a long list that also included onboarding automation, screening workflows, and more.

And we could have started building toward all of that. It's flattering to be asked for the big thing.

Instead, we picked one job.

Not because the bigger vision was wrong, but because platforms earn trust one reliable job at a time. If the first thing we ship is shaky, nobody trusts the second thing. So we looked for the single task that was repetitive, high-stakes, and already measured as painful. The agreement pile was all three. That was the place to start.

What we actually built first

The first version is narrow on purpose. When a new agreement comes in, the agent pulls the document and checks the things that are mechanical and checkable:

• Is this the current template and the current year's calculator, not last cycle's?
• Are all the fields actually filled in, with no leftover placeholders?
• Do the region and the company entity match up the way they should?
• Are the signatures there?
• Does the pay type line up with the role?

If something's off, the agent hands the agreement straight back to the person who submitted it, with a note on what's wrong, before it ever reaches payroll. If it's clean, the agent names the file correctly and drops it into one folder, ready for a person to upload.

That's it. We deliberately stopped there, shipped it, and let it run. A human still does the final upload, and that's a perfectly fine place to draw the line for version one. Getting a limited, reliable thing into real use before the busy season beats promising the full build and missing it. If you've ever watched an ambitious internal project stall out before it touched real work, you know why. We dug into that failure pattern in why your AI pilot never made it into real work.

What we deliberately left alone

Just as important as what we built is what we chose not to build yet.

We left the full "which job title belongs to which entity and location" logic out of the first check. That matrix is useful, but it changes often and is messy enough that pretending to automate it would do more harm than good. So those outliers go to a person. On purpose.

We put the onboarding automation, a chain of follow-on tasks spread across several different tools, into a later phase. We tabled the screening workflow until the core checker was solid. We were clear that we were not rewriting anybody's company policies. One job, done well, first.

This is the buy versus build question in miniature. The answer is rarely "build the everything-platform now." It's usually "prove one thing, then expand."

The moment we slowed down

Partway through, we noticed that the attached documents were reachable in a way that was more open than anyone had assumed. These are people's compensation and personal details. That's not a corner you cut to hit a date.

So we stopped and flagged it. Sensitive data and compliance aren't the exciting part of a project like this, but they're the part that can end one if you get them wrong. Moving carefully there isn't a delay. It's the job.

"Usually right" is a trap for a checker

Here's the honest limit, and it's the most important line in this whole piece.

A checker that is usually right is dangerous, because the moment people trust it, they stop looking. And "usually" always has a bad day. So we did not build something that silently approves agreements on its own judgment. It catches the clear, mechanical mistakes and hands them back. The genuine judgment calls, the fuzzy exceptions, still go to a person.

We were careful about the promise, too. The bar we set was honest: catch even half of those roughly four-in-ten bad submissions before they hit payroll, and you've already given the team weeks back. We did not promise a perfect number, because you can't, and anyone who does is selling you something. The checker earns trust by showing its work and handing errors back, not by claiming it never misses. Knowing when AI is wrong is a skill the whole team has to keep, not hand off.

And this is not a set-it-and-forget-it build. The rules shift every cycle. Someone has to own keeping the checker current, which is true of basically every useful automation. We've said it plainly before: set it and forget it is a lie about AI.

The lesson you can take to your own business

If your team is buried, the loudest instinct is to go find the big system that does it all. Resist that for a minute and ask a smaller question instead:

What is the one task that is repetitive, high-stakes, and painful, that a person has to do the same way over and over?

That task is where AI pays off first. Not because it's magic, but because it reads the boring stack without getting tired and surfaces the handful of things that are actually wrong. It didn't replace this HR team. It took the one part of the work no human should do several hundred times in a row, and gave their attention back to the exceptions, the judgment, and the people.

Start with the checker. Earn the platform.

If your team is losing weeks to checking the same kind of document over and over, and errors still slip through, that gap is exactly the kind of thing we help businesses close at Humanity AI. It almost never starts with a big platform. It starts with one unglamorous job, scoped tight and done right.