← Back to Blog
2026-07-07· 5 min readAI QuotingVertical AIVerification

The Trades Are Raising Billions for AI. The Quote Is Still the Hard Part.

Concept illustration of a blank price tag chained to a ledger and database while an abstract AI cloud stays outside a boundary.

In March, a startup called Rebar raised $14M for software that reads a construction blueprint and produces the quote 60–70% faster than an estimator with a spreadsheet. A month later, Avoca hit a $1B valuation for a voice agent that answers the phone for plumbers and HVAC shops before a competitor can pick up.

None of this existed two years ago. The money is placing a new bet: that AI's next real job is in the trades — and that it starts at the quote.

I've been in this world from the other side. I run facilities maintenance for a retail chain, and I built the pricing tool my own operation uses. So when a hackathon asked for an autopilot agent, I built one for the thing I actually live in — quoting.

Hackathon screenshots
Sanitized synthetic pricing screen with all quote details obscured.
synthetic pricing screen
Sanitized synthetic negotiation rehearsal screen with all conversation details obscured.
synthetic rehearsal screen

And the part that mattered wasn't the AI writing the number. It was the places I took the AI out.

A quote is a promise about money. A confident wrong number isn't a smaller version of a right one — it's a lie the customer acts on.
Diagram
model zoneLLM-free truth zonehuman gate

work order

source context

LLM drafts

price language + rehearsal

human gate

approve before money moves

DB truth

COUNT(*) / frozen quote / loss reason

Rule 1: Where a wrong number becomes a lie, remove the model

Every quoting demo wants to show the AI being clever. Mine has a line on screen that looks boring: "14 deals, 9 won."

That line is never generated. It's a COUNT(*) off the database.

// not this — a number the model can round to "about 10":
const won = await llm("how many of these did we win?")

// this — the database counts, the model never touches it:
SELECT COUNT(*) FROM deals WHERE outcome = 'won'

The moment an LLM writes "9 won," you've built a system that can round 9 to "about 10"on a bad decode and sound just as confident doing it. In the one place where a wrong number is a lie a human repeats to a client, the model doesn't get to speak. The database counts. The model never touches it.

Rule 2: Freeze the number, or it drifts

Ask the same model the same question twice and you can get two prices. I measured it: on one work order, same inputs, the price drifted up to 18.8% run to run.

So a quote, once made, is frozen to the database. Reopen it tomorrow and it's the exact price — not a fresh guess that happens to be close. A quote you can't reproduce isn't a quote.It's a mood.

Rule 3: No silent losses

Every deal that's lost has to say why. The system won't record a loss without a reason — a loss with no cause is treated as a bug, not a data point.

It sounds like bookkeeping. It's actually the only way the next quote gets smarter: the reasons you lost last month are what price this month.

What the AI is actually for: rehearse the fight, don't make the call

So what does the LLM do, if it's fenced out of the counting, the freezing, and the record? It preps the negotiation.

Here's what the pricing math alone misses: the client always wants it lower. Always.That's not noise in the deal — it's the whole climate. A structurally correct price is table stakes; a correct price the client doesn't believeis still a lost job. So the agent's real work starts after the number is already right — make it defensible.

It works out two anchors — the market going-rate, and thisclient's willingness-to-pay read off their own history — and drafts a price with a justification the client can actually follow. A human approves it (Gate 1). Then it runs a rehearsal: a client agent attacks the price, a contractor agent defends it, turn by turn, and the useful lines get distilled into a battle card. A human keeps the lines worth keeping (Gate 2).

The justification and the rehearsal are belt-and-suspenders on a price that's alreadystructurally correct — a second layer of insurance on the number your business lives or dies on. AI preps the fight. The human closes it.Two gates, placed exactly where money changes hands — not a UX afterthought, the architecture itself.

Diagram
LLM work

draft

model prepares the case

approval

human gate

approve quote before sending

LLM work

rehearsal

model tests objections

approval

human gate

keep only usable lines

 Let the model do itKeep the truth outside the model
Counting"9 won" — generated, can quietly roundCOUNT(*)— the DB counts, always
Pricingfresh guess each open, drifts 18.8%frozen to the row, reproducible
Losinglosses vanish, nothing learnsevery loss names its reason
Decidingagent auto-fires the quotehuman gate where money moves

The point

The funding wave is real, and it's aimed right here — the trades want AI in the quote, and they're paying for it. But the market doesn't need another tool that generates a confident number. It needs a number you can defend to the person signing the check.

The interesting engineering in an AI quoting tool isn't the prompt. It's the discipline about where the AI is not allowed to speak.

What I carry forward

  1. Put the LLM where being wrong is cheap; take it out where being wrong is a lie.
  2. A number you can't reproduce isn't a number. Freeze it.
  3. The human gate goes where money moves — not where it's convenient.

The agent is a hackathon build, open source under MIT. Data is 100% synthetic — fictional clients, fictional prices. The problem is real; the data never was.

The project is open source: GitHub repo · 3-min demo

The same discipline, in production.

How I design AI systems that ship — measured, gated, verified.

See the Work