We use AI extensively, and openly.

The contract: verbatim, or nothing

Our landing page says AI agents quote the law through Lex-Ray "with hallucination guards built in". Marketing sentences deserve falsifiable definitions, so here is the contract that sentence stands on. When Lex-Ray answers — to a human on the page, to an agent over MCP, or to a program over the structured API — the answer is a stored artifact quoted back: a verbatim span of the official text at a stable identifier, in a pinned version, or a human-reviewed artifact layered on top of one and labelled as such. Nothing is generated in the answering path. We reproduce; we never regenerate.

The corollary is the part worth holding us to: Lex-Ray abstains rather than approximates. When it doesn't hold the answer, it returns nothing — an empty result, not a best effort. A system that only quotes stored, identified text can fail by finding nothing; it cannot fabricate a provision, because it has no machinery for producing one. That is a property you can test from the outside: ask for something that doesn't exist, and watch it decline.

Why insist on this? Because a citation is supposed to be a pointer that always resolves, and a generated citation is a sequence of tokens that looks like a pointer. The failure isn't that model citations are sometimes wrong; it's that nothing in the generating mechanism connects the citation to the thing cited. Courts on both sides of the Atlantic have now disciplined lawyers for citing authorities their AI invented — Mata v Avianca in New York, and the 2025 Ayinde rulings in the English High Court, with a formal warning from the President of the King's Bench Division. Every Lex-Ray citation dereferences: to the exact span, in the exact version, at a stable address. Summarisation and probabilistic citation have their place — exploration, orientation, a first draft. Accountability is not that place.

None of this claims our analysis is infallible — the labelled, machine-checked corpus above carries its own honest limits, stated on this page. The contract is narrower and stronger: the substrate never silently changes, never paraphrases, and never invents. What we serve as the law is the law, or it is nothing.

Is this legally "an AI system"?

Article 3(1) of the AI Act defines the thing the Act regulates:

"'AI system' means a machine-based system that is designed to operate with varying levels of autonomy and that may exhibit adaptiveness after deployment, and that, for explicit or implicit objectives, infers, from the input it receives, how to generate outputs such as predictions, content, recommendations, or decisions that can influence physical or virtual environments"

The honest answer is that the definition is vague — its criteria have no clear cutoff for a case like ours. Our language-model pipelines clearly infer, but they operate with no autonomy at all: they run in batch, offline, and everything is gated before publication: by a human editor, or, for formal structure, by a symbolic verifier whose checks you can watch below. Our alignment solver doesn't infer anything; it exhaustively proves its answer (try it below). Our extraction pipeline is a neural proposer wrapped in a symbolic verifier wrapped in a human reviewer. Is a product an "AI system" when its AI components are batch tools behind an editorial desk? The Act's recitals exclude systems that only execute human-defined rules; the Commission's February 2025 guidelines on the definition acknowledge the boundary cases are genuinely hard. Reasonable lawyers disagree; several work here.

Our position: radical transparency. We are not going to litigate the boundary. Out of an abundance of caution, we treat Lex-Ray as an AI system and comply with Article 50 in full: the labels, the machine-readable marking, the human review, this notice. If the definition is ever read narrowly enough to exclude us, we will simply have over-disclosed.

Grounded discovery: AI-suggested, human-approved

Our discovery pipeline keeps Lex-Ray current: it watches official registers and regulator publications, and proposes new resources and milestones. The model's job is to find and summarise, never to invent: every proposal carries its source links, retrieval evidence, and the model's own rationale, and a human editor makes the publish decision. The same discipline applies in our internal studio tooling: the model drafts, a person with their name on the audit trail decides.

The pipeline is designed against hallucination: it starts from trusted source registries, crawls and verifies documents before screening, and deduplicates with concrete signals (URL, content hash, title). Reviewers see the whole chain, and are trained on the failure modes, theirs included.

Good old-fashioned AI: what an ILP actually is

