Two years after the alarming six weeks she spent switching nothing, the Head of Localization walked a newly hired VP of Product through what her function had become, and the VP kept waiting for the part where it got complicated. There was no complicated part. A source file entered the operation and, within an hour, an intake step read its metadata and classified it into a risk tier: a support article was tier three, a marketing landing page tier two, a product-documentation module tier one, a medical-device instructions-for-use file tier zero and flagged for full human translation before a single engine ever saw it. The machine drafted every segment it was allowed to touch, grounded on the enterprise's own translation memory and its approved termbase, not on whatever the model had swallowed from the open web. A qualified post-editor worked the draft against the source and the terms, never trusting the smooth surface. An independent evaluator scored the file against a Critical, Major, Minor typology, and one Critical error would have blocked the delivery no matter how clean the average looked. A quality record captured every segment's machine source, human edit, term decision, and error score, so that a client or an auditor could reconstruct exactly how the file was made. Above all of it sat a governance group, a dual-axis dashboard that never showed a cost number without its paired critical-error rate, and an org chart where humans owned quality and engines owned first drafts. The VP said it sounded expensive. The Head of Localization said it was the cheapest thing she had ever built, because the operation shipped more languages faster than it ever had and had not shipped a single regulated-content incident in two years. This lesson is the portrait of that operation: the end state the whole program builds toward, where speed and provable quality run as one system, and every piece you have learned separately is finally shown working together.

What AI-Native and Human-Quality-Owned Actually Mean

The phrase at the center of this lesson is doing a great deal of work, and it is worth taking apart slowly before we assemble the operation it names, because the two halves are usually held to be in tension and the entire point is that they are not. AI-native does not mean "an operation that uses AI," the way a phrase like "cloud-native" got diluted into "we have some servers we rent." An operation is AI-native when the machine draft is the default first pass on every eligible segment, assumed rather than requested, so that the pipeline, the roles, the metrics, and the economics are all designed around the machine having already produced a rendering before a human opens the file. The alternative, an operation where a human translates from scratch and AI is an occasional accelerant, is not AI-native, it is AI-assisted, and it is the world most of this program's earlier levels prepared you to work inside. AI-native is the steady state where machine-first is the substrate, not the exception.

Human-quality-owned is the other half, and it is the discipline that keeps AI-native from becoming a euphemism for surrendered judgment. It means that accountability for whether the output is correct, safe, on-brand, and terminology-conformant sits with a named human, and that "the engine wrote it" is never an answer when a Critical error ships. The machine may draft, but a human owns the quality, which is a specific and load-bearing claim: ownership is not review, it is not a courtesy glance, it is the professional and often legal responsibility for the delivered file resting on a qualified post-editor and an independent evaluator whose name is on the record. Before we go further, let us fix the working vocabulary the rest of this lesson leans on, because the operating model touches every role and the terms must be shared. MT is machine translation; NMT is neural machine translation, the classic sentence-to-sentence engine; LLM is a large language model, more fluent and more confidently wrong than NMT. PE is post-editing and MTPE is machine-translation post-editing, the workflow where the machine drafts and a human revises. QE is automatic quality estimation, a machine's own confidence signal, not a verdict. MQM is the Multidimensional Quality Metrics error typology, and ISO 5060:2024 is the standard that formalizes the MQM-aligned analytic scoring of translation output by dimension and by severity (Critical, Major, Minor). ISO 18587 is the post-editing standard, whose revision (in Draft International Standard ballot, publication targeted for late 2025 into 2026) expands scope to AI and LLM "non-human translation output," retires the rigid light-versus-full split for an effort spectrum, and requires the post-editor to hold the full linguistic competence of a professional translator. ISO 17100 is the baseline standard for professional human translation services. TM is translation memory, TMS is the translation-management system, CAT is the computer-assisted translation tool, a segment is the sentence-sized unit the CAT tool works in, locale is the language-plus-region target such as de-DE, i18n is internationalization and l10n is localization, and LSP is a language-service provider. The operating model is the steady-state design of the whole function: the roles, the processes, the governance, and the metrics by which the operation runs every ordinary day, not a project with an end date but the permanent shape of the work.

