In June 2026, the high-risk provisions of the EU AI Act take effect. Any organization using automated decision-making in employment, finance, benefits eligibility, or critical infrastructure must explain those decisions to customers, regulators, and auditors. Penalties run up to €35 million or 7% of global turnover.
The standard response is to bolt explainability onto AI systems that were never designed to explain themselves. Frameworks like SHAP and LIME approximate which inputs mattered most to a black-box prediction. They are useful, but they are inferences about a stochastic system — best-effort reconstructions of reasoning that lives in billions of parameters. They are not the actual reasoning, and they cannot be.
There is another option: don't use a system that needs to be reverse-engineered. Use a system whose reasoning is the output.
The platform
Sertainly is a platform for compiling decision logic — your own, or anyone's — into deterministic, citation-bearing decision APIs.
You start with a source: an internal policy document, a regulatory publication, a contract, a procedure manual. The platform helps you compile it into Business Decision Language: a structured ruleset where every statement carries the citation it came from. The result is callable as an API, an MCP server, or directly in your application. Every evaluation returns a complete trace — which rules fired, which inputs they consumed, what the source citations are, how each value was produced.
There is no language model at runtime. The decisions don't come from a probabilistic system that needs a layer of explanation glued on top. They come from rules that explain themselves by their existence.
This works for the IRS publication that defines federal payroll withholding. It also works for your bank's internal lending criteria, your insurance company's underwriting guidelines, your hospital's admission protocols, your platform's content moderation rules. The architecture doesn't care whether the source is public or proprietary. It cares whether the logic can be specified — and most regulated decision logic already is.
Why this satisfies the Act differently
Article 13 of the EU AI Act requires high-risk systems to be transparent enough that users can interpret outputs and use them appropriately. Article 14 requires effective human oversight. Article 15 sets standards for accuracy and robustness.
A compiled-policy decision satisfies these requirements without the workarounds:
On transparency. The system's behavior is fully described by its rules and the source they came from. No hidden weights, no training data, no model drift.
On interpretability. The trace reads like the source document because it was compiled from the source document. A subject-matter expert can read it directly, without translation.
On robustness. Determinism is a stronger property than accuracy. The same inputs always produce the same outputs.
On version control. When the source changes — a regulation republishes, a policy gets revised — the package recompiles. The diff is auditable. There is no equivalent for “the model was retrained.”
What this is not
Compiled-policy decision systems don't solve every requirement of the EU AI Act. The Act requires risk management, data governance, technical documentation, and quality management around the broader system in which a decision is deployed. Those obligations remain. What Sertainly does is eliminate the hardest of them — explainability of the decision itself — from the list.
It's also worth being precise about scope. The EU AI Act applies to systems used in the EU. The architectural argument for compiled policy doesn't depend on EU regulation — it stands on correctness, auditability, and operational stability — but the regulatory environment is making the argument urgent in a way it wasn't a year ago.
The honest comparison
SHAP and LIME aren't wrong. They solve a real problem when machine learning is the architecture you're committed to. The question is whether machine learning is the right architecture for decisions whose logic is already specified in writing — in regulations, in internal policies, in contracts.
For those decisions, a compiled rule executor is a better fit than a language model with an explainability layer. Not because rules are smarter than models, but because the decision wasn't a pattern-recognition problem to begin with. It was a rule-execution problem that got miscategorized.
What we built
Sertainly compiles decision logic into deterministic, traceable APIs. We maintain a catalog of compiled public policies — federal payroll withholding, FMLA eligibility, accredited investor determination — that customers subscribe to and integrate. We also let customers compile their own policies into private packages they own and operate.
In both cases, the architecture is the same. There is the source, the compiled rules, and the trace. When a regulator asks how a decision was made, the answer is a section number and a worksheet. When the source changes, the package changes with it. When questioned, the system explains itself.
This is what compiled, not prompted, means. The explainability isn't a layer. It's the architecture.