Verification Doesn't Translate. It Has to Be Re-Earned, Jurisdiction by Jurisdiction.

This one doesn't start from someone else's post. Everything below comes from actually building and running verification across dozens of legal systems at once, and it's the part of the work nobody outside it seems to reckon with: multi-jurisdictional legal AI is not one hard problem solved once and then translated. It is the same hard problem, solved again, honestly, in every language and every legal family, and the failure mode when you skip that is invisible rather than loud.

The trap of building for one jurisdiction first

Every legal AI system starts somewhere. It gets built, tuned, and tested against one jurisdiction's case law, one language's phrasing, one legal family's way of citing authority, because that is where the founding team and the first customers are. Then it gets "internationalized," and internationalization almost always means translation: the same prompts, the same checks, the same logic, now running in French or Portuguese or Korean instead of English or Spanish.

That looks like coverage. It is not coverage. It is one jurisdiction's verification logic wearing a different language's clothes, and the gap between the two only shows up the day someone actually tests it, which is usually after a client in that second jurisdiction has already relied on it.

The discipline that prevents this is less a feature than a constraint, enforced structurally rather than hoped for: no jurisdiction is allowed to be the default. Every path through the system requires a jurisdiction as an explicit input, with no fallback to a home market if one isn't specified, and no code path that quietly assumes one jurisdiction's rules apply unless told otherwise. It sounds like a small thing. It is the difference between a system that was built for everyone and a system that was built for one market and taught to answer in other languages.

Verification does not travel with translation

Here is the part that is easy to miss even when you know to look for it. The actual mechanics of how a legal claim gets subtly wrong, a negation flipped, a quantifier quietly weakened from all to some, an exception dropped, a magnitude altered, a sum written out in words that no longer matches the digits beside it, are language-specific patterns, not universal ones. The grammar of negation in Korean does not work like the grammar of negation in Spanish. The way an exception clause gets phrased in a French statute does not look like the way it gets phrased in an Indonesian one. A verification system that was tuned and adversarially tested against English or Spanish failure patterns has exactly zero guarantee that it catches the equivalent failure the day it starts processing Portuguese or Italian, because it was never actually tested against what those failures look like in that language. It was tested against what they look like in the language it was built in, then pointed at a new one and trusted to generalize.

The dangerous part is what this looks like from the outside when it goes wrong. It does not throw an error. It reports a clean result. A jurisdiction wired up without its own tested set of adversarial cases for that specific language will show the same reassuring "nothing wrong found" as a jurisdiction that has actually been through the wringer, because nobody has run the test that would surface the difference. A green checkmark on a test that was never actually written is not success. It is an untested claim dressed as one, and it is the single easiest way to ship a verification system that quietly does nothing in exactly the markets furthest from where it was built.

The only fix we have found is mechanical rather than aspirational: a jurisdiction and its language do not go live until there is a real, adversarially tested set of failure cases specific to that language sitting in the pipeline and passing against it, checked automatically, not signed off informally. Coverage becomes something you have to earn and can point to, not something you assume because the feature list says the language is supported.

Hallucination does not even mean the same thing everywhere

This is the part that changes the shape of the actual verification logic, not just its coverage. In a common law system, the paradigm failure is a fabricated or misattributed case, a citation to a precedent that was never decided or that does not say what it is claimed to say. That is the failure mode almost everyone building legal AI verification implicitly designs against, because almost everyone building it is starting from a common law or Anglo-American frame of reference.

In a codified, civil law system, that is not the dominant failure mode at all. The paradigm failure there is a real article, quoted correctly, word for word, that has since been repealed, superseded, or amended, and is still being cited as if it states the current law. The citation is not fabricated. It existed. It may even still be sitting in the corpus, unmodified, exactly where it always was. The problem is that the law moved and the citation didn't. Existence was never the question. Currency was.

