ScopeForge doesn't read a project — it closes it.

Every claim carries its receipt.

ScopeForge reads your drawings and specs into a complete, source-cited model of the scope — and the paperwork that closes it.

You close the job. ScopeForge holds the receipts.

Book the demo

Live, on a real project.

The job lives in a thousand pages. And one head.

A project's truth is spread across the drawing set, the spec book, the addenda — more pages than anyone holds completely — plus whatever the PM carries in memory. Three things go wrong, over and over. Work sits in the documents, never gets registered, and gets built unpaid — or disputed. Finished work can't be certified, because the proof paperwork — submittals, inspections, certifications, warranties — went untracked, so payment doesn't release. And when the one person who holds the job is on another site, decisions stall or go wrong. The tools you've been given store what someone typed. The problem was never storage.

It reads the documents. All of them.

Feed ScopeForge the drawing set and the spec book. It builds a complete, checkable list of every piece of work the project contains — where each item appears on the drawings, and what paperwork must close before that work counts as finished and payable. It keeps that list current as documents change, and every entry can show the exact page that created it.

Every other tool is a system of record — it stores what your team types in. ScopeForge starts a layer earlier, with what the documents state.

Nothing drops silently.

Every item read ends in one of three states: asserted with its source, escalated for your judgment, or not in scope. The counts sum to the total — so the system can tell you what it couldn't read.

The audit ledger, summing live.

Two clicks from claim to page.

Click any scope item and land on the sheet and legend row that created it. Closeout requirements are quoted verbatim from your spec book — never paraphrased.

Claim to source, on the real drawings.

You hold the verdict.

The AI proposes; you decide. Ask for a quantity the drawings don't state and the answer is "not stated" — it will not guess, and a wrong guess can never become a billing claim.

The honest no; send-and-freeze.

From documents to a model you can check.

It reads what the sheets literally say — embedded text and coordinates first, exact on computer-drawn sheets; vision only as a fallback for scanned regions — and every read is checked against an independent witness before it's trusted.
Legend rows become scope items; callouts become their located instances. Everything is keyed by CSI — the numbering your spec book already uses.
Each scope item gets its closeout requirements pulled from the spec book — quoted verbatim against the spec's own text, never paraphrased.
Your screens — scope review, coverage, submittals, the audit ledger — read from that model. Click anything; land on the page that created it.

It will not guess.

Some of what ScopeForge won't do is the point.

It won't compute quantities. It transcribes what the drawings state; a computed takeoff wrong by ten percent is your liability, so it doesn't produce one.
It won't author your RFIs. It surfaces the gap; the formal question to the architect is a contractual act, and it's yours.
It won't decide review stamps. It reads the returned stamp; you confirm it.
It won't replace the owner's system of record, and it won't rebuild P6. The schedule of record stays where it is.
It won't guess expert judgment. What a project "should" contain beyond what its documents state is either learned from practitioners or not answered.

On your machine. On the record.

Desktop-first: your daily working tool, fast on large drawing sets, with project data in a database under your control — not in a browser tab.
Nothing erased: when addenda and bulletins land, new conclusions supersede the old — never overwrite them. Ask what the record showed on March 3rd, and why; get the answer with its sources.
Proposes, never executes: reads come back directly; anything consequential — a record write, a sent document — waits for your confirmation. A wrong guess cannot silently become a billing claim or a mailed submittal.

Early, and honest about it.

ScopeForge is pre-launch. It's built and tested on one real public-school restoration project — a full drawing set and spec book, not a sample. QA is adversarial: a dedicated tester is paid to break it, she finds real bugs, and fixes are re-proven against her exact attacks. There are no customers yet; the first ones will be able to check every claim on this page against the running product. That's the arrangement.

See it on a real project.

The demo runs live on the real corpus — the ledger summing, claim to source, the honest no, send-and-freeze. Bring a skeptic.