Held together, then, the AI-native, human-quality-owned operation is the one where the machine drafts everything it is allowed to draft, and a human owns the quality of everything that ships, and neither half is negotiable. Drop the first half and you have an operation that has refused the speed the market now assumes, pricing itself out of the business. Drop the second half and you have the speed-only operation that ships the silent critical error at scale and gets frozen by a regulator. The whole program has been teaching you to hold both at once, and this lesson is where you see what it looks like when you do.

AI-native means the machine draft is the assumed first pass on every eligible segment. Human-quality-owned means a named human is accountable for whether the output is correct. The operation is the one that holds both at once, and neither half is optional.

The Operation as One System, Not a Toolbox

The single most common way of understanding an AI-native operation is also the most misleading: as a toolbox, a collection of good practices you can adopt in any order and mix and match to taste. Risk tiering here, a grounded engine there, a severity gate if you have time, a quality record when a client asks. Understood that way, each piece looks optional, and an operation under cost pressure will quietly drop the pieces that cost effort and keep the ones that produce a dashboard, which is exactly how the speed-only collapse begins. The correct understanding is that the pieces are not a toolbox, they are a system, and a system has the property that its components depend on one another so that removing one does not subtract a feature, it breaks a chain. The whole point of showing the fully realized operation is to make that dependency visible, so that no one on the team can treat any single control as the negotiable one.

Trace the chain and the dependency is obvious. Risk-tiered intake decides what the engine may touch, which is only meaningful if there is a grounded engine to draft the eligible content and a human-only lane for the content that is forbidden. The grounded engine produces a draft against the TM and the termbase, which is only worth grounding because a post-editor is going to work it against the source and the terms, and the grounding raises the floor so the post-editor's effort lands on real errors rather than on cleaning up avoidable drift. The post-editor's work is only defensible because an independent evaluator scores it against the severity typology, and the severity gate is only a real gate because a single Critical error blocks the delivery. Terminology enforcement runs through all of it, at intake as a constraint on the engine, during post-editing as a check, at the gate as a scored dimension. The quality record captures the whole chain so that the governance group can see it, the metrics can measure it, and an auditor can reconstruct it. Pull out the gate and the post-editor's judgment becomes unprovable. Pull out the grounding and the post-editor drowns in avoidable term drift. Pull out the risk tiering and the cheap workflow lands on a drug label. Pull out the quality record and none of the rest can be proven to anyone outside the room. Each piece exists because the others do, and the operation is the shape they make together.

The Through-Line That Holds It Together

There is a single idea threaded through every component, and naming it makes the system legible. The idea is that accuracy is a relationship to the source and the approved terminology, not a property of the prose. Every control in the operation is a defense against the one failure mode that this program has returned to at every level: the fluent, grammatical, confident machine rendering that reads perfectly and means the opposite of the source, the silent critical error that does not trip your eye precisely because it is fluent. Risk tiering exists because that failure is catastrophic in some content and merely annoying in others, so effort must be matched to consequence. Grounding exists because the failure is likelier when the engine invents from its own training rather than answering from your approved language. The post-editor exists because a human comparing the draft to the source is the instrument that catches the failure. The severity gate exists because the failure has to be scored and blocked, not vibed. The quality record exists because the failure, and the fact that you caught it, has to be provable. Once you see that every component is a different defense against the same silent error, the operation stops looking like a toolbox and starts looking like what it is: a single system built around a single, well-understood danger.

The pieces are not a toolbox to mix and match. They are a system whose components depend on one another, all defending against the same failure: the fluent mistranslation that reads perfectly and means the opposite. Remove one and you do not lose a feature, you break a chain.

The Seven Components Working Together

Now we assemble the operation from the parts the program built, and the discipline of this section is to show each part not in isolation, which is how you learned it, but in its place in the running system, connected to the parts before and after it. Seven components make the whole: risk-tiered intake, grounded MT, the severity-scored gate, terminology enforcement, the quality record, governance, and metrics. An eighth thing, the org, is what staffs and sustains all seven, and it gets its own section because it is the difference between a workflow and an operation.

Risk-Tiered Intake, the First Control

