Checking a progress claim against the contract before a named person certifies it
A payment application on a capital project is an arithmetic exercise sitting on top of a contractual one. The quantities claimed have to agree with what was measured, the rates have to be the ones the contract sets, work outside the original scope only counts once it has been instructed, and the amount due is what remains after the last certificate, retention and any set-off. Most of the effort is reconstruction — pulling the previous position, the rate schedule and the period's measurement records back together before anyone can read the claim at all. Modeled as one orchestrated process, that assembly and the checks that go with it happen before the claim reaches a person, and the certificate stays where the contract puts it: with the person named to issue it.
A reference architecture: how RoboAgentix would model this process on UiPath. It is not a description of a delivered project, and no client, result or metric is implied.
What starts it
A contractor or subcontractor submits the period's payment application through a project portal, a monitored mailbox, or the claim register in the cost system.
Why it is orchestrated rather than scripted
- The process runs on contractual dates — an assessment window and a certification date — so it has to hold state against a clock rather than time out between runs.
- Rates, retention and set-off terms differ by package and by form of contract, and belong in one editable rule rather than a separate variant of the same automation for every package.
- The certified amount is the figure a dispute is argued over later, so the measurement, the clause applied and the certifier's own changes have to be reconstructable long after the project closes.
How it runs on UiPath Maestro
The process is defined in BPMN and Maestro runs it across agents, robots and people, holding its state for as long as the work takes — including while it waits on an approver.
Step by step
- 01
Payment application arrivesSystem
A contractor or subcontractor submits the period's application through the project portal, a monitored mailbox, or the cost system's claim register.
- 02
Assemble the claim packRobot
The application is classified and read into claim lines by Document Understanding, each quantity, rate and item reference carrying a confidence score, and the contract's rate schedule, the instructed variations, the period's measurement records and the previously certified position are pulled in against the package's cut-off date.
- 03
Value it against the contractAgent
Each line is reconciled to a measurement record, checked for an instruction where it sits outside the original scope, priced at a contract rate, and carried into a valuation that deducts the last certificate, retention and any set-off.
- 04
Supported by the contract?Maestro
The orchestrator routes on whether every claimed line is supported, and on whether the excluded lines need commercial review before the pack goes forward.
- 05
Certify the valuationPerson
The named certifier sees the recommendation, the exclusions and the measurement behind each line, and certifies the amount they consider due. No path issues a certificate without them.
- 06
Record the certificateRobot
The certificate, its line detail and the retention held are written to the cost system, and the payment instruction the certificate authorizes is raised in the finance system.
- 07
Certified and recordedSystem
The cumulative position moves on, and the recommendation, the exclusions, the certified amount and the certifier are written to the audit record.
What each agent is allowed to decide
An agent is only useful in a governed process if its authority is written down. Each one below has a defined input, a decision it may make on its own, and the condition that obliges it to hand over.
Measurement Agent
Reconciles what is claimed against what has actually been measured.
Reads
- The claim lines and the quantities they assert
- Measurement sheets, survey records and progress sign-offs for the period
- Delivery and storage records for materials claimed as on site
- The quantity already certified against each item
Decides on its own
Must escalate when
Variation Agent
Separates work that was instructed from work that was only done.
Reads
- Claim lines that fall outside the original scope
- The instruction and variation register for the package
- The contract clauses on valuing varied work, indexed for retrieval
Decides on its own
Must escalate when
Valuation Agent
Builds the amount it recommends for the period from the supported quantities.
Reads
- Supported quantities and the contract rates that apply to them
- The last certificate and the cumulative position to date
- Retention, advance recovery and set-off terms for that package
- Contra-charges raised against the package before the cut-off
Decides on its own
Must escalate when
What the robots do
Deterministic steps stay with robots — the same action every time, including in systems that never exposed a usable API.
Claim pack robot
Digitizes the application and gathers the rate schedule, the instructed variations, the period's measurement records and the previously certified position into one pack.
Runs in
Certification robot
Writes the issued certificate and its line detail back to the cost system and raises the payment instruction it authorizes.
Runs in
Supported by the contract?
Every claimed line traces to a measurement record and a contract rate, work outside the original scope rests on an instruction, and the net recommendation reconciles against the last certificate, retention and any set-off.
- Passes
- The pack reaches the certifier as recommended, with nothing outstanding on it.
- Does not pass
- Unsupported lines are separated into an exclusions schedule and put to commercial review first; the pack still reaches the certifier, and the process stays open until the certificate is issued.
Modeled as a decision table, so the threshold can be changed by the people who own the policy without redeploying an automation.
The human step
Who
What they see
What they decide
People are in this process because judgment or authority belongs to them — not as a fallback for a step that failed.
What this design deliberately does not do
An automation is only trustworthy if its limits are written down as plainly as its capabilities.
- It does not issue the certificate. Certification is a contractual act, and the process cannot complete without the named certifier acting on it.
- It does not measure work. It reconciles a claim against records produced by the people responsible for measuring; where no record exists the line is unsupported, not estimated.
- It does not agree a rate the contract does not already carry. Varied work with no applicable rate is carried as unagreed and left to the commercial parties.
- It does not release retention or settle a contra-charge that is in dispute — both stay with the people the contract gives them to.
Failure has a defined path
Systems go down, confidence drops, approvers go on leave. Each of these is a modeled branch rather than a stuck instance.
- The cost system or the variation register is unavailable at the cut-off.
- The instance holds at pack assembly and retries on the queue rather than valuing against a partial pack. If the pack is still incomplete at the escalation point set for that package, the instance is raised to the commercial lead with the missing source named.
- The measurement agent cannot support a claimed quantity above its confidence threshold.
- The line is kept out of the recommendation and moved to the exclusions schedule with its reason and the records that were searched. The rest of the claim continues to be valued rather than the whole application stalling.
- The certifier does not act as the contractual certification date approaches.
- The task is reminded on the schedule set for that package, then raised to the delegate the contract names. The process does not certify by default and does not close; the elapsed time stays visible on the instance.
- A line is claimed twice — within one application, or against a period already certified.
- The duplicate is matched against the cumulative position, held out of the recommendation, and both the current line and the earlier certified line are put in front of the certifier together.
Data, rollout, and what to watch
Data it touches
- The process handles commercial data — rates, valuations, retention and set-offs — that is normally restricted to a package's own commercial team. Access follows the package, so a reviewer on one package does not see another's rates.
- Agents read contract terms through a retrieval index over the contract documents and cite the clause they applied. They hold no contract text outside that index, and they write to neither the contract nor the variation register.
- Site records carry names on timesheets and sign-offs. Those fields are redacted before an agent receives the record, and are shown to the certifier only where authorship is part of what they are checking.
- Instance data, the document store and the retrieval index are held in the region the organization specifies, and connectors are configured to read source documents in place rather than copy them. Retention of the instance follows the period the contract and the organization's own policy set for a payment certificate.
How it goes live
- 01
Shadow
The process runs on live applications alongside the existing assessment, and nothing it produces reaches the certifier. Each recommendation is compared line by line with what the commercial team assessed by hand. The gate to the next phase is that every difference has a known cause — a missing record, a rate lookup, a rule written wrong — rather than an unexplained one.
- 02
Supervised
The pack, the recommendation and the exclusions schedule go to the certifier through Action Center, but a commercial reviewer checks the build first and can amend it. The gate to the next phase is that the reviewer's amendments stop being corrections of the process and become commercial judgment the process was never meant to make.
- 03
Assembled unattended, certified by a person
Pack assembly, measurement reconciliation and the valuation build run without a reviewer in front of them; exclusions and anything an agent escalates still route to commercial review. Certification stays with the named person in every phase — it is not a step the rollout removes.
Signals worth watching
- The share of claim lines reaching the exclusions schedule, and whether it concentrates in one package or one subcontractor.
- How often the certifier changes a line the process recommended, and in which direction they change it.
- The time between an application arriving and its certificate being issued, read against the contractual date rather than an internal one.
- The proportion of claimed work resting on variations whose rate is still unagreed, tracked across the life of the package.
Named without target values. What good looks like depends on your volumes and your risk appetite, and is set with you rather than asserted here.
The UiPath components this design uses
UiPath Maestro
Runs the BPMN process and holds its state for as long as the work takes, including while it waits on a person or a system that is down.
UiPath Agent Builder
Where each agent is defined — its instructions, its tools, its inputs and outputs, and the escalation that sends work to a person.
UiPath Document Understanding
Classification and field extraction, returning a confidence score per field that the policy gate can route on.
Context Grounding
A retrieval index over your own policies and reference data, so an agent cites the rule it applied instead of recalling it.
UiPath Action Center
Where a human step actually lands. The approver gets a task with the agent's reasoning and sources attached, and the process resumes on their decision.
UiPath Orchestrator
Schedules the robots, holds queues and retries, and issues the least-privilege credentials each automation runs under.
UiPath Integration Service
Connectors to the systems of record, so the process talks to them through a maintained integration rather than a bespoke script.
Systems it touches
- Cost management or project controls system
- The contract, its rate schedule and the variation register
- Site measurement and progress records
- Finance system for payment instructions
- Project document store
What the run leaves behind
- The application as submitted, and the claim lines extracted from it
- The measurement record behind each supported quantity, and each quantity that had none
- The instruction relied on for every line outside the original scope
- The valuation build — gross, each deduction, the clause behind it, and the net recommended
- The certifier, the amount certified, what was excluded, the reason and the time
Other representative workflows
Talk to us about a process like this.
The most useful first conversation is about a real process — where it stalls, who approves what, and which systems it touches.