You've met integer linear programming before, even if not by name. It is how FedEx-scale logistics decides which parcel goes on which truck, how airlines build crew rosters that violate none of a thousand union and safety rules, how chips get laid out. It is also a close cousin of the exact search your sat-nav runs when it proves the fastest route rather than guessing one. The recipe has three ingredients: decision variables (a grid of yes/no choices: "does proposal Article 52 map to final Article 50?"), constraints (rules that must hold: each article matches at most one partner), and an objective (a single number to optimise).

For us the objective is text difference. A custom difference algorithm, fine-tuned for how lawyers actually read legislation (what counts as the "same" provision when boilerplate shifts, definitions get rephrased, and numbering moves), scores every combination of old and new text with a distance. That grid of distances is the ILP's input, and the ILP finds the provable global minimum of the total: not the first plausible alignment, not a locally good one, but the floor.

How does a solver find that floor without checking every combination one by one? Not by rolling dice: there is no Monte Carlo sampling here, no gradient descent, no training data. It builds a tree of choices, and at every branch it computes a ceiling: the best total this entire subtree could possibly reach, assuming everything below goes perfectly. If that ceiling is below the best complete answer already in hand, the whole subtree is proven empty and never entered. Here it is on the real numbers from the demo below; each branch shows its score and its ceiling:

Real numbers, from the score grid in the demo below. A branch's ceiling = its score so far + the best each remaining row could possibly add (1.00 + 0.60 + 0.71 + 1.00 + 0.55 + 1.00 = 4.86). When the leaf equals the ceiling, nothing unexplored can beat it. That is the proof.

This is good old-fashioned AI, and the phrase is literal. For most of the sixty-odd years the term "artificial intelligence" has existed, search, logic, optimisation and proof were the centre of the field: Dantzig's simplex method (1947), Gomory's cutting planes (1958), branch-and-bound (1960), the symbolic school the textbooks call GOFAI. Article 3(1) therefore does something remarkable: by defining AI systems through inference and adaptiveness, it hands the term to machine learning and reads the field's first half-century out of it. The solver that routes a continent's parcels (and the one about to prove your alignment below) arguably isn't "AI" under the Act, while a model that guesses fluently is. We think that is worth saying plainly, and it is why our compliance posture never leans on the definition's edges: we disclose as if everything is in scope.

Try it: align the AI Act against its own proposal

When legislation is amended, recast, or replaced, the hard problem is knowing which provision became which. Here is the machinery above, on the most self-referential data we could find: articles from the 2021 AI Act proposal on the left, the final 2024 act on the right. In the proposal, the transparency rules were Article 52. In the final act they are Article 50: the article this page complies with moved. Meanwhile final Article 52 became "Procedure" and final Article 71 was taken over by the EU database. Matching by number is a trap here.

And here are the demo's decision variables: the full score grid the solver optimised over, chosen cells highlighted:

The tuning study: text difference vs cohesiveness

The solver is only half the craft. The other half is what you feed it and how you weight it: slice the text too coarse and a moved sub-paragraph hides inside an "unchanged" block; slice too fine and you end up with all shuffle, no amendments. We swept algorithm families and configurations against each other on a hard real case (the payments recast, where a 1,795-paragraph proposal replaces a 698-paragraph directive), scoring every run on the two axes that matter: how small the residual text difference gets, and how cohesive the aligned units remain for a reader. The chart below is that study, re-run live on our production code: twenty real measured configurations, not an illustration. Toggle the two views: every ILP run finds more total alignment confidence than every sequential-heuristic (DTW) run, and every DTW run is beaten on both axes at once, lower difference and higher confidence, by at least five ILP runs. The second view shows what DTW was ever good at (chunkier blocks), the very property the ILP's block bonus buys back at zero difference cost. The ringed point is our production default.

Try it: watch the verifier catch the model's mistake

