AI for Construction Registers

Every PM has had the moment: you get to next week and realize nobody logged the RFI response that came in, and now the superintendent’s calling asking what the outcome was. This is for anyone running RFI, submittal or correspondence registers who wants them to actually stay current, not just exist. It comes from my own build, walked through in the video below.

Key takeaways

• A register is only as good as how current it is. The moment updating it becomes a chore you do “when you get to it,” it stops protecting you.
• AI can read incoming correspondence, match it against the register, and log the update automatically, on a schedule or as a routine that runs in the cloud.
• A structured database like Airtable beats a spreadsheet for this because it’s easier for AI to search and because it can link RFIs, correspondence and people to the same project record.
• Poor contract management costs firms an average of 9% of annual revenue, according to World Commerce & Contracting research, and a stale register is exactly the kind of gap that shows up in that number.
• The trust boundary holds here too: AI reads, matches and logs. You still decide what a response means and what happens next.

What is an AI-maintained construction register?

An AI-maintained construction register is a correspondence, RFI, submittal or risk log that updates itself: an AI process reads new emails, checks them against what’s already logged, and adds or updates the row without anyone opening the sheet by hand. You still decide what each item means; the register just stops depending on memory.

The problem it solves is a familiar one. I know from running projects that the first thing to slip when you get busy is exactly the thing that protects you most, the register. That’s when you realize it was last week you were supposed to submit the price for a variation, or you forgot to respond to an RFI and now there’s work happening on site tomorrow that hasn’t been resolved. Not a good position to be in, and it’s rarely because anyone’s careless. It’s because keeping a register current is a discipline task competing against everything else a project throws at you in a day.

“A register is only good if it actually gets used and it is actually kept up to date,” is the line I keep coming back to. The fix isn’t a better spreadsheet. It’s taking the update itself off your plate so the register can’t go stale just because the week got busy.

How do you set up AI to keep a register current?

You point an automated process at your inbox and your register, and it does the reading and the matching for you, on a schedule you set. In Claude there are two ways to run this, and the difference matters for what you’re trying to keep up to date.

A scheduled task runs inside Cowork and is tied to a folder. A routine runs in Claude Code and lives in the cloud, which means it can keep running even when your laptop is closed. Both pull context from a folder and can write updates into a structured database like Airtable.

	Scheduled task	Routine
Runs in	Cowork	Claude Code
Tied to	A folder	A folder, stored in the cloud
Runs independent of your laptop	No	Yes
What I use it for	The daily correspondence sweep	Anything that has to run with nothing else depending on it

My working example, the one that actually keeps my correspondence register current, is a scheduled task. It lives in Cowork, connected to my inbox folder, and I have it set to run daily at 4am. Setting one up is simple: new task, set up manually, name it, add a description, then the prompt. Mine is one line, because the real instructions live inside a skill I built once, with reference files and scripts, so Claude knows exactly what to do with my inbox every time it runs.

The build sequence matters more than the schedule itself. Run the task by hand first, on a real inbox, until the output is right, before you trust it to run unattended. On one manual run against a handful of live inbox threads, mine came back with one genuine update, one item it correctly recognized as a duplicate already in the register, and one it marked as a low-confidence match because it didn’t have the information it needed. That third one is the point of checking early runs closely: I confirmed it by hand, cleared it, and it logged correctly. A scheduled task you never spot-check is one you’re trusting blind.

Why does a structured database work better than a spreadsheet for registers?

A structured database works better than a spreadsheet for registers because it’s built for the lookup and cross-referencing AI needs to do: checking whether an item already exists, linking it to a project, and surfacing it in a viewer. A spreadsheet holds the same data, but AI has to parse it freeform every time instead of querying it.

I use Airtable for this, though other structured databases work the same way. A basic correspondence or document-control register splits by project, then by topic (variations, payment claims, notices, submittals, general correspondence), tracks a status, and tracks whose ball and court it is, in other words, who owes the next response. That last field is the one that actually keeps a project moving, because it tells you at a glance whether you’re waiting on someone or someone’s waiting on you.

Two things make the structured version worth the switch over Excel:

