The contract you signed, on one page.
The Contract Summary is the Trueleveler engine that compresses a 40–80-page subcontract into a 2-page field-ready brief your PM can actually carry. Payment terms, retainage rate and step-down, liquidated damages, insurance minimums, claims notice periods, and the dispute resolution sequence — each one surfaced with a page citation so the PM knows exactly where to look when something goes sideways at month 9. The full-risk Contract Review is for review. This is for use.
Try it now
Contract Summary runs on a signed contract (PDF) and needs a free account (no card). It has no sample data yet, and the no-signup demo only levels bids.
The contract is a binder. The PM needs a card.
A signed subcontract is a 60-page binder. The PM running the field never reads it again after award. When the architect rejects a CO at month 9, the PM has to know the claims-notice window. When the sub stops paying lower-tier, the PM has to know if there's a contingent-payment trigger. When the retainage-release request lands, the PM has to know the substantial-completion definition. None of those answers are within easy reach of someone whose desk is a job-site trailer.
Contract Summary reads the executed subcontract and produces a structured 2-page brief: the key terms card up top, then payment + retainage, claims + notice deadlines, insurance requirements, and the dispute resolution sequence. Every section line carries the clause reference (§ + page) so the PM can jump back to the source when they need to quote it. Companion engine to Contract Review — Review surfaces the risks pre-signature, Summary surfaces the obligations post-signature.
Day one of project execution. Every PM transition. Every claims moment.
Contract Summary runs at handoff and stays a reference for the project's entire life. Run it at the moments where a clause matters.
- Estimator-to-PM handoff — the PM Handoff engine pulls Contract Summary as the centerpiece of the handoff package. New PM walks the job with the summary card in hand on day one.
- Pre-mobilization PM kickoff — print the 2-page brief, distribute to the field super, the project engineer, and the project accountant. Everyone reads the same summary instead of the same 60-page binder.
- Mid-project PM swap — incoming PM rebuilds context fast. The summary plus the active project's tracker state covers 80% of what the new PM needs in 30 minutes.
- Before filing a notice — the claims section spells out the notice window and the recipient. PM verifies they're still within the window before the email goes out.
- Pre-closeout — verify retainage-release prerequisites, lien-waiver requirements, and substantial-completion definitions before the final pay app submits.
The executed contract. That's it.
One required input. Optional context narrows the summary to the contract type if useful.
Signed contract (PDF)
The executed subcontract, prime contract, or owner-GC agreement. ConsensusDocs, AIA A401 / A201, ConsensusDocs 750/751, or custom forms — all parse. Multi-document contracts (general conditions + supplementary conditions + addenda) are linked and summarized together.
Contract type hint
Subcontract / prime contract / owner agreement. The summary structure adapts — a sub gets the contingent-payment row up top, a prime gets the LD exposure and owner-supplied items section.
Project metadata
Contract value, start date, substantial-completion date. If supplied, the deadline rows compute concrete dates (e.g., "Notice of claim due: 06-Sep-2026, 21 days from event") instead of generic windows.
The 2-page brief. Five sections, each clause-cited.
Sample summary for an executed AIA A401 subcontract on a commercial tenant fit-out, $1.86M, 18-month duration:
A PM in a phone call with the owner doesn't have time to read a 60-page contract to find the answer. The summary says "21-day notice per §10.2, p.18." The PM either knows the answer or knows the page to look. Every field is deliberately paraphrased — short, plain-language summaries rather than verbatim contract sentences — and the trap clauses and ongoing watchpoints that carry the real risk are the ones that keep a clause reference attached, so you can jump straight to the source when it matters.
One summary. Feeds the engines that use the contract.
Contract Summary is the field-side companion to Contract Review. The summary's structured data feeds every downstream engine that needs to enforce a contract term.
- Contract Review — the clause-by-clause risk review feeds Summary, and Summary's structure pulls the same source clauses. Run Review first for the risk lens, Summary for the operating brief.
- PM Handoff — the handoff package inherits the summary as its centerpiece. The incoming PM gets the 2-page brief plus the risk register plus the contacts — everything needed for day one in one place.
- Pay App Review — retainage rate, payment terms, lien-waiver requirements, and contract-revised SOV all flow from Summary's payment section into the pay-app reconciler.
- Insurance Tracker — the insurance requirements section is the schema that COI tracker validates against. Required minimums + endorsements + waiver-of-subrogation all carry forward automatically.
Things everyone asks first.
How is this different from Contract Review?
Contract Review surfaces risks before signing — clause-by-clause severity ratings, suggested redlines, position vs. standard. Contract Summary surfaces obligations after signing — the executed terms the PM operates under. Most teams run Review during negotiation, then Summary the day the contract is executed. Both engines read the same documents, just answer different questions.
What contract forms are supported?
AIA A101 / A102 / A107 / A201 (general conditions) / A401 (subcontract), ConsensusDocs 200 / 500 / 750 / 751, DBIA, EJCDC, and custom forms. The engine identifies the form on parse and uses the form's section numbering convention. Custom contracts (owner-drafted, GC-drafted) work but with slightly lower field-mapping confidence — the summary still composes correctly, the clause references just need PM verification on first run.
What about supplementary conditions and addenda?
Multi-document parsing. Base contract + general conditions + supplementary conditions + addenda all upload together. The engine resolves overrides correctly (e.g., if a supplementary condition modifies the retainage rate, the summary reflects the modified rate with both clause references). The hierarchy is preserved in the audit trail.
Does it catch trap clauses?
Yes. Clauses tagged TRAP CLAUSE are ones with material consequences and tight deadlines (waivers, notice requirements, schedule-modification triggers, pay-when-paid). Each TRAP is severity-highlighted in red on the brief with the consequence spelled out: "Missed notice = waiver of claim." The full Contract Review engine handles the risk-rating side; Summary just flags so the PM knows which lines are non-negotiable.
Can the summary update mid-project?
Yes. If the contract gets amended (executed CO modifies a payment term, agreed-upon change in retainage, etc.), upload the amendment and the summary re-issues with the change reflected. The previous version is archived in the project's contract history. The deadline math (claims windows, etc.) recomputes off the amendment date when relevant.
Who uses this most — GCs or subs?
Both. Subs run it on the GC-issued subcontract before mobilization. GCs run it on the prime contract for the project team and on every executed subcontract for the subcontract management database. Same engine, same plan tier, same structure — perspective is set by the contract type and who's named where.
Drop a signed contract. See the 2-page brief in 60 seconds.
Bring one executed subcontract or prime contract to a 15-minute call. We'll process it on screen, walk the five sections, and you keep the printable brief for the trailer wall.
Try Free for 14 Days →