Everything begins at intake, before a single engine touches a file, because the first and most consequential decision in the whole operation is what the machine is allowed to draft at all. Content enters and is classified by consequence, not by volume: a marketing string, a UI label, a support article, a piece of product documentation, a financial disclosure, a drug label, an indemnity clause. The classification assigns a risk tier, and the tier determines the workflow. Low-consequence, high-volume content gets a machine draft and light post-editing. Medium-consequence content gets a machine draft and full post-editing. High-consequence regulated content (medical, legal, financial, life-safety) gets full human translation or full post-editing, and some of it is flagged MT-forbidden and never enters the machine flow at all. This is the first control because it is the one that prevents the catastrophic mismatch of a cheap workflow landing on content that can kill or sue, and in the running system it is the valve that routes every downstream effort. Get the tier wrong and every later control is applied at the wrong intensity to the wrong content. The revised ISO 18587's effort spectrum is the spirit of this control: match the post-editing effort to the consequence, by rule, at the front door.

Grounded MT, Drafting From Your Own Language

For every segment the intake tier permits, the machine drafts, and in the realized operation it does not draft naked. It drafts grounded: retrieval over the enterprise's own translation memory, its approved termbase, and its style guide, so the engine answers from your accumulated, approved language rather than from the open-web averages baked into its training. Grounding does not make the engine trustworthy, nothing does, but it raises the floor. A grounded engine drifts off the approved term less often, matches your established renderings more often, and therefore hands the post-editor a draft whose errors are more likely to be real ambiguities than avoidable term drift the operation had already solved years ago. In the system, grounding is the component that makes the post-editor's effort economical: without it, the human spends their scarce attention re-fixing the same drift on every file, and the MTPE economics that justify the whole operation quietly evaporate. Grounding is also where linguistic-asset governance pays off, because grounding a fluent engine on a poisoned TM industrializes the poison, which is why the clean-TM discipline you learned at L2 and L3 is a load-bearing input here, not housekeeping.

The Post-Editor and the Severity-Scored Gate

The grounded draft reaches a qualified post-editor, and here the operation makes its most important human demand. The post-editor holds full professional-translator competence, the bar the revised ISO 18587 insists on, and they work the draft against the source segment and the termbase, never trusting the smooth surface, hunting specifically for the fluent error the machine produces with total confidence: the flipped dosage, the dropped negation, the inverted obligation, the swapped approved term, the invented number. Then, separately and independently, an evaluator scores the file against the MQM/ISO 5060 typology across accuracy, terminology, locale, and fluency, at Critical, Major, and Minor severities. The independence matters: the evaluator is structurally separate from the post-editor for the same file, because a person cannot reliably audit their own work. And the gate has one absolute rule that makes it a gate rather than a suggestion: a single Critical error fails the file, regardless of how clean the rest looks. One flipped dosage does not average out against a thousand perfect segments. In the system, the gate is the throttle and the proof at once: it is what blocks the silent critical error from shipping, and it is the artifact that authorizes the file's delivery, so the currency of the operation is a quality record with zero Criticals, never a throughput number.

Terminology Enforcement, Running Through Everything

Terminology is not a single step, it is a discipline that runs through the whole chain, which is why it is easy to underrate and expensive to neglect. At intake, the approved termbase is attached to the job as a constraint the engine is grounded on. During drafting, the grounded engine is pushed toward the approved terms rather than the common synonyms it prefers. During post-editing, the human checks that the approved term held. At the gate, terminology is a scored dimension, and a term error can be a Critical when the term is safety-relevant, such as a device name or a dosage unit. Across the operation, terminology conformance is a reported metric, because an engine that drifts off approved terms at pilot scale drifts catastrophically at enterprise scale, and the drift is invisible on a throughput dashboard. In the running system, terminology enforcement is the connective tissue: it is present at every component, and its conformance number is one of the two or three signals that tell the governance group whether the operation is actually holding or merely looking busy.

The Quality Record, Making It All Provable

Everything the operation does leaves a trace, and the trace is deliberate, not incidental. For each file, the quality record captures the machine source of each segment, the human edit, the term decisions, the evaluator's severity-scored error report, and the go/no-go verdict, so that a client, a certifier, or the operation's own governance can reconstruct exactly how the file was made and prove it was made conformantly. The quality record is what turns "trust me, it's fine" into "here is the throughput, here is the risk tier each content type got, here is the ISO 5060 error score with zero Criticals, here is the terminology conformance, and here is the post-editing record, all defensible under the revised ISO 18587." That sentence is the operation's credential, and the quality record is the only thing that makes it sayable. In the system, the record is the memory: it feeds the metrics, it satisfies the audit, it enables the incident response when something does slip, and it is the evidence that authorizes every stage crossing and every client claim. An operation without a quality record is running on the hero's word, which evaporates the day the hero leaves.

