Authorization against your own rules, in real time. A signed record on file. Defensible years later.
{ "decision_id": "CS-LOGISTICS-20260504T142019Z-7K2M", "outcome": "ALLOWED", "rulebook": "credit-policy-v2.1", "binding_rule": null, "authority": "Operations Manager (T2)", "timestamp": "2026-05-04T14:20:19.342Z" }
A signed Authorization Record. Produced before the decision executes. Kept on file for the retention period.
Same input. Same rulebook. Same answer.
ClearState is the layer between an operational decision and the system that executes it. It confirms — in real time — whether the decision is allowed under current policies and mandates, and produces a record of that confirmation.
Today this step is often manual, fragmented and undocumented.
Legitimate decisions often get stuck because no one can see, in the moment, that they are allowed. ClearState gives the operator that answer in real time: ALLOWED, with the named authority and rule on file.
The right decisions move. The wrong ones don't.
When something is missing — a mandate, a limit, an authority — the system says NOT ALLOWED with the exact rule that didn't hold and the role required to escalate.
No ambiguity. No "let me check with someone."
A customs guarantee, a netting exposure, a credit line, a fund mandate cap. Today these are checked at end of day, end of week, or when someone asks. By then the breach has already happened.
ClearState checks the limit at the moment the decision is proposed. If the next shipment, trade, or drawdown would push the exposure over the line, the system says NOT ALLOWED — with the limit that would be breached and the role that can authorize an exception. The breach doesn't happen.
Defending a decision under audit or regulator review is, today, a reconstruction exercise. With ClearState, the record exists at the moment the decision was made.
Pulling it up years later is one query, not a project.
Who was allowed to decide what, on which date, under which version of the rules — that's a system property now.
Not something an experienced colleague has to remember.
Before a decision is released, ClearState authorizes whether it can proceed.
If something fundamental is missing, the decision does not proceed. If the decision is complete, it is tested against your policy and authority. The result is binary.
Same input. Same rulebook. Same answer.
Existing tools each solve part of the problem. ClearState combines rule enforcement, authority validation, and decision records at the moment of execution.
| Capability | Audit tools | Rules engines | AI copilots | ClearState |
|---|---|---|---|---|
| Records what happened | ✓ | partial | partial | ✓ |
| Applies rules in real time | ✗ | ✓ | partial | ✓ |
| Validates authority before execution | ✗ | ✗ | ✗ | ✓ |
| Produces reproducible decisions | ✗ | partial | ✗ | ✓ |
| Stops decisions when authority or rules fail | ✗ | partial | ✗ | ✓ |
| Produces a signed decision record | ✗ | ✗ | ✗ | ✓ |
| Identifies undefined ownership, authority, or escalation paths | ✗ | ✗ | ✗ | ✓ |
ClearState is not a workflow, audit, or recommendation tool. It is an authorization layer.
Rules engines require the rule, authority, and escalation structure to already exist.
ClearState also identifies when it doesn't. When ownership is unclear, mandate is undefined, or no valid escalation path exists, the system stops before execution and makes the gap explicit. The output is not "the rule was broken" — it is "no one is named to make this decision under these conditions, and here is what would need to be defined."
That is where rules engines, BPM tools, and AI governance platforms cannot follow. They assume the governance is there. ClearState identifies when it isn't.
The 2025–2026 reports from Deloitte, KPMG, EY, and McKinsey point to the same gap: organizations have governance policy, but lack per-decision authorization at execution time.
Low-value consignments, platform-driven volume, and growing customs pressure. From 1 July 2026 the EU's €150 duty exemption is removed — declaration volume and guarantee exposure shift at the same time.
A customs operator decides in real time which shipments consume remaining guarantee capacity, under which release rules, and within which authority.
ClearState authorizes each declaration before submission — against current capacity, prioritization rules, and release authority. Same input. Same rulebook. Same answer.
A customs operator submits declarations against a guarantee envelope approaching its limit. Multiple shipments wait for release. Not all declarations can be authorized within remaining capacity.
The question is not only whether a declaration fits. It is which shipments consume remaining capacity, under which release rules, and within which authority.
ClearState authorizes the declaration before submission — against current capacity, prioritization rules, and mandate. ALLOWED or NOT ALLOWED with the exact rule and named authority. If NOT ALLOWED, the escalation path is shown.
Other domains — same architecture, same authorization layer.
Trade authorization against fund mandate, investor restrictions, and current rulebook version. LP subscription eligibility. Liquidity Management Tools activation.
Limit checks, exposure rules, named credit authority binding. SME credit underwriting where AI copilots produce recommendations but the credit officer carries the file.
Bind/no-bind decisions with named underwriter authority and rulebook version on file. Trade credit, surety guarantees, AI-assisted underwriting where the underwriter carries the file.
Permit decisions, eligibility determinations, and regulated approvals where the citizen has a right to know which rule applied.
Payment authorization against limits, sanctions, and counterparty rules at the moment of release. Operator mandate matched to transaction.
Existing tools either run rules or write down what happened. ClearState authorizes the decision — and produces a defensible record at that moment.
The difference is timing: before execution, not after. And output: a binary authorization with a named authority, not a workflow step or a log entry.
Two to four weeks from first conversation, depending on how quickly we can get access to your historical decision data. The pilot itself is three weeks.
No. Most organizations don't, and that's part of what the pilot reveals. We translate what exists — documents, exceptions, things people just know but no one wrote down — into a rulebook the system can run, together with your team.
The rulebook is the deliverable, not the entry requirement.
Typically: one operations lead who knows how decisions are actually made, one compliance or legal lead who knows what the rules should be, and one technical contact who can get us access to historical data.
The pilot doesn't require IT integration.
We move from historical analysis to live authorization on new decisions. Integration depends on your environment.
The rulebook you keep doesn't change — it's now applied in real time.
The Authorization Record names the decision-maker, the rulebook version active at decision time, the rule that authorized or stopped the decision, and the timestamp. The defence is the record itself.
The same input against the same rulebook produces the same answer — so the decision is reproducible years later.
A set of historical decisions — typically 3 to 12 months of operational data. Your existing policies, mandates, and authority structure, in whatever form they exist today (often documents, often inconsistent).
We translate your policies, mandates, and authority into a rulebook the system can run. We process your historical decisions through ClearState and show what the system would have said — ALLOWED or NOT ALLOWED — for each one. Where the system would have stopped a decision, we show why.
If you choose not to license, you walk away with the rulebook and the historical analysis. The runtime stops. 50% of the pilot fee is credited toward license if you continue.
The pilot produces five things. They're yours, regardless of whether you license the runtime or not.
The policies, mandates, and authority structure that govern your decisions — translated from documents and undocumented practice into a rulebook the system can run. You own it. You can share it with regulators, auditors, or LPs. If you don't license ClearState, the rulebook is still yours.
Every decision in your pilot dataset processed through ClearState, with the outcome the system would have produced — ALLOWED or NOT ALLOWED — and the rule that drove it. You see what would have changed.
Most organizations discover during the pilot that their rules aren't actually written down — or that they're written down inconsistently, or that the documented version doesn't match what people actually do. The pilot makes those gaps visible. That's value on its own, even if you go no further.
Real records from your historical decisions, showing the named authority, the rulebook version, the rule that authorized or stopped the decision, and the timestamp. You can hand these to your auditor, regulator, or internal reviewer and ask: is this the evidence you need?
Either you license the runtime and move to live authorization on new decisions, or you don't. Either way, you have the rulebook, the analysis, the gaps, and the sample records. There is no obligation. There is no lock-in.