The deepest layer of Lex-Ray turns prose obligations into typed logical structure: who must do what, when, under which conditions. This is neurosymbolic AI, perhaps the future of the field, and the marriage of its two great traditions: a neural model proposes structure, because reading nuanced legal prose is what neural models are good at; a symbolic layer (typed schemas, verification rules, grounding back to the exact official words) checks every claim, because guarantees are what symbolic systems are good at. Below is the real GDPR breach-notification provision. Run the pipeline: we've made the model commit a realistic error, and the verifier will catch it in front of you.

The pills above are the story; here is the real thing: the same provision through our production renderer, exactly as it appears in the product. Hover any element and watch it light up the official words it is anchored to. Every pill, every condition, every deadline is a claim about a specific span of the official text, which is what makes the whole structure checkable, by machines and by you:

BetaThis specimen is unapproved extraction, marked exactly as the product marks it.

How do we make a language model produce structure this strict? A glimpse: the model must emit against a typed schema that only admits well-formed logic trees; a validator rejects anything malformed before it exists; every leaf must carry a span of the official text that actually contains its claim (you watched that check run above); generation is pinned deterministic; and the whole pipeline is scored, continuously, against the gold standard our specialists built by hand. The full recipe is the craft we sell, but the shape of it is what you just saw.

Rolling out across the corpus during 2026. Structure like this publishes on the machine's proof, not on a per-item human sign-off, so it carries the "AI-generated" label, and that label means exactly what it says: it might be one of the gold-standard examples our specialists built by hand to teach and score the system, or it might be what the AI produced from them. The verifier, the statistical screens, and the hand-made yardstick are the guarantee; the label itself claims nothing more. And yes: whether an LLM-drafted, symbolically-verified pipeline makes the product "an AI system" is exactly the boundary Article 3(1) leaves open. We don't wait for case law. See above: abundance of caution.

Neurosymbolic AI: a discourse. (Is it just flow charts?)