Governance and Metrics, the Permanent Instruments

The last two components are what make the operation permanent rather than a heroic push that decays when attention wanders. Governance is the standing structure that owns the program: a group with quality, terminology, engineering, and PM at the table, a standing quality gate, a calibration cadence that keeps evaluators from drifting apart so that the gate keeps meaning the same thing, an internal audit that behaves like an external one, and an incident-response protocol for the day a Critical does slip through. Metrics are the dual-axis instrument that keeps the operation honest: throughput and cost on one axis, quality-risk (critical-error rate, terminology conformance, MQM/5060 score) on the other, reported together always, because reporting speed without its paired quality-risk number is precisely how an operation lies to itself and its board. In the running system, governance and metrics are the components that watch the other five, and their job is to keep the volume from ever getting ahead of the proof. An operation with all five production components and neither of these two instruments is a workflow that will drift back toward speed-only by entropy, because the discipline was living in vigilance rather than in structure.

The Organization That Staffs the System

A system on paper is not an operation, and the difference is the org. The seven components are staffed by named humans in standing roles, and the AI-native org chart is not the pre-AI one with fewer people, it is a differently shaped structure where the humans have moved up the value chain from words-per-hour production to quality ownership, terminology stewardship, evaluation, and risk judgment. This is the redesign the whole program has been arguing for: the engine takes the first draft, and the human takes the thing the engine cannot do.

The realized operation has a recognizable cast. A Head of Localization AI or equivalent owns the program end to end, holds the sequencing rule against impatient executives, and answers to leadership for both axes of the dashboard. A Quality Lead owns the gate, the severity typology, the calibration cadence, and the evaluator pool, and is the person who can say "not authorized yet" when the gate has not proven it holds at the next tier. A Terminology Lead owns the termbases across content types and languages, because terminology conformance is a program, not a spreadsheet, and its decay is silent. Qualified post-editors, held to full professional-translator competence under the revised ISO 18587, own the accuracy of the files they work. Independent evaluators, structurally separated from the post-editors for the same file, own the score. Localization engineers own the plumbing, the placeholders, the length budgets, the grounding integration, and the CI/CD for l10n that keeps quality intact at build time. And project managers own the routing, the risk-tier assignment at intake, and the client-facing quality story. The shape of the org is the answer to a question the operation must be able to answer: who owns the quality of this file, by name, and the answer is never "the engine."

The AI-native org is not the old org with fewer people. It is the old org moved up the value chain: engines take the first draft, humans take quality ownership, terminology stewardship, evaluation, and the risk judgment the machine cannot do. Every file has a human owner by name.

Why the Org Is the Hardest Part

The technical components are the easy half, and the org is the hard half, for a reason worth stating plainly. The humans who catch the silent critical error are the linguists, and a transformation that frightens or deskills them removes the exact judgment the whole quality-first system depends on. A vendor pool that has heard "the machine will replace you" one too many times is not being irrational, it is responding to a real economic shift, and an operation that treats the redesign as a cost-cutting exercise loses the pool and, with it, the human gate that was the entire safeguard. The honest contract, the one that both retains people and satisfies the standards, is the spine of this program: the AI drafts, the human owns the quality. The revised ISO 18587 makes that contract real rather than rhetorical by insisting the post-editor hold full professional-translator competence, which means the operation is not deskilling the role, it is moving it up. The operations that build a durable AI-native function are the ones that communicate the redesign as "we are making you the owner of the thing the machine cannot do," back it with real re-qualification and career paths that reward quality ownership, and thereby keep the human judgment their entire system is built on. The operations that communicate it as "we are cutting your rate because the machine does most of it now" lose the pool and become, over time, the speed-only operation wearing the vocabulary of quality.

Why This Is a Durable Competitive Position

It is tempting to see the fully realized operation as merely prudent, a way to avoid disaster, and to assume the real competitive advantage lives in raw speed. That gets the economics exactly backwards, and understanding why is what separates a leader who builds this operation from one who tolerates it as an insurance cost. The AI-native, human-quality-owned operation is not a defensive crouch, it is a durable competitive position, and it is durable precisely because the thing it sells is the thing a raw-machine competitor structurally cannot sell.

