Checking a Cost Estimate With an AI Agent: Cross-Checking Your Own Documents Locally

A cost estimate is a document where almost any mistake costs money: a rate applied to the wrong line, a duplicated item, a quantity in the estimate that doesn't match what was actually done. Checking an estimate is routine work with a clean, measurable outcome: either a discrepancy turns up, or it doesn't. Here's what an AI agent can genuinely do here, and what it can't.

First — what this article covers, and what it doesn't

The market for "AI for estimates" tools is already sizable: there are products that pick rates from current regional pricing databases on their own, compare line items against supplier prices, or generate an estimate straight from a drawing. That's a separate class of product with its own pricing-norms database built in — Doka doesn't contain that kind of database and can't select rates against construction pricing norms. If what you need is a calculation against current estimating standards, this isn't that.

What Doka can do is different: read your estimate and whatever documents you show it — an instruction, acceptance reports, a specification, a contract — and cross-check them against each other. The difference is fundamental: not "AI knows what something should cost," but "AI checks whether what's written in the estimate matches what's written in your own documents."

What an agent can actually check

• Cross-check work quantities in the estimate against a specification or project documentation — is a line item duplicated, is a row missing.
• Compare the estimate against a completion certificate — where a sum doesn't match, what's been closed out and what hasn't.
• Check the estimate against a checklist or instruction you write yourself: "for every line item under 'Electrical,' check whether a unit of measure is given and whether the quantity exceeds the design value."
• Find duplicate or suspiciously similar line items within one estimate — a common cause of accidental duplication when copying rows.
• Merge several estimates into one summary — several section-level estimates, for instance, into one table for a quick overview.

In every case, the agent works from documents you put in the working folder, and follows a rule you spelled out in words — not built-in knowledge of pricing norms.

Why do this locally instead of an online service

An estimate is a commercial document. It contains a contractor's rates, margin, supplier terms — things you usually don't show competitors or a client before signing. Most online estimate-checking services work one way: upload the file to their server, get a result. That's fine for a one-off check, but inconvenient if estimates are a regular workflow with real prices and counterparties in them.

Doka reads an estimate and its supporting files on your own computer. If you connect a local model, the data itself never gets sent anywhere — not while reading the file, not while generating the answer. For a file sitting in Excel or exported from your estimating software, this isn't a change of tool, it's a change in where the data goes during the check.

How this looks in practice

The mechanics are the same as for any spreadsheet work: show the agent a working folder with files and describe the task in words. For example:

The folder has an estimate estimate.xlsx and a specification spec.xlsx. Compare the work quantities for every line item in the "Roofing" section. For every discrepancy, give the line number, the estimate value, the specification value, and the source file. If a line item is missing from one of the files, note that separately, don't skip it.

From there, the agent opens both files and goes through them, showing the steps it takes — which files it reads and what it compares. The result is a table of discrepancies, not a rough impression.

If the estimate is split into several files by section, you can ask the agent to merge them into one file with section totals before cross-checking.

Being honest about the limits

Three things worth keeping in mind so you're not disappointed.

The agent doesn't know current pricing norms. It won't tell you whether a rate is inflated relative to a regional pricing database or market price — that needs a dedicated pricing-database service, or an estimator with access to one. Doka cross-checks your own documents against each other, not against an external price reference.

The source file format matters. An estimate in Excel or readable PDF parses well. A scan of a paper report or a photo needs OCR first — regular file reading can't pull text out of a scan.

The result needs checking. On a large estimate with hundreds of line items, the agent can miss a row or mismatch similarly worded lines ("cable installation" and "cable routing" might mean the same thing to a person, and look like two different rows to an exact text comparison). The right mode: the agent does a first pass across the whole estimate, and a person does the final check on the discrepancies it finds, rather than trusting the list blindly.

What if you need a check against pricing norms or for a formal review

If the estimate is headed for a formal regulatory or expertise review, that process runs through specialized systems and has its own compliance requirements against current pricing standards. That's not a job for a general-purpose AI agent — it needs an estimator with access to the current pricing database, or a specialized service that contains one. Doka is useful for the step before that: getting your own documents in order and cross-checked, before handing the estimate off for formal review.

Where to start

Take one estimate and one document you'd normally cross-check it against by hand — an acceptance report, a specification, or a previous version of the estimate — and ask the agent to find discrepancies in one section. If the result matches what you'd have found yourself, move on to the whole estimate. Download Doka for free, and for working with documents in general, see the article on document analysis.