Approach
Built. Proved. Proven.
Three stages. We have completed two of them, and the third is already mapped.
- Stage one
Built
The first domain we modelled and built infrastructure for. A bank was prepared to hand us the running of its guarantees on the strength of it, a considerably higher bar than a pilot. We did not set out to operate that business; the domain was modelled properly and the demand followed.
- Stage two
Proved
Carried into a second, unrelated regime without a rebuild, and trading commercially in it today. The two domains have nothing in common but the shape of the problem, which is precisely what we needed to find out. The architecture survived a change of domain.
- Stage three
Proven
What comes next. International evaluation of each jurisdiction runs to a published schedule, so we know which markets open and roughly when. The engine, the orchestration and the evidence standard are constant; the regulator, the terminology and the local law are a mapping exercise. Two stages are behind us and paid for. The third is a question of pace.
The five layers
The first four carry no assumption about the domain. That is the whole claim: the domain is an input, not the architecture.
Codify the framework
A regime arrives as prose: an Act, guidance, years of interpretation. Turning that into deterministic logic is the slow, expensive part, and it never finishes. This is the layer competitors underestimate, because it does not look like product.
Bind it to the world
That logic is only useful connected to the registries, verification providers and counterparty systems the process depends on. Each market has its own sources; the interfaces are ours.
Orchestrate the parties
Most software assumes one user with one goal. These processes involve several parties with different obligations and no reason to hurry. Getting all of them to done is where the elapsed time goes, and where most implementations quietly fail.
Make the record defensible
The output must withstand examination long after the transaction closed. Audit trail, version history, identity assurance and finality are properties of the architecture, not features added afterwards.
Operate it
Where the work still needs judgement or persistence, we do it rather than hand over a dashboard. That is deliberate, and it is also how the system learns which cases are genuinely hard.
Read as a ladder that is misleading. It is a circuit.
Doing the work is how we learn the work
Layer five is not the end of the process, it is the input to layer one. In both businesses we deal directly with our customer’s customer: every party to the transaction, not only the one who pays us. That is where a rule as drafted meets a situation nobody anticipated. Because we own the codified layer, what we see there becomes a change to the logic rather than a feature request in a queue, and it ships to the whole market.
It is also how we knew the two businesses were the same system underneath. We did not deduce that in a strategy session; we discovered it by operating both.
Why this is hard to copy
Tools-only software leaks its own IP by construction. The vendor ships the product; the customer’s people do the judgement work, and what they learn forms off the platform, in someone’s head, an email thread, a spreadsheet nobody else opens. The vendor never sees it. The customer loses it when that person leaves. Every customer re-learns the same lessons.
We run that flow the other way. The work happens on the platform, so judgement lands as structured data, once, for everyone. The gap widens in both directions at the same time: they lose what their customers learn while we bank it.
It holds because three things are true together: we own the codified rules, so we can change how the process behaves; we do the work, so we see where it breaks; and the stack is modern enough to ship that change across a market quickly. A software vendor has the first and third. An outsourced team has the second. An incumbent may hold all three nominally and release quarterly, which forfeits the third.
We measure it the obvious way: human minutes per matter by case type, and the share completed without intervention. Both trend one way, and neither reaches zero.
Where this is proven
ARCaml is the primary application. myGuarantee is a second application of the same capability, and an ARCaml customer, which is what demonstrates the two compose rather than merely coexist.