Home The example The record The technology The method Agencies & Platforms Send me your process

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 example 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 draft 3 · verified
# ── 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, review the plan the AI proposes — shown as a readable flowchart, not code — and bless it for use. 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.

Integrations

AI++ operates the systems you already run.

A step that has to act in the outside world — raise a work order, update a client file, post an invoice — does it in the system where that record already lives. AI++ connects two ways: through Zapier, which reaches thousands of installed business applications today, and through MCP — the Model Context Protocol, the open standard by which AI systems operate other software. Anything reachable by either is reachable by a plan step, with no integration project in between.

Access follows the plan, not the AI. A step can touch only the systems its step of the plan names — the same zero-trust rule that limits what data it sees, extended to what it may operate — and every call is recorded like everything else: what was invoked, with which values, and what came back.

What AI++ 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.
Send me your process See a record