Skip to content
transglot.engineStart free
the glossa engineautomatic translation, two passes

It translates every string you ship. Fast by default, careful where you say so.

deep

the careful pass

Turn it on for a project and every language in it takes the careful pass. Where a reviewer has captured the screen for a key, that goes into the prompt too. Quality Mode, from the Team plan.

glossa deep

flux

the fast pass

Drafts every changed string into every language on the project, without anyone filing a ticket. On every plan, Free included.

glossa flux
the clock

The engine runs on your commits. The old way runs on a calendar.

Illustrative, not a stopwatch. Nothing on this axis is measured. What the band compares is a pass that starts on your commit against a round trip that waits for people to be free.
read
draft
repair
re-gate
ship
a human-only round trip
your assumption, not a measurement of ours
1.0 s
The axis is logarithmic: every gridline is about ten times the last.
Flux runs on the commit. Deep runs on the projects you put in Quality Mode. Nothing on this axis is measured.
the router

You set Quality Mode. The engine picks the pass.

A project on Quality Mode goes to Deep. Every other project goes to Flux. Both clear the same four gates before anything ships. Flux is on every plan, Deep from the Team plan.
pushthe router reads the projectflux: the default for every stringdeep: projects on Quality Modefour gates0 flagged to deep
0rows shipped this run
every push takes this shape
every plan

flux

The default pass. It drafts every new and changed string as soon as it lands, before anyone asks for it.

trigger
Every new and changed string, automatically.
how many at once
Every language on the project, in one run.
what it reads first
Source strings, glossary terms, plural rules.
gates
Placeholders, plurals, glossary, length.
on a fail
One automatic corrective retry, then refused.
availability
Every plan, Free included.
what it counts
Words count against the plan allowance.
past the allowance
$0.0008 a word on paid plans.
team plan and up

deep

The careful pass. It reads your style guide, and any screen captured for the key, before it drafts.

trigger
Projects you put in Quality Mode.
how many at once
The same, on the careful model.
what it reads first
All of that, plus your style guide and any captured screen.
gates
The same four, with no exceptions.
on a fail
Refused rows reach a reviewer with the gate that failed.
availability
Quality Mode, from the Team plan.
what it counts
Reading the screen meters words as well.
past the allowance
$0.0008 a word on paid plans.
the engine console

Two passes, four gates, and the cheapest lane that still works.

Live: pick a source string or type one of your own, choose a lane, and run it. Nothing on this plate leaves the page.
glossa · engine consoleacme / checkout / checkout.cta
source
Glossa Flux · fast, drafts every push16 / 24 chars
Glossa Flux
nothing run yet_
pick a source and a lane, then run. Four locales stream here, gate by gate
this run
words drafted0
memory hits0 · 0 tokens spent
human edits untouched0
refused0
time0.0 s
auto-approve at0.90 and above
Flux drafts on every push and lets the gates and the confidence figure decide what a person has to look at. Most rows clear; the rest wait in review.
the engine never overwrites a human edit: a locale someone touched is kept as it is, not redrafted, and the meter counts it
A simulation, in your browser. Nothing is sent anywhere: the drafts, the confidence figures, the memory hit and the timings are a fixture and illustrative. The two lanes, the four gates, the one repair pass and the human-edit rule are the shipped mechanism.
the pipeline

Every string takes the same path.

git pushthe live editoran agent over MCPa file upload
new and changed strings, keyed for you
key
flux writes every language in one run
draft
placeholders, plurals, glossary, length
gates
repair, then back to the gates
bundle, pull request, or held for review
publish
pull requestCDN bundleheld for review
A row that fails a gate is repaired once, then all four gates run again. Fail twice and the row is refused and held for review with the gate that failed. It is never shipped broken.
the gates

Four gates. Every row, every commit.

Placeholders, plurals, glossary, length. Whichever pass drafted a row, it clears all four or it does not ship. Source: the deterministic pre-gate in QaRunner, and the same checks again on the drafting path.

Placeholders

Every variable survives the trip: never dropped, never renamed, never reordered into a different meaning.

en Hi, {name}!

ja {name}さん、こんにちは

Plurals

Every form a language actually needs. The rule sets come from CLDR, which covers 224 languages.

en one, other

ru one, few, many

Glossary

Your own terms hold in every language. A locked term is enforced at the gate, not suggested in a style note.

term "Acme Pay", do not translate

held in every locale on the run

Length

German is long and buttons are small. Every row is measured against the character limit you set on the key.

de In den Warenkorb

within the character limit on the key

  • gate placeholder {code} missing from a draft row
  • repair reinserting {code}, re-shaping the right to left run
  • re-gate all four checks re-run on the repaired row
  • refuse a second failure is held for review, with the gate that failed
the careful pass

Quality Mode takes the careful pass on every language in the project.