Consider what happens to raw speed as a competitive advantage. The machine draft is a commodity: the same engines are available to every operation, the per-word cost of a raw machine translation is collapsing toward zero, and an advantage that anyone can buy from the same vendor is not an advantage, it is table stakes. An operation that competes only on speed is competing on price against every other operation with the same engine, and that race has one destination. What is not a commodity, what cannot be bought from the vendor, is the proven quality: the severity-scored evaluation with zero Criticals, the terminology conformance, the risk-tiered routing, the quality record defensible under the revised ISO 18587 and ISO 5060, and the qualified human accountability standing behind all of it. That is a capability an operation builds over years, staffs with scarce judgment, and proves with an accumulated record, and it is exactly what a regulated client, a legal team, or a certifying auditor is willing to pay a defensible premium for, because the alternative is the frozen program and the counted exposure.

The Position Compounds

The durability is not static, it compounds, which is what makes it a genuine moat rather than a temporary edge. Every file the operation ships adds to a clean TM and a maintained termbase, which grounds the engine better, which lifts the draft floor, which makes the post-editor more economical, which improves the margins on the very quality the operation sells. Every evaluation feeds the metrics that prove the operation's quality to the next client, and every calibrated evaluator makes the gate more trustworthy. The quality record accumulates into a body of evidence that no new entrant can conjure, because it is the residue of years of disciplined work. Meanwhile the speed-only competitor's advantage decays: their engine is the same commodity, their price race has no floor, and their first shipped silent critical error into a regulated market resets their reputation to zero. The AI-native, human-quality-owned operation therefore sits in the rare position where the prudent move and the competitive move are the same move, where the discipline that keeps you safe is also the capability that lets you charge a premium and keep the accounts that matter. In localization the speed move and the quality move are the same move only when they are sequenced correctly, and the operation that sequences them right does not choose between safety and advantage, it collects both.

Raw speed is a commodity every operation can buy from the same vendor. Proven quality, risk-tiered, severity-scored, terminology-conformant, and defensible under the standards, is a capability built over years and staffed with scarce judgment. The moat is the quality, and it compounds.

A Worked Portrait of the Fully Realized Operation

Return to the Head of Localization from the opening, two years into the steady state, and follow four real files through her operation in a single ordinary week, because the portrait of the system running is more instructive than any diagram. Watch how the seven components and the org handle four content types of wildly different consequence, and watch the through-line, the defense against the silent critical error, appear in every one.

The Support Article, Machine-First and Light

A batch of two hundred support articles enters on Monday for all forty-one locales. Intake classifies them tier three, low consequence and high volume, the content the operation was built to move fast. The grounded engine drafts every segment, matching the deep support-content TM in the top-eight languages and leaning harder on the thinner assets in the long-tail thirty-three. Light post-editing clears the drafts; the post-editors fix meaning-changing errors and leave the preferential rewrites alone, because over-editing tier-three content burns the MTPE economics that justify the whole tier. The evaluator scores a sampled subset against the typology, terminology conformance comes back above the floor, zero Criticals, and the batch ships by Wednesday at a cost per word close to the CFO's original number. This is the speed the operation exists to capture, and it captures it without ceremony, because the system is designed for exactly this to be routine.

The Marketing Launch, Where Transcreation Enters

A product-launch landing page enters Tuesday for the top eight markets. Intake classifies it tier two, medium consequence, and routes it to full post-editing, but the PM flags three segments as transcreation: a tagline and two pieces of brand copy where a literal-but-fluent rendering would kill the campaign. Those three segments bypass the machine-first flow entirely and go to a human transcreator, because the operation knows the boundary of what the engine can do and does not pretend the machine can carry brand intent across a culture. The rest of the page gets grounded MT and full post-editing, the evaluator scores it, a Minor locale-convention error on a date format is caught and fixed, and the page ships. The file shows the operation's judgment about where the machine helps and where it must not, encoded as routing rather than left to a linguist's discretion under deadline.

The Product Documentation, Full Post-Editing and a Caught Critical