1. It’s structured, which makes it far more efficient for AI to search and update accurately, rather than guessing at column meanings from a loosely formatted sheet.
2. It’s relational, so an RFI can link to its project, its people, and the correspondence thread it came from, instead of living as an isolated row. That’s what makes a dashboard possible on top of it, because everything’s already connected.

The skill that runs this correspondence sweep, along with the register template it feeds, is part of what’s in the ContractorOS community library, alongside more than 40 other pre-built workflows members can download and adapt to how they actually run projects.

What does a register dashboard actually show you?

A register dashboard is a live viewer built on top of your structured register, showing what needs your attention today without opening the underlying database. Because the register is already structured and relational, building one in Claude Code is straightforward, you’re just querying data that’s already connected.

On one of my own projects, selecting the project brings up the open items that need attention that day. Drilling into a specific one, an extension-of-time claim, for example, shows the current status (with the engineer, in this case, so not something I have to chase yet), the attachments, and the original message, with a link back to the underlying Airtable record if I want the full detail. It’s the same information that would normally live in a spreadsheet you open twice a week and mostly avoid. The dashboard just makes it somewhere you actually want to go.

Register upkeep is one thread in the broader picture covered in AI for construction workflows. The wider pattern I’m building toward for the ContractorOS community is three layers stacked on each other: your project context (files in SharePoint, Google Drive, wherever they live), a structured database underneath that holds registers and other reference data, and workflows, like the correspondence sweep, that use both to keep things current. Dashboards sit on top as the viewer. None of it works if the layer underneath isn’t structured and current, which is exactly why the automated update matters more than the dashboard itself.

One extension worth mentioning: after a phone call, you can log it straight into the same system with a voice note instead of typing it up later, which means the record of what happened gets captured while it’s still fresh instead of reconstructed from memory.

This is a narrower slice of the same trust boundary that runs through AI for construction contract administration: AI drafts and tracks, a person decides what any of it means. It also pairs directly with AI for writing construction RFIs, where the same routine pattern applies to drafting the RFI itself, not just tracking the response.

What stays with you when AI runs the register

AI does the reading, the matching and the logging when it runs a register. It sweeps new correspondence, checks it against what’s already there, and updates the row. What it doesn’t do is decide what a response means, whether it changes anything, or what happens next. That judgment stays with the person running the project.

Task	What AI does	What stays with you
Reading new correspondence	Sweeps the inbox, works out what’s relevant	Nothing, until it surfaces something
Matching to the register	Checks for duplicates, finds the right row	Confirms it matched the right item
Logging updates	Adds or updates the row, notes the status	Reviews anything marked low-confidence
Interpreting a response	Nothing	Decides what it means, what changes
Escalating overdue items	Surfaces what’s sitting past due	Decides who to chase, and how hard

That last row is where research on contract management backs up what the register is actually protecting. Poor contract management costs companies an average of 9% of their bottom line, according to World Commerce & Contracting, and separately, the average construction dispute in North America runs to $60.1 million and takes 12.5 months to resolve, per Arcadis’s 2025 Global Construction Disputes Report. A register that’s actually current is one of the cheapest defenses against ending up in that number.

Common mistakes to watch for

• Treating the dashboard as the fix. The dashboard is just a viewer. If the register underneath isn’t being updated, a nicer viewer shows you the same stale data faster.
• Skipping the manual run before scheduling it. Get the output right by hand on a real inbox first. I ran mine manually and checked the result before trusting the 4am schedule.
• Not checking the early runs closely. This matters most in the first week or two, so you catch the process matching the wrong item or missing an update before it becomes a habit you stop questioning.
• Letting AI resolve what a response means. It can note that an RFI answer arrived. Whether that answer settles the issue, changes the drawings, or needs a follow-up is still yours to decide.
• Running this with no real inbox discipline underneath it. If correspondence isn’t arriving in one place, a project email address you CC everything into, for instance, there’s nothing consistent for the scheduled task to sweep.
• Ignoring a low-confidence note. If the process isn’t sure an item matches, that’s exactly the row to check by hand, not skip.

The full walkthrough, including the live scheduled-task run and the dashboard build, is in the video above.