Agentic localization for your codebase

Glossia translates your content with LLMs, keeps everything in-repo, validates output locally, and generates drafts your team can review without the round-trip of external platforms.

Get started How it works

Why we built this

We tried Crowdin and Weblate. The indirection of exporting and importing content slowed us down, and we could not run our own validation in the loop. We wanted the same workflow we use for code: change, test, review, ship.

Now translations are generated in place, checked by your tooling, and reviewed by humans only when it matters.

How it works

01
Give agents context

Add L10N.md context files alongside your content. Glossia tracks their dependency so when context or content changes, only the affected translations get regenerated.

02
Choose your models

Pick one model to coordinate the agentic session and another to translate accurately. Use any OpenAI-compatible endpoint, Vertex AI, or your own hosted model.

03
Agents validate their own work

Agents have access to built-in syntax checks and custom commands you define. They run validation after each translation and retry on errors, so output is correct before you review.

Tools

Agents use tools to automate verification after every translation.

Syntax validators

Parse output to ensure it is valid before it is saved.

  • JSON
  • YAML
  • PO
  • Markdown frontmatter

Preserve checks

Guarantee critical tokens survive translation.

  • Code blocks
  • Inline code
  • URLs
  • Placeholders

Custom commands

Bring your own validators with check_cmd and check_cmds.

  • Linters
  • Compilers
  • Schema validators

Tool failures trigger retries until the output is valid.

Configuration lives in your repo

L10N.md

Define translation sources, targets, and output patterns in TOML frontmatter.

+++
[[translate]]
source = "site/src/_data/home.json"
targets = ["es", "de", "ko", "ja", "zh-Hans", "zh-Hant"]
output = "site/src/_data/i18n/{lang}/{basename}.{ext}"
+++

# Context for the translating agent...

CLI commands

Translate, validate, and track what needs updating.

  • glossia init Interactive project setup
  • glossia translate Generate translations
  • glossia status Report missing or stale outputs
  • glossia check Validate output syntax
  • glossia clean Remove stale translation outputs

Use --force to re-translate everything.

Built for real workflows

#

Context-aware hashing

Translations update when source content or ancestor L10N.md context changes.

✓

Validation hooks

JSON, YAML, and PO syntax checks plus optional external lint commands.

»

Agent pipeline

Separate coordinator and translator models with retry on validation errors.

Human review ready

Generate drafts fast, review when needed, and keep everything in Git.

Progressive Refinement

Translations don't have to be perfect on day one. Like code, they improve through iteration.

First drafts from LLMs are structurally correct but may miss nuance, tone, or domain-specific phrasing. That is by design. Each review cycle -- a pull request comment, an updated context file, a glossary tweak -- feeds back into the next translation run. Quality converges over successive passes, not in a single shot.

Draft

LLM generates a structurally valid first pass based on your context files.

Review

Your team flags issues through pull requests, just like code review.

Refine

Updated context and glossary corrections feed into the next run, closing the gap.

Converge

Each cycle narrows the distance to production quality. The system learns your product's voice.

This follows the same principle behind Kaizen in manufacturing, post-editing in professional translation (PEMT), and successive approximation in engineering: start with a good-enough baseline and systematically improve it with human judgment in the loop.

FAQ

How is this different from traditional translation tools?

Traditional tools rely on translation memories, static databases of past translations that are matched by similarity. Glossia replaces that with LLM context as memory: context files that agents read, learn from, and that your team can iterate over time. Instead of looking up a fuzzy match, agents understand your product's tone, terminology, and conventions. And just like developers validate code changes by compiling or linting, agents validate their translations using the same tools in your environment. Run it in CI or locally, and agents will use your linters, compilers, and validators to correct their own output.

Do I need to bring my own models?

Yes. Glossia is a CLI tool, not a hosted service. You point it at any OpenAI-compatible endpoint, Vertex AI, or your own model. You control the cost, the data, and the quality.

How do humans review translations?

Today, reviewers check translated content through pull requests and diffs, and can update context files to force re-translation when needed. In the future, we expect them to become part of the loop by running Glossia locally, the same way developers already work with coding agents like Codex.

Updates