Four cents
Most construction software was built for the build. But a contractor's revenue and margin are decided earlier, at the estimate. That's where we think AI agents can do the most good, and here's what it takes.
Table of contents
Four cents. That's roughly what a general contractor keeps from every dollar it builds, before tax.
One wrong line in an estimate can take all four. Miss a scope item on page 214 of the drawings, take a sub's quote that quietly leaves something out, and a job that looked like a win ends in the red. The opposite mistake is just as quiet: the bids a team never had time to send, for work it could have won.
Most construction software was built for the build. Scheduling, daily logs, documents, inspections - the part of the job you can see. The part that decides whether a company grows, and whether a job makes money, happens earlier, in a spreadsheet, against a deadline. It's the estimate.
Revenue is decided by how many bids you send. Margin is decided by how well you price them. Both happen at the estimate.
This piece is about why estimating is the cornerstone use case for AI in construction - the one the rest of the business rests on - and how it should be approached.
How the work flows
Construction covers a huge range of work. Homes, apartment blocks, stores, restaurants, data centers, remodels. Some projects run for years and others for a few months, and the companies that build them specialize to match.
Under that variety, most commercial work follows the same chain. An owner wants something built - an investment group, a developer, a retail chain. Unless the owner is a developer that builds everything itself, it usually doesn't have the expertise in-house. So it hires a general contractor (GC) to plan the project and run it. The GC rarely does every trade itself, so it hires subcontractors (subs) for specific work: foundations, roofing, windows, electrical, mechanical.
The mix varies. Some developers do almost everything themselves and bring in subs only for extra capacity. Some GCs do a few trades with their own crews and subcontract the rest. Sometimes the owner's architects have already done part of the design. But the shape holds: owner, then GC, then subs.
The delivery is a waterfall. First a concept, then a design that goes through several rounds of revision and approval, then construction. Each stage has its own problems, and technology has gone after each of them with varying success.
Construction itself is fairly well served
During the build, the biggest pain is rework - work that has to be torn out and done again, often discovered at the very end, when the client walks the site. Across 359 projects studied by the Construction Industry Institute, direct rework costs alone often came to about 5% of total construction cost.
That pain has attracted a lot of software. There are tools for quality control and site inspections, experiments with drones, daily logs, project tracking, and document control so everyone builds from the current drawing. Procore is the name most people know, and it has plenty of competitors. Not every firm has adopted these tools, and some still run projects over email and spreadsheets. We wouldn't call this part of the market solved, but it has had years of serious investment.
Procurement - buying materials and subcontractor services - straddles preconstruction and the build. It matters a lot in a business with thin margins, and marketplaces and bidding platforms such as BuildingConnected are working on it.
The stage before all of that has had much less attention.
The real pain is preconstruction
A lot of commercial work is won through competitive bids. An owner - say a retail chain opening a new store - sends an invitation to bid to its approved GCs. Each GC puts together a proposal. To price it with confidence, the GC runs a tender of its own: it sends the scope to subs in each trade and collects their quotes. Public tenders work the same way, and subs play the same game one level down, often quoting the same project to several GCs.
This is where owners of construction firms focus, because it's where growth comes from. The funnel is simple. You win more work by bidding more, or by bidding better. Most bids lose - contractors commonly aim to win one bid in three to five. Even a better hit rate doesn't change the basic math, so the number of bids a team can send is usually the bottleneck.
Revenue is a function of bids submitted
More invitations arrive than a team can answer well. Each comes with a bid package - the project description, drawings, specifications - and a deadline. Several competitors are bidding the same job, often leaning on the same subs, so the timeline is tight for everyone. A good estimate takes real time, and estimators are expensive: a commercial building estimator in the US averages about $101,000 a year. You can't hire your way out of the queue.
So invitations get passed over. Not because the work is wrong for the company, but because nobody could respond in time. Each one is revenue the business never got a chance to win.
Margin is decided at the estimate
Construction runs on thin margins. US contractors keep about 4 to 8 cents of pre-tax profit on each dollar of revenue - 4.4% for GCs and construction managers, 7.7% for specialty trades. That's net margin, what's left after every cost. Gross margin, before overhead, is much higher, which is why you'll often hear a bigger number quoted.
On a 4% net margin, a miss of 2% in the estimate halves the profit. A missed line item isn't a rounding error. It's the difference between a job that pays and one that doesn't. Averages hide this, too: some jobs make a lot and others lose a lot. We think much of that spread starts at the estimate, for a handful of reasons.
Drawings get skimmed
Against a deadline, nobody reads every sheet. Estimators work through the drawings as fast as they can, and things get missed - a detail on one sheet, a note in the specifications, a site condition that changes the scope. Whatever's missed at the estimate is either absorbed by the contractor or argued over later.
There's often no cost history to lean on
Where no sub quotes a line, the estimator prices it from experience. That works if the company keeps a clean record of what past work really cost. Many don't. The history lives in old spreadsheets, closed jobs in the accounting system, and people's memories. About two in three estimators used spreadsheets in their workflow in the last big industry survey, in 2019, often alongside dedicated estimating software.
Every trade is a mini-tender
To price the job, the estimator needs quotes from subs in each trade. That means posting the package on BuildingConnected or a similar platform, or emailing subs one by one, answering their questions, chasing the ones who haven't replied, and then doing it all again for the next trade. It's a lot of back-and-forth to fit inside a bid window.
Quotes don't compare
When quotes come back, they rarely cover the same scope. One sub includes permits and another doesn't. One priced the alternate, another missed a sheet. Usually nobody is trying to cheat - someone didn't read closely, or read it differently. But the numbers can't be compared as they are. The estimator has to level the bids - line them up scope by scope, find the gaps, and fill them - before picking a sub. A gap missed here comes back during the build as a change order.
One agent, one spreadsheet
Look at that list again. Almost every problem on it is about reading, cross-checking, or communicating. That's work AI agents are good at, as long as a person stays in charge of the judgment.
The approach that makes sense is one AI agent working with the estimator in one shared spreadsheet - the tool estimators already use. Everything happens in the same file, so the estimator can see what the agent did, change it, and pick up where it left off. The work runs in four steps.
1. Read the package and extract the scope. You forward the invitation email with its attachments. The agent reads the bid package and the drawings, and builds the skeleton of the estimate: the scope of work by trade, with quantities, dimensions, and the conditions that could affect the price. No prices yet. General-purpose models aren't strong at reading drawings on their own, so this step needs models built for drawings working alongside them. The estimator reviews the scope before anything gets priced.
2. Draft a preliminary estimate from your own past projects. The agent goes through the firm's history - past projects, their scopes and drawings, what they cost - finds similar jobs and similar parts of jobs, and fills in preliminary prices, each marked as preliminary. It's a baseline, not a final number, grounded in what this company has actually built.
3. Reach out to subs, and track every reply. For each trade, the agent suggests subs from the firm's own list, or suggests posting the package on BuildingConnected. Once the estimator agrees, it prepares the scope package, sends it, answers clarifying questions, sends reminders, and collects quotes. A separate tab tracks every trade: who was invited, who replied, whether a quote is preliminary or final, and what's still being discussed.
4. Level the quotes and assemble the final package. As quotes arrive, the agent checks each one against the scope from step 1, flags what's missing or extra, and lines them up so they can be compared fairly. Then it proposes a configuration for the final bid - which sub for each trade, and why. The estimator reviews it, changes what they want, and approves it. Nothing goes to the owner until a person signs off.
The estimator's job changes shape: less time reading and chasing, more time judging.
An illustrative example
Here's what that could mean for the cost of one bid. These numbers are an example, not a measurement. Say an estimate takes 8 hours of estimator time today. At the BLS average for a commercial building estimator, that's about $389 in wages. Now say the agent does the first pass, and the estimator spends about 2.9 hours checking, correcting, and approving it. Add a small agent cost, and the same estimate comes to about $150.
The saving per bid isn't the main point, though. The bigger effect is the bids a team can now answer, and the gaps it catches before they turn into change orders.
What it needs underneath
An agent like this is only as good as what it can see. Reading the package well comes first - if the scope is wrong, every later step inherits the mistake. Beyond that, two things matter.
A workspace. The firm's documents, its past projects with their estimates and final costs, and its list of subs, all in one place. This is where a company's expertise builds up over time: its prices, its contacts, its sense of which subs deliver. The richer that history, the better the preliminary estimate. It's also what makes the agent work like this company's estimator, rather than a generic one.
Connectors. Estimating doesn't live in one system. Packages arrive by email, drawings sit in shared drives, and subs are on bidding platforms. So the agent needs to reach OneDrive, SharePoint, Gmail, Outlook, Procore, and BuildingConnected - reading what's there, and posting invitations where the firm already does.
The bid comes next
An agent like this also has to earn trust one step at a time. The fair test is the estimator's own work: how much of the scope it pulls from a real package, how close its preliminary prices land to what the firm's estimators priced, whether its leveling catches the gaps an experienced estimator would, and, over time, how its estimates compare with what jobs really cost. Anything that can't show that shouldn't be pricing bids.
Construction got its software for the build first. The bid is where the business is won or lost, and it's still run on skimmed drawings, old spreadsheets, and email threads against a deadline. That's the problem we keep coming back to.
If estimating is your bottleneck, we'd like to hear how your team handles it.
