The technology
Deterministic outcomes from a probabilistic engine.
That is the whole engineering problem, and this page is the technical tour of how it is solved. Agentic AI is probabilistic — capable, and unrepeatable. A business process needs the opposite: the same behaviour, run after run, provably. AI++ gets there by construction: the probabilistic engine operating inside a deterministic, compiler-verified structure — the plan — with every action it takes checked as it happens.
The home page shows what it does. This page is how it holds.
Under the hood
How a plan earns the right to run.
An under-the-hood look at how the AI authors a plan — here, the maintenance plan from the home page. The AI writes in a formal language; the compiler refuses every draft it cannot prove; the AI fixes what was refused and submits again, until nothing is left to refuse.
The authoring loop
# ── Types ─────────────────────────────────────────────
record Triage
trade : text # The trade the repair needs.
urgency : ( 'routine' | 'urgent' )
summary : text
end record
record Vendor
name : text
estimate : money # The written quote for this job.
end record
record Approval
grantedBy : text # Who authorised the spend.
note : text
end record
record Slot
window : text # The agreed access window.
end record
record Confirmation
inWriting : ( 'yes' | 'no' )
note : text
end record
# ── Plan ──────────────────────────────────────────────
# 1 · triage
pluck
try @reasoning=high
: Read the tenant's message and any attached photographs. Classify
: the trade, judge the urgency against the standing urgency rules,
: and summarise the problem in one sentence.
try @reasoning=high
: Consult the unit's maintenance history and classify from prior
: reports of the same fault.
verify → ( 'pass' | 'reattempt' ) @reasoning=high
? $($$.trade) is a real trade, and $($$.urgency) follows the
? standing rules given the evidence in the message.
failure message
! The report could not be classified from what the tenant sent.
end pluck → TRIAGE : Triage
# 2 · vendor
work
do @reasoning=high
: Choose one vendor for $(TRIAGE.trade) from the approved list,
: covering the property's postcode. Record the vendor's name and
: the written estimate for this specific job.
verify → ( 'pass' | 'fail' ) @reasoning=high
? $($$.name) is licensed for $(TRIAGE.trade), insured to date,
? covers the postcode, and has no open dispute.
failure message
! No eligible vendor could be found for this repair.
end work → VENDOR : Vendor
# 3 · the limit
decide
evaluate @reasoning=low
? Is $(VENDOR.estimate) over the owner's standing approval limit
? for a single repair?
end decide → LIMIT : ( 'over' | 'within' )
# 4 · approval
switch $(LIMIT)
when 'over'
interact
select @reasoning=medium
: Pick the owner of the unit.
failure message
! No owner could be identified for this unit.
deliver
: What was reported, which vendor was chosen, and the
: estimate $(VENDOR.estimate).
collect
: Ask for approval to proceed, and wait for the answer —
: however long it takes.
verify → ( 'pass' | 'reask' ) @reasoning=medium
? $($$) is an explicit approval or refusal from the owner.
end interact → APPROVAL
when 'within'
work
do @reasoning=low
: Record the standing approval — $(VENDOR.estimate) is
: within the owner's limit, so no ask is needed.
end work → APPROVAL
end switch → APPROVAL : Approval
# 5 · the slot
negotiate
select @reasoning=medium
: Pick the tenant who reported the fault, and the vendor
: $(VENDOR.name).
failure message
! The tenant or the vendor could not be identified.
collect
: Converge on one access window, honouring the standing
: contact-hours rule. The tenant must be present or give written
: consent recorded against the work order.
end negotiate → SLOT : Slot
# 6 · the work order
work
do @reasoning=medium
: Raise the work order carrying $(VENDOR.name), the approved
: amount from $(APPROVAL.note), $(SLOT.window), and the access
: arrangement.
verify → ( 'pass' | 'fail' ) @reasoning=low
? The work order exists and carries the window, the amount and
? the access note — check the record itself.
failure message
! The work order could not be created.
end work
# 7 · tell the tenant
notify
select @reasoning=low
: Pick the tenant who reported the fault.
failure message
! The tenant could not be identified.
deliver
: Expect $(VENDOR.name) during $(SLOT.window) — with the access
: note, and how to reschedule if the window fails.
end notify
# 8 · confirm
interact
select @reasoning=low
: Pick the tenant who reported the fault.
failure message
! The tenant could not be identified.
deliver
: The access window has passed — checking on the repair.
collect
: Ask whether the repair is complete, and for confirmation in
: writing.
verify → ( 'pass' | 'reask' ) @reasoning=medium
? $($$) says clearly whether the repair is complete, in writing.
end interact → CONFIRMED : Confirmation
# 9 · report
work
do @reasoning=medium
: Report the final cost and the outcome to the owner —
: include $(CONFIRMED.note) and both photographs.
verify → ( 'pass' | 'fail' ) @reasoning=low
? The report names the amount actually invoiced and carries
? both photographs.
failure message
! The owner report could not be assembled.
end work
VERIFIED · draft 3 · 9 steps · every value assigned on every path
The diagnostics are written for the AI, not for you — it reads them, fixes what it got wrong, and submits again. A person is consulted only when a fix turns on something the AI cannot know: which of two readings of a rule you actually meant. What matters is that every draft that could not be proven was refused, automatically, before anything ran.
AI++ core principles
What the system holds itself to.
Each one is enforced by the machinery, not by discipline.
Proven before it runs
An AI writes the plan as a structure of typed steps; a compiler proves it
before it may run — every value assigned on every path, every branch of every decision
covered, nothing produced that nothing uses, every check aimed at what it claims to check.
What fails goes back to the AI, in the vocabulary of the process. And anything that never
changes between runs — a fixed rule, a stable reference — is resolved once at
authoring, shown for approval, and written in, so a run never pays to rediscover it.
Zero-trust, inside and out
Perimeter protections wrap each step individually, and the interior assumes the
perimeter will one day fail: steps share no conversation and no scratchpad; each receives
exactly the named values the plan routed to it and returns a declared shape, checked before
anything downstream may see it. Hostile text lands as data in the one step that asked for it
— it cannot change which branch is taken, cannot enlarge its own reach, cannot leak
what it never saw. Containment, not a promise of elimination.
Policy exact, judgment human
Standing decisions are captured once, checked for collisions, and enforced from
the first authored word; every change is validated for consistency with the processes already
defined and running. Policy is applied exactly as written — and a run comes to a person
only when the decision is genuinely theirs.
No engineering required
The times when launching an agentic automation required a build are over. In
AI++, automating a process is a conversation — minutes, plus one person who knows
today’s manual process well enough to describe it and to eyeball the proposed plan.
What accumulates is the company’s own specification: it lives with the business and
outlives any single process.
Right-sized intelligence
Each step runs on its own agent at its own reasoning depth, chosen per step
when the plan is authored — deep reasoning where judgment lives, a fast model where the
work is mechanical. Nobody pays for deep reasoning to confirm a postcode.
Checked while it runs
Every acting step’s result is reviewed by an independent evaluator
— its own agent, its own instructions, no access to what other steps said, so it cannot
be talked into a pass by the thing it is checking. The verdict and its reasoning are kept.
Where a step gathers data, it tries genuinely different sources in order and stops only when
a separate check confirms the result answers the question — and if every source comes
up empty, it stops and says so in the plan’s own words rather than inventing a
plausible answer.
Waits and chases as long as it takes
A step holds a conversation with a named person for hours or weeks and picks up
exactly where it stopped; another works several people in parallel until everyone who must
sign has signed. Progress commits step by step, so an interruption on our side resumes at the
last completed step — never starting over, never silently repeating something that
already happened. Each person sees their own conversations in one place, across every process
waiting on them.
Recorded, always
Every prompt with the values that went into it, every result under its
published name, every verdict with its reasoning, every message to a person, and the cost
— per run. Documents run against a versioned workspace: every run gets its own, changes
are committed step by step, and any earlier state can be restored.
What it deliberately does not do
Each of these is a deliberate boundary. None is a gap waiting for a later version.
It doesn't decide what it wasn't told to decide
The process is fixed and readable before it runs. It does not improvise a new step
because a run went sideways — it stops, in the words the plan carries for exactly that case.
It doesn't hide a failure
A stop that was designed for is reported in plain language. A stop that wasn't is
reported as a failure with the technical detail kept for whoever has to fix it — never dressed up
as a result.
It doesn't practise anyone's profession
In regulated work it collects, tracks, reminds, escalates to a human and reports
status. It does not advise, decide a case, or file anything. That boundary is written into the
process as a standing decision, so it is visible in the diagram and checked like anything else.
It isn't a chatbot with tools
Nothing here depends on a model choosing well in the moment. The structure is fixed
and proven first; the models fill in the parts that genuinely need judgment, and each one is checked.