A product-documentation module enters Wednesday, tier one, medium-high consequence, into full post-editing across the top-eight strong-asset languages. The grounded engine drafts it, and on one segment it produces a fluent, grammatical rendering that inverts a safety instruction: the source says the device must not be operated during a certain condition, and the machine's German draft, perfectly natural, drops the negation and says it may be. This is the silent critical error the entire operation exists to catch, and the system catches it exactly where it is designed to. The post-editor, working the draft against the source rather than trusting the surface, sees the flipped meaning. The evaluator scores it a Critical. The gate does its one absolute job: the file does not ship until the segment is corrected and rescored. Nothing about this is heroic or lucky; it is the routine functioning of a system built around the assumption that the machine will, confidently and fluently, occasionally invert a safety-critical instruction. The quality record captures the catch, and the metrics register a Critical caught at the gate rather than a Critical shipped to a customer, which is the difference the whole operation is for.

The Regulated Content, Human-Only by Rule

A medical-device instructions-for-use file enters Thursday, tier zero, highest consequence, and the machine never touches it. Intake flags it human-only before a single segment is drafted, and it goes to full human translation by qualified medical linguists, with an independent revision and a severity-scored evaluation on top. There is no MTPE economics argument here, because the operation has decided, by rule and not by guess, that this content's consequence forbids the machine-first workflow no matter how much volume it represents or how much the cost line would love the saving. The file ships slower and costs more than a tier-three batch, and that is the correct outcome, because matching effort to consequence is the first control and the one that keeps the operation out of the frozen-competitor story. The dashboard the Head of Localization shows her board on Friday reports the week's throughput and cost beside the week's critical-error rate (one caught at the gate, zero shipped) and the terminology conformance, always paired, and the board sees an operation that shipped more languages faster than ever and did not ship a single regulated-content incident, for the eighth consecutive quarter.

Four files, four consequences, one system. The support article moves fast, the marketing page routes transcreation to a human, the documentation's flipped negation is caught at the gate, and the regulated file never meets the machine. The through-line is the same in all four: every control is a defense against the silent critical error, and the human owns the quality by name.

Key Takeaways

• AI-native and human-quality-owned are two halves of one operation, and neither is optional. AI-native means the machine draft is the assumed first pass on every eligible segment; human-quality-owned means a named human is accountable for whether the output is correct, safe, and terminology-conformant. Drop the first and you price yourself out of the market; drop the second and you ship the silent critical error at scale.
• The components are a system, not a toolbox. Risk-tiered intake, grounded MT, the severity-scored gate, terminology enforcement, the quality record, governance, and metrics depend on one another so that removing one does not subtract a feature, it breaks a chain. An operation under cost pressure that drops the effortful pieces and keeps the dashboard has begun the speed-only collapse.
• Every component is a different defense against the same failure. The through-line is that accuracy is a relationship to the source and the approved terminology, not a property of the prose, and the danger is the fluent, confident mistranslation that reads perfectly and means the opposite. Once you see that, the operation stops looking like a collection of practices and starts looking like a single system built around a single, well-understood risk.
• Intake is the first control because it routes every downstream effort. Content is tiered by consequence, not volume: low-stakes gets light post-editing, medium gets full, high-liability regulated content gets full human or is flagged MT-forbidden and never enters the machine flow. Get the tier wrong and every later control is applied at the wrong intensity to the wrong content.
• The gate is the throttle and the proof at once. An independent evaluator scores the post-edited file against the MQM/ISO 5060 typology across accuracy, terminology, locale, and fluency, and a single Critical error fails the file regardless of how clean the average looks. The currency that authorizes delivery and every stage crossing is a quality record with zero Criticals, never a throughput number.
• The org is the hard half and the human gate the whole system depends on. The AI-native org moves the humans up the value chain to quality ownership, terminology stewardship, evaluation, and risk judgment; every file has a human owner by name. The honest contract, the AI drafts and the human owns the quality, backed by real re-qualification under the revised ISO 18587, is what keeps the linguist judgment the safeguard rests on.
• This is a durable competitive position, not an insurance cost. Raw speed is a commodity every operation buys from the same vendor and races to the bottom on; proven quality, risk-tiered, severity-scored, terminology-conformant, and defensible under the standards, is a capability built over years that a raw-machine competitor structurally cannot sell. The moat is the quality, and it compounds as clean TM, maintained termbases, and an accumulated quality record raise the floor and prove the operation to the next client.
• The prudent move and the competitive move are the same move when sequenced right. The operation that holds both halves does not choose between safety and advantage, it collects both: it ships more languages faster than it ever could, and it ships zero regulated-content incidents, because at every boundary the volume was authorized by a quality record rather than a throughput number.