Never miss a notice window again.
PrimX reads project correspondence and live project events, detects EOT and Variation risk, drafts the contractual response, assembles the evidence, and waits for your approval before anything is issued.
The contract operating layer for Australian builders. Not a chatbot. Not a task list. Contract administration logic, running live — on every project.
Entitlement isn’t lost to bad contracts.
It’s lost to administration.
Most entitlement isn’t lost because the contract was unfair. It’s lost because nobody has time to administer the contract perfectly, every day. After award the contract goes in a folder. Notice windows live in people’s heads. EOTs get spotted too late. Variations get buried in email. Evidence is chased after the fact. Registers are updated by hand, if at all.
Industry research puts the average construction dispute in the tens of millions, with failure to properly administer the contract among the leading causes. The contract was never the problem. Keeping up with it — on every project, every day — was.
From project event to contractual action.
PrimX turns contract administration into a live operating loop. It isn’t a tool you open when you remember to — it runs the moment a project event lands and keeps running until the obligation is closed and on the register, with audit-grade lineage at every step.
Interpret
Every incoming event is classified against the contract’s function registry — EOT, variation, payment, defect, statutory notice.
Retrieve
Relevant clauses, programme data, correspondence, and supporting evidence are pulled together automatically.
Draft
A complete, contractually-compliant submission package is assembled — the notice plus its evidence manifest.
Approve
You review, fill any genuine gaps, and approve. Nothing leaves the system without a human signature.
Convert
The approved submission becomes a register entry — the system of record, permanently linked to its source.
Remember
The outcome feeds the classifier and the counterparty model, so the system gets sharper with every cycle.
Brief
Daily briefings keep you oriented across every live obligation, deadline, and open position on the project.
Repeat
The loop never stops. New events ingest, obligations trigger, deadlines track, the register stays current.
interpret → retrieve → draft → approve → convert → remember → brief
Built first around the workflows that cost builders money.
PrimX runs end-to-end on the two functions where entitlement is most often lost — Extensions of Time and Variations. Caught as they happen, drafted with the evidence, and held for your approval before anything is issued.
Extension of Time
- Detects delay events from correspondence, weather and project signals.
- Links every claim back to the clause that creates it.
- Drafts the EOT notice and claim with the evidence manifest.
- Tracks evidence and names the inputs still missing.
- Requires your approval before issue, then writes the EOT register.
Variations
- Detects superintendent directions and changed scope.
- Opens a protective notice or full-claim workflow.
- Supports valuation inputs and a line-item cost breakdown.
- Updates the variation register after issue.
- Feeds approved full claims into your commercial calculations.
Weather-triggered EOT detection runs from project weather signals and is available as a pilot capability — production weather-data sources are connected per project. Other clause functions extend the same framework as they come online.
Every part of the CA function, engineered as one system.
PrimX doesn’t rely on generic templates. It ingests your actual contract, maps clause functions like EOT and Variation, and turns those clauses into executable project logic — deadlines, required evidence, submission structure and approval pathways. Each capability below is purpose-built around a function of contract administration, not a task list dressed up with construction labels.
Contract Intelligence
A hybrid engine — deterministic rules first, AI classification in the borderline band — maps every clause to its operating function and assigns a confidence score to every call.
Continuous Event Detection
The system reads project email as it arrives and detects EOT and Variation triggers in seconds. Project weather signals extend the same pipeline — so causes are caught the moment they occur, not weeks later.
Deadline Engine
Derives every contractual deadline from the clause that creates it — notice periods, EOT windows, payment schedules, SOPA timeframes, defect liability — and tracks them live, escalating before they fall due.
Action Hub
Every obligation surfaces as an action with provenance back to its clause. Nothing falls through the cracks. Escalations fire ahead of the deadline, not after the entitlement has lapsed.
Submissions & Registers
Each submission compiles a complete, contractually-compliant package — clause reference, register entry, programme revision, supporting evidence, linked correspondence — pre-populated, reviewed, and signed off before issue.
Evidence Graph
Notices, photos, programmes, directions, and correspondence link into a queryable causation graph. Build the claim once and the evidence chain is already assembled — and defensible — when you need it.
Clause functions
Latent conditions, payment claims, and defect workflows extend the same framework — each new function reuses the one before it.
Autonomous where it saves time. Controlled where it matters.
Contract administration is too consequential for confidence theatre. PrimX does the work — detection, drafting, evidence — but every external submission is approved before issue, and that approval is tied to the exact version being sent.
Shadow
The system watches, classifies, and tracks — silently. You see what it would have done, and judge it against your own calls. Trust is built on evidence, not promises.
Assisted
The system drafts the notices, assembles the evidence, and queues the actions. You review and approve. The assembly is automated; the judgment and the signature stay with you.
Autonomous
Within bounds you set, the system runs routine cycles on its own and surfaces only what needs you. Even here, external notices always wait for approval. Autonomy is a setting, not a surrender.
Audit-grade lineage
Every action, register entry, and submission carries an immutable link back to the originating clause and the data it relied on. Built for the day a dispute makes you prove every step.
Approval is locked to the version you saw
Every issue is checked against a fingerprint of the approved content. Change a slot, a posture, or a number after sign-off and the send is blocked until it’s re-approved. You can never accidentally issue something other than what was approved.
It tells you what it doesn’t know
Low-confidence calls are flagged for review, not waved through. Missing inputs are named explicitly — “anchor date missing, cannot compute claim window” — instead of being quietly guessed.
Deterministic first, AI second
The engine reaches for hard contractual rules before inference. AI fills the gaps the rules can’t — it never overrides them. Predictable where it can be, intelligent where it must be.
Human-in-the-loop, always
No notice, claim, or formal communication is ever issued to another party without your explicit approval. The system does the work; you make the call.
The longer it runs, the harder it is to live without.
Because the contract is treated as executable logic rather than a document to search, capabilities compound. Each one builds on the loop you’re already running — and on the project data only your projects can generate.
Breach radar
Continuous listening across email, programme files, weather and statutory feeds. The moment a notice window opens, a draft is already waiting. Nothing slips through, ever.
Counterparty modelling
Patterns learned per principal and per superintendent across projects — how they respond, what they contest, where they concede. A moat no competitor can replicate without your data.
Adversarial simulator
War-game a position before you submit. See likely outcome ranges at each escalation tier and the expected value of settling versus pressing — before you commit.
Living contract twin
Variations, directions, side letters and waiver-by-conduct auto-amend the live contract. A clause-level risk heatmap shows which obligations are hot given current project state.
Back-to-back engine
Head contract, subcontracts and consultant agreements linked at the clause level. A head-contract event fires and pass-down obligations to subs are calculated and triggered automatically.
Compounding intelligence
Every clause function makes the next one cheaper. Every event source makes every function sharper. Every closed cycle makes the system more accurate. The product improves by running.
PrimX is the contract operating layer.
Project management platforms run the project. PrimX runs the contract that drives it.
Most construction software operates at the project execution layer — tracking tasks, drawings, RFIs, daily logs. PrimX operates one layer beneath, on the contract logic that defines what the project must deliver, when, to whom, and with what evidence. It is not a project management tool, not document search, and not a generic AI assistant — it is contract administration logic, running live, alongside the tools you already use.
Made for the contracts Australian builders actually administer.
PrimX speaks the language of Australian construction contracts — and the people who administer them.
Standard-form fluent
Fluent in the Australian standard forms — AS 4000, AS 4902, AS 2124 and GC21 — with AS 4902 as the proven reference for EOT and Variation. Bespoke and amended contracts are mapped against the same reference frame.
Entitlement-first
EOT and variation workflows are built around entitlement first, paperwork second. The clause is the spine; the submission is the deliverable; the evidence is already attached.
Built in Australia
Designed by and for Australian contract administrators. SOPA timeframes, Australian standard forms, and the realities of head-contract and subcontract administration are first-class concerns.
Priced per contract, not per seat.
Start with one live contract. We map it, activate EOT and Variation workflows, connect your project correspondence, and run PrimX in shadow or assisted mode so your team can see what it catches before you rely on it. Scale to your portfolio when the system has earned it.
Pilot
Free assessment
One contract, founder-led setup
- One contract mapped — clause functions identified
- EOT + Variation workflows activated
- Action Hub + project correspondence connected
- Draft submissions + register flow, approval before issue
- Pilot review session with the founder
Project
Custom
Per contract, per month
- All capabilities
- Full autonomy ladder
- Unlimited team seats per project
- Subcontracts included
- Priority support
Portfolio
Contact us
Multi-project, SSO, dedicated success
- Everything in Project
- SSO (Google, Microsoft)
- Dedicated implementation
- Custom integrations
I built PrimX because I watched entitlement disappear on real projects — not because teams didn’t care, but because administering a contract perfectly, every day, while running the job is more than anyone can hold in their head. The obligations were buried in 200 pages and nobody had time to track them clause by clause.
The contract is meant to be the operating manual for the project. PrimX makes it actually function that way — reading every email, deriving every deadline, drafting every notice, with the audit trail to prove it.
If you administer construction contracts in Australia, I’d like to show you what we’ve built. The pilot is hands-on and free.
Request a pilotYour contract is already complex.
Administering it shouldn’t be.
See what PrimX does with your contract in one founder-led session.