Treating that as a special case bolted onto an existence check is how you miss it structurally, not occasionally. The fix is to make legal hierarchy and time first-class data rather than an afterthought: every provision carries its rank in the normative hierarchy and the window of dates during which it was actually in force, and a verification check resolves both, not just whether the text is real. Critically, this has to live as data the system loads per jurisdiction, not as code written per jurisdiction, or every new legal system you support becomes a new codebase to maintain forever rather than a new dataset to load once. The mechanism stays the same. What changes is which hierarchy and which effective dates you hand it.

The corpus is not one thing. It is dozens of separate fights.

It is tempting to talk about "the corpus" as a single asset that scales cleanly. It doesn't. Each jurisdiction is its own project with its own access constraints, its own state of digitization, its own reliability profile. Getting reliable, current case law out of one country's court system looks nothing like doing it in another: different formats, different publication practices, different gaps in what is even available in machine-readable form at all. Some jurisdictions hand you clean, complete, well-dated primary sources. Others hand you fragments, and the honest answer for those is a declared gap, not a confident number that quietly assumes completeness it doesn't have.

That discipline, treating coverage completeness as something to measure and disclose per jurisdiction rather than something to imply is uniform, is the same instinct as declaring an unverifiable claim instead of guessing at it, just applied a level up, at the level of which parts of the map are actually filled in.

What genuine multi-jurisdictional depth makes possible: comparing, not just coping

There is a payoff to all of this that goes beyond not failing silently in market number forty. Once every jurisdiction is actually verified to the same standard, its own tested lexicon, its own hierarchy and validity data, its own honestly declared coverage, something becomes possible that a translation-based system can only fake: putting several jurisdictions side by side against the same document or the same situation and comparing, with the same rigor in each direction, how they actually treat it.

We run this as a distinct capability: hand the system a contract or a described situation, name anywhere from two to fifteen jurisdictions, and a branch of law to scope the comparison, civil, commercial, labor, criminal, tax, administrative, constitutional, procedural, and it returns how each of those jurisdictions actually treats that document or situation under its own law, side by side. This is private international law territory in the traditional sense, questions of governing law, of which forum's rules actually apply, of how a treaty interacts with each signatory's domestic law, made tractable at the level of a specific contract rather than left as a general doctrinal question.

The reason this only works if everything described above is real: a comparison across jurisdictions is only as trustworthy as the weakest jurisdiction verification going into it. A system that treats verification as translation can still produce an answer that looks like a comparison, a paragraph about jurisdiction A next to a paragraph about jurisdiction B, but it is comparing one properly grounded answer against one that was never actually checked to the same standard, and there is no way to tell which side of that asymmetry you are looking at from the output alone. Comparing several jurisdictions honestly requires having done the unglamorous, jurisdiction-by-jurisdiction work described above for all of them, not just one with the rest translated alongside it.

Concretely, this is what a cross-border contract, a treaty question, or a multi-jurisdiction compliance check actually needs: not a generic answer about "international law" in the abstract, but a specific document held up against the actual current, hierarchy-aware, verified law of each named jurisdiction at once, scoped to the branch of law that actually governs the situation, with the same standard of rigor applied in every direction.

What this actually buys, in practice

If you operate in, or need law from, a jurisdiction that is not wherever your AI vendor happens to be headquartered, you are structurally the person most likely to be quietly failed by a system that was only ever really tested at home. Not because anyone decided you mattered less. Because internationalization-as-translation makes that outcome the default unless something specifically prevents it, and most systems have nothing that does.

The point of building it the harder way, peer treatment enforced in the architecture rather than assumed, adversarial coverage earned per language rather than inherited from whichever one came first, hierarchy and time treated as data that travels rather than logic that has to be rewritten, honest gaps instead of implied completeness, is that the client in the jurisdiction furthest from wherever the system was built gets the same rigor as the one in its home market, not a quieter, less-tested version of the same product wearing a different flag.

It is not a demo-able feature. Nobody sees sixty jurisdictions treated as peers in a screenshot. But it is the actual moat, more than the verification mechanism itself, because the mechanism is now something several people independently agree is the right idea. Having actually done the unglamorous work of earning it, market by market, honestly, is not.