A project brain for a nine-figure build

The seat no one wants

Every construction project runs on information, and nobody holds less of it than the owner's representative. They do not build anything and they do not control the money. They sit in the middle: accountable for seeing the project clearly, with read-only access to almost everything.

Read-only is literal. The owner's rep usually has no login to the systems that track the work. So they referee instead. They hold every party to the process the construction contract lays out, the formal questions and change paperwork and monthly invoices, each with a named owner and a deadline. Not because the paperwork adds value on its own, but because it is the least-bad routine the industry has, sharpened over decades.

Before AI, the job was pure reaction. Nothing you built compounded, because the day went to digesting everyone else's paperwork in everyone else's formats. It is no surprise the role has traditionally gone to silver-haired construction lifers, cashing in a career of pattern matching as the owner's go-between.

That works on a simple project. On a complicated one, casual oversight falls apart.

The insight

AI agents change the seat. If you can capture every document as it arrives, you can build your own working copy of the whole project without ever logging into anyone else's system. OCR every document as it lands, then have the agent build a wiki from the pile (Andrej Karpathy's framing): one linked page for every question, change, and invoice, kept current instead of re-searched. Do that, and the owner's side can connect dots across the project better than anyone inside it. Information asymmetry on a construction project has always run against the owner. This narrows the gap from the one seat nobody expects it from.

The trick is the constitution. The system needs a rulebook nobody can argue with, and on a construction project one already exists: the construction contract. Treat the contract as the source of truth and every subcontract as an extension of it, and the agent inherits a point of view grounded purely in what the parties signed. A standard contract already spells out how information is supposed to move, who owes an answer to what, and by when, with the budget and schedule attached as exhibits. Running a project strictly by the contract is the industry's best practice, and an AI agent is, by design, very good at following written rules. The project's operating system comes baked in.

What I walked into

An owner's team steering a nine-figure commercial building project with no single picture of what they had committed to.

A long run of contract amendments and no consolidated master, so the true total was never on one page. Tens of thousands of documents in SharePoint, more arriving daily. Thousands of RFIs, the formal questions that fly between builder and architect. At that scale, human-maintained spreadsheets are an unsustainable way to run anything.

They were not starting from zero. They had loaded contracts, amendments, and change logs into Claude and gotten real analysis out: change-order triage, an allowance review, early error flags. Smart work that hit a ceiling. They could run the analysis. They could not push back on it with construction judgment. That was the gap I was hired to close.

One month, fixed fee, with a defined bar: recreate their analysis, then exceed it.

Four constraints shaped the build. No access to anyone's systems at first, documents arriving second-hand. PDFs with no clear origin, working files mixed with official records, often undated. Non-technical clients, so nothing could require a terminal. Remote-only, across different machines and networks.

How it works

A shared folder is the foundation. Every file lives on every machine, readable offline by a local agent, nobody logging into anything at the moment of analysis. This was a compromise more than a choice. I wanted the client inside the same wiki I was, with Cowork as their interface. Dropbox brings file-conflict headaches, but it holds for a small group.

The system carries its own instructions inside that folder. The operating rules, the glossary, the procedures: all plain text files sitting next to the content, not settings buried in someone's app. Maximum file, minimum project. I edit a file, and the next session on any machine picks up the new behavior. Nothing to configure, no drift between sides.

Claude Code runs on my side for pulling documents, scanning them to text, and checking the results. The client never sees that layer. They see clean, searchable structure.

SharePoint came down through its REST API, the machine channel its own apps use: over a hundred gigabytes and tens of thousands of files in a day. Converting file by file would have produced thousands of wiki pages. Treating a whole folder as one page, a vendor's folder, a month's invoice package, cut that count by nearly three-quarters. Anything not worth downloading gets a small placeholder pointing at where it lives upstream, thousands of them, so nothing is invisible from inside the wiki.

The links are the spine. A change order links to the question that started it, the amendment that paid for it, and the invoice where it shows up. The links live inside the pages themselves, so they travel with the folder. A page can even link to a document that has not arrived yet; when it lands, the link completes itself.

This is the part that has surprised me most. The systems those documents come from are mutually incompatible, and it does not matter, because the wiki is a layer of meaning on top of all of them. Each party's system is deep in its own lane, and nobody's job is to join them. The owner's secondhand pile is the only place everything lands, and once it is linked, it holds a broader picture of the project than the systems run by the parties who direct the work. The owner's ledger ties down through the monthly invoice to the change orders and budget lines beneath it, and sideways from a field question to a meeting minute to a signed change. I have never seen a project's information connect that completely.

One lesson cost a rebuild. The early design kept a "current state" summary at the top of the folder. Stored summaries rot, and rotted summaries get quoted as truth. Now the current state is computed fresh each time it is asked for, never stored.

The checking machinery is as large as the wiki itself, because a record you cannot trust is worthless. Every figure links to the exact document it came from, and the agent may never cite its own earlier work as a source. Checking structure alone is not enough: the first time I checked the numbers themselves, asking whether every dollar figure actually appears in the document it cites, I found 126 violations on a wiki that had just passed every check of its structure. Both checks now run automatically, every time a page changes.

What it found

Along the way the system produced a budget history rebuilt from the original contract through every amendment, change-order reviews, a hunt through the builder's contract reserves, a full audit of the budget workbook with every formula verified, a monthly owner health report, and a refreshable analysis workbook. Three results carry the story.

An independent budget, rebuilt from the signed contracts in a day, landed within 0.8% of the book the owner's rep maintains. Read that two ways. The rep's book was good. And the owner now has an independent check that can be rebuilt on demand.

The reserve hunt surfaced an eight-figure pool of allowances, money set aside in the contract for costs not yet pinned down, sitting unused inside the builder's trade contracts. Invisible if you only read the monthly invoices.

Before a projection of the next six months of cash needs went upstream to the people who fund the project, the system reconciled it against the closed books and surfaced a gap of tens of millions of dollars, using only documents already in hand.

The pilot became a month-to-month engagement, then a standing role. The system now runs as the owner's independent set of eyes.

What it can't do

The system is only as good as its inputs. Documents the owner never receives do not exist in it. It works from snapshots, not a live feed. The weakest link is the scan-to-text step: every check downstream assumes the text matches the page, so I still hand-check and re-run the OCR more than anything else in the system. It has no read on personal dynamics, and those decide a lot on a job this size. And it does not assign blame: the pages establish what happened and when, and a human decides who is responsible.

That last one is the point. It does not replace the owner's team. It gives them a memory no one on the project can out-argue.

The method is open source

Everything above describes one engagement. The system underneath it travels, and I have documented it: how the wiki is organized, how the contract becomes the rulebook, the checks that keep the agent honest, how to pull documents out of other people's systems, and everything that broke along the way. It is open source, and it uses invented names end to end: Claude of Record.

The project's documents stay private. The method does not.

More of the record is at Work.