Switch it on for the project where the wording matters: your marketing site, your pricing, your onboarding. Everything else stays on flux and ships on the push.

you pick the project
Quality Mode is one switch on the project. Turn it on and every target language in that project takes the careful pass.
it reads the screen you captured
Where a reviewer has captured the screen for a key, that screenshot goes into the prompt, so tone, fit and glossary are checked against what a reader sees.
a refusal comes with evidence
A refused row is held for review with the gate that failed, so the fix takes one look.
How quality is checked
Quality Mode is on the Team plan and up. Screen reading needs the project toggle on and a screen captured for the key, and it meters words like any other work.
A flagged row under review: the target open in its field, outlined, with the row state beside it.
deep: within the character limit, glossary held
the frontier

Against a general model, and against machine translation.

Three questions decide whether you can leave a translation pipeline running unattended. The bars below are illustrative: they show the shape of the argument, not a benchmark anyone ran.

First-pass quality

how much of a draft survives review
GlossaGeneral-purpose AIOff-the-shelf MT

Placeholder and plural accuracy

what the four gates measure on every row
GlossaGeneral-purpose AIOff-the-shelf MT

Reviewer time saved

work that never reaches a person
GlossaGeneral-purpose AIOff-the-shelf MT
Illustrative, and deliberately unnumbered. Transglot publishes no model benchmark and cites no eval corpus, so these bars show the shape of the argument rather than a measured result. What is measured is the gate: four deterministic checks on every row, every commit.
the honest version
What we will defend is not a quality score. It is that a row failing placeholders, plurals, glossary or length is repaired once, and refused if it fails again.
the old way

Against an agency round trip.

Five questions, three answers. The difference is whether translation is a project you run or a step in your build.

flux
the fast pass, always on
Trigger
Every push, automatically.
How many at once
Every language on the project in one run.
Review
Four gates on every row, before merge.
On a fail
One corrective retry, then refused.
Cost
Included on every plan. Past the allowance, $0.0008 a word on paid plans; Free is hard capped instead.
The ROI model uses $0.16 a word as a round industry figure for all-human translation, not a quote from any competitor, and you can move it.

FAQs

What people ask about the engine before they switch it on.

What is Glossa?
Glossa is the name of our translation engine: the prompt, the routing between two passes, the glossary and memory it reads first, and the four gates every row has to clear. Flux is the fast pass and runs on every plan. Deep is the careful pass and runs on the projects you put in Quality Mode, from the Team plan.
We do not publish a model name and we do not train one of our own. Glossa is our pipeline around inference we buy, and every inference provider we call is listed as a subprocessor on our trust page. None of them trains on your content.
It is automatic. There is no send to translation step. The engine reads the new and changed strings, keys them, and drafts every language on the project. Flux is the default path for every key, on every plan including Free.
Switch it on for the project where the wording matters: your marketing site, your pricing, your onboarding. It is one switch, and every target language in that project takes the careful pass, so your other projects keep shipping on the fast pass. Quality Mode is on the Team plan and up.
The engine repairs the row and runs all four gates again. That is one automatic corrective retry, not an unlimited loop. A row that fails a second time is refused and held for review with the gate that failed, rather than shipped broken.
There is no fixed list. Any BCP-47 tag ICU recognises is accepted, which is 708 locales today, and 224 of those languages carry their own CLDR plural rule set that the plural gate enforces.
No. A row a person edited or reviewed is left alone: the engine will not redraft it, and it is not sent to a provider or billed again. One shared guard enforces that, so it holds for a run, for the API and for the memory alike.
Yes. Glossary terms go into the prompt before a draft is written and are checked again after it, so a locked term is enforced rather than suggested. You can mark a term do not translate, forbid a target word, and set one preferred word per language. A per-language style guide goes into the same prompt.
Yes. Approved translations are kept and searched before anything is generated. An exact match is served from memory, which skips the AI call entirely and costs nothing. Memory can be turned off per project, on any plan.
20 formats round-trip natively, including JSON, XLIFF, PO, Android XML, iOS strings and stringsdict, ARB, YAML and properties. Seven of them carry plurals, and placeholders and comments survive in both directions.
From the Starter plan. The CLI, the GitHub Action, the REST API and the MCP server all authenticate with a project token, and minting one needs a paid plan. The engine itself is the same on every plan.
Nothing until you pass your plan allowance. Free includes 100,000 words to start and 10,000 a month after, and is hard capped rather than billed. Paid plans meter overage at $0.0008 a word, which is $80 per 100,000 words, against a spend cap you set.
flux on every plan, deep from Team

Put your next change through the engine.

Create a project, add your strings, and every new and changed one is drafted, gated and ready before anyone asks.

Start for freeSee the plans
No card. Free includes 100,000 words to start, then 10,000 a month, and is hard capped, so it cannot bill you.
Works with the tools you already run
All 41 integrations