Let's give the sceptic the first word. "Neurosymbolic AI" gets used as a paradigm word, but in many shipping systems it means: an LLM does all the actual reading, and some JSON schemas stand around it looking rigorous. Isn't the symbolic layer just… types? Flow charts with a research pedigree (Garcez & Lamb call it the field's third wave; the sceptic calls it a rebrand of input validation)?

Partly, yes. And that concession matters, because the power was never that the symbolic layer thinks. It's that it changes how LLM output gets consumed. Raw model output is prose: to use it, you must trust it. Our extraction output is not prose: it must arrive in a rigid shape (a closed schema of typed statements and logic trees), every leaf must cite the exact official words it came from, and the whole thing must survive a deterministic checker before anything downstream is allowed to touch it. Whether the model ran just-in-time or in batch is irrelevant; what matters is the mandatory alignment to structure in between. This is the same architectural bet as LLM-Modulo frameworks, in which the model generates and an external verifier decides what survives, and it buys four concrete things:

• Error types become enumerable. Prose fails vaguely; structure fails in categories: wrong actor, ungrounded span, dropped carve-out, requirement misfiled as trigger. Categories can be counted, tracked, and attacked one at a time.
• Determinism goes up. The shape is fixed, the checker is deterministic, and a re-run either converges to the same structure or fails loudly, with no silent drift.
• Testability. A structure is a claim you can execute tests against, which is what our gold standard is for.
• Hallucination can be eliminated, if done properly. An invented fact has no verbatim span to cite, so a strict grounding gate refuses it: a claim that cannot point at the official words cannot exist in the output. Everything rests on done properly: the gate must demand verbatim substrings, not approximate similarity, or it launders hallucination instead of blocking it.

Now the limit. None of that guarantees the structure is right. A schema-valid, fully grounded extraction can still be the wrong formalisation: the modal read as permission instead of obligation, a condition attached one level too high. Turning natural language into formal structure, autoformalisation, is a known, high-profile weakness of language models (Wu et al., 2022), and legal text is its hardest habitat: the Catala project found that formalising statutes reliably takes lawyers and programmers working line-by-line, together. We operate at the state of the art, and the state of the art is nowhere near finished: it is a Hard problem. That is why the machinery below exists, and why everything it produces ships labelled AI-generated with a hand-built gold standard scoring it continuously.

So: how do we actually coerce a language model into structure? Three real artefacts from the pipeline: the coercion, the shape, and the discipline.

1 · The coercion: extractor system prompt (excerpt)

2 · The shape: the response is forced through a closed schema

3 · The discipline: the repair round, after the deterministic checker

Note what the third block is: we don't ask the model to "try again". We hand it a deterministic defect list and forbid it from touching anything else. Generation is left open; correction is tightly constrained; hard gates sit between every stage. In a production system, that is what "neurosymbolic" amounts to: a consumption layer that refuses to consume anything unproven.

The model that runs while you browse: omnisearch

A correction, in the radical-transparency spirit: an earlier draft of this page said no model output is generated on demand while you browse. Strictly, one model does run live, and it is one of our favourite pieces of engineering, so let's explain it properly instead of lawyering the sentence. When you search within a piece of legislation here, you're not doing string matching. Type punishment into the GDPR and it finds penalties; type data leak and it finds personal data breach, as you type, with the matches highlighted in the text. That is live synonym search, and it works because of vector embeddings.

How vectors work

Start with an analogy. Suppose you scored every provision by hand on a few scales: how much is this about money? about deadlines? about data? Three scores per provision, three numbers, and now every provision is a point in a three-dimensional space, where provisions about similar things sit near each other. An embedding model does exactly this, except nobody chooses the scales: the model learned 384 of them by reading over a billion sentence pairs, adjusting the scales until sentences that mean the same thing land close together. The dimensions have no names (scale 217 isn't "about money"), but the geometry works. Here are real vectors from our production embedder (the first 44 of 384 dimensions, one coloured cell each):

Real output of all-MiniLM-L6-v2, the exact model this product ships: orange cells positive, blue negative. Similarity is the cosine of the angle between two vectors: 1.0 means pointing the same way, 0 means unrelated. Squint and you can see it: the top three strips share a stripe pattern; the bananas don't.

Look at the third cosine: "the amount of the fine shall be proportionate" scores 0.31 against penalties despite sharing not a single word. That number is the entire feature: it is why searching punishment lights up provisions that never say punishment. If you want the full pedagogy, Jay Alammar's Illustrated Word2Vec is the classic, with one correction for what we actually run: word2vec (2013) gave each word one fixed vector; we use a sentence-transformer (a distilled six-layer MiniLM) that reads a whole passage in context and produces one vector for the lot.

The journey of a keystroke

Here is what actually happens between your keystroke and the highlight, straight from the code:

Two of those stages deserve a closer look. Stage 4 is a confession that embeddings alone aren't enough: cosine similarity is brilliant at synonyms and hopeless at exact identifiers ("Article 83(5)"), so we run classic exact matching and TF-IDF alongside and merge the three rankings with Reciprocal Rank Fusion: each method votes by rank, so a paragraph that any method loves surfaces. Stage 5 is the subtle one: to know which words to highlight as synonyms, we score every word in the act's vocabulary against the centroid of your top matches minus its score against the act as a whole (differential similarity), so boilerplate that's near everything stays unlit, and the words specifically near your query glow.

A model in your own browser

The paragraphs of each act are embedded once, server-side, when we enrich the act. The whole index is then squeezed to one byte per dimension (~1.3 MB for a large regulation), shipped to your browser once, and cached in IndexedDB. Searching across a large body of rules — the FCA Handbook — works the same way, one sourcebook at a time: we send the index for a sourcebook when you search into it, rather than sending you the whole Handbook, which would be about 83 MB. Two things follow, and you should know both. Stage 5 does not run on those cross-sourcebook results: the vocabulary vectors that light up synonyms are roughly half of an index and are no use for ranking, so we do not send them, and nothing is highlighted as a synonym until you open the act itself. And a semantic result can only come from a sourcebook already loaded — everything else is covered by ordinary keyword matching over the whole Handbook, which is always on. Where both have something to say, the two are merged by the same Reciprocal Rank Fusion as stage 4, and a provision that matched your actual words is still ranked above one that only matched their meaning. The Handbook search bar says, under its results, which sourcebooks it was able to read that way and which it was not. The query embedder is the same MiniLM, quantised and compiled to run over WebAssembly in a background worker: it warms up quietly, after your first search and only on a device with the headroom for it, and from then on your keystrokes are turned into numbers on your device. Until then, or if your browser can't run it, a single server call embeds the query instead, and the same call works out stage 5's highlight words with the same arithmetic your browser would, so it never has to download the act's vocabulary. Those words are picked from the act's own text, never written. Either way, the model's entire output is 384 floats. It cannot hallucinate a provision, because it never writes one; the only text you ever see is the official text it helped you find.

The honest limits

Embeddings measure similarity, not meaning, and the gap shows in places a lawyer should know about. Measured on our actual model: "the controller shall notify the authority" and "the controller shall not notify the authority" embed at cosine 0.994, near-identical. Negation, of all things, is almost invisible to the geometry. Partial words are another: half-typed tokens embed into noise, so the pipeline literally refuses to suggest synonyms when a query word isn't in the model's vocabulary. This is why the embedder is never trusted alone (stage 4), why it only ever ranks official text, and why the deterministic and symbolic layers above exist.

Three kinds of "AI", three different guarantees

We disclose all three.

The vocabulary: five categories of provenance, one badge

"AI" is not one thing, and pretending it is would be its own kind of dishonesty: it would let a solved optimisation hide behind the same word as a language model's guess. So we sort every piece of content into one of five categories. The first — generative and unapproved — carries a visible badge, and it has two labels: nothing checked (ai-generated), and machine-checked but with no human sign-off (ai-generated-grounded) — where best-effort automated, non-LLM checks appropriate to the data have run. One more category (ai-assisted) carries a machine-readable provenance field but no badge, because a human approved it. The last three carry no marking at all — but we still name them. That is five categories, the six labels in the table below.

The token is the machine value we attach: it rides in the page as a data-provenance attribute and in our API and MCP responses as a provenance field, so another system, human or AI, can read our claim about a piece of content without guessing.

The cell we are proudest of is ai-generated-grounded. The regulatory and provenance vocabularies in circulation — the AI Act, C2PA, IPTC — are effectively binary: AI-generated, or not. None has a slot for whether the machine checked its own work. Ours does: a cited source confirmed to be real and live, or formal-logic structure gated by determinative checks (type-binding, internal-consistency, span-grounding to the official words, exact solvers) against a hand-made gold standard. That is genuinely different from a raw model guess — it is where we can point you at a check rather than ask you to trust an editor's affirmation. We deliberately keep it to one word rather than grade the checks, because the honest claim is the same whichever ran: a machine looked, a human did not. Two things we will not let it become: the checking does not make it non-AI (the badge still says AI-generated), and grounded does not mean the reading of the law is correct — the checks anchor it to something real, nothing more.

Our commitments

• AI-assisted content is visibly labelled where it appears, and marked machine-readably in the page and in exports, in line with Article 50 of the EU AI Act, the Commission's transparency guidance, and the Code of Practice on Transparency of AI-Generated Content.
• Content a named editor individually approved publishes as human work; the editor's review is the claim. Machine-produced analysis is labelled "AI-generated", uniformly: it may be our hand-made gold-standard examples or AI output built on them, and we don't pretend to draw a line within that corpus. Editorial responsibility rests with Simmons & Simmons for everything we publish.
• Official legal text is rendered verbatim from official sources, always.
• No generative model output is produced on demand while you browse. The one live model, the search embedder, produces vectors, not text, and nothing it produces is published or stored.
• This page is updated in the same change as any new AI feature.