MCP and i18n: AI in the translation workflow

Ask an AI assistant to translate “Submit” into French and it’ll hand you back “Soumettre.” Right? No way to tell — is it a form submit button, a job application, a payment? Without context, even the best model is guessing. That’s the whole problem with software translation, and it’s exactly what the Model Context Protocol sets out to change.

This article covers what MCP is, why connecting AI to your tools changes the game, and what it unlocks in practice for teams running multilingual products. If you need the i18n basics first, start with what i18n is.

What is MCP (Model Context Protocol)?

The Model Context Protocol is an open standard, introduced by Anthropic, that defines a common way to connect an AI agent to outside tools and data. It’s often described as “USB-C for AI”: instead of inventing a bespoke integration for each app, you expose your capabilities through an MCP server, and any compatible client — a code editor, a chat assistant, an autonomous agent — can plug in.

Concretely, an MCP server publishes two things: resources (data the agent can read) and tools (actions the agent can trigger). The agent no longer just produces text in a window — it can read your system’s real state and act on it, within guardrails.

Why connect AI to tools, not just to a chat box

A language model in a chat box is brilliant but blind: it only sees what you paste in. It doesn’t know where a string is used, what your glossary conventions are, or what’s already been translated elsewhere. So you spend your time playing middleman — copying context in, pasting the answer out, checking by hand.

MCP removes the middleman. By giving the agent eyes (read the context) and hands (act in the tool), it goes from “text generator” to “workflow participant.” The difference isn’t cosmetic: it’s the gap between an assistant that suggests and a colleague that does.

MCP or just an API?

“But doesn’t a REST API already do this?” Not quite. An API exposes endpoints a developer has to read, understand and wire into code. MCP exposes tools an AI agent can discover and use on its own, on the fly, because each tool is described in a format the model can interpret.

Three practical consequences. First, the integration is client-agnostic: the same server serves an editor, a chat assistant or an autonomous agent, no bespoke adapter. Second, it’s model-agnostic: switch AI models and the wiring holds. Third, the agent composes tools — read context, then propose, then verify — without anyone scripting the sequence in advance. That’s the difference between wiring an integration and granting a skill.

The translation workflow today

To see what MCP adds, look at how translation actually works on most teams — and where it jams.

• Keys with no context. A translation file is a list of keys and text. The translator sees checkout.submit = "Submit" but not the button, the screen, or the neighboring sentence. They guess.
• Tool ping-pong. The source text lives in the code, the translations in a platform, the glossary in a third place. People copy-paste between the three, and information leaks at every hop.
• Glossary drift. “Cart,” “basket,” “bag”: with no control, the same concept ends up translated three ways depending on who handled the key.
• The blocked developer. A key’s missing in production? Leave the editor, open the platform, find the key, translate it, republish. The friction discourages small fixes — and they pile up.

None of these is an AI-model problem. They’re context and tooling problems.

What AI in the workflow unlocks

This is where connecting AI to your i18n platform through MCP gets interesting. Without giving away the recipe, here’s the value it opens up.

• Context-aware translation. Because the agent can read what surrounds a key — its location, the neighboring strings, the notes your team left — it proposes a translation that fits the actual use, not a dictionary rendering. “Submit” becomes “Place order” when it’s a checkout.
• Automatic terminology consistency. The agent can check each proposal against your glossary and flag — or fix — a drift before an inconsistency reaches the user.
• Action where you already work. Because the MCP client lives in the developer’s tool (editor, CLI, agent), it reads, proposes and applies without ever making you switch tabs. Fixing a missing key becomes a one-sentence job, not a ten-minute detour.
• Volume without the grind. Seeding a new language across hundreds of keys, spotting gaps, harmonizing vocabulary: the mechanical work gets done in bulk, and the human focuses on what deserves judgment.

The key point: AI doesn’t replace your i18n system, it plugs into it. Your keys, your glossary, your review statuses stay the source of truth; the agent works with them.

An example: from missing key to fix

Picture a developer who adds a screen and, with it, a new text key. In the classic workflow, that key ships untranslated to a platform, waits for a translator to notice it, then comes back — days later, at best.

With an agent plugged in over MCP, the loop folds in on itself. The agent spots the newly added, untranslated key. It gathers the context — the screen, the neighboring strings, the intent. It proposes a translation in each target language, aligned with the glossary. And it drops it at a “needs review” status, ready for a human — all without anyone leaving their editor.

The win isn’t only speed: it’s that the work happens when and where the information is freshest, rather than reconstructed from memory a week later by someone who never saw the screen.

Keeping humans in control

Giving an AI hands only helps if you keep control. The right model isn’t “the AI translates and publishes silently,” it’s “the AI proposes, the human approves.” Generated translations land at an intermediate status — proposed, needs review — and a reviewer keeps the final say on tone, brand, cultural nuance. MCP makes the agent fast; the human guardrail makes it trustworthy. Both together, not one without the other.

The vision: AI as a colleague in the workflow

For a long time, i18n pitted two worlds against each other: developers who place the keys and linguists who translate them, each in their own tool, separated by exports and imports. MCP sketches a third path: an agent that moves between the two, understands both the technical context and the linguistic intent, and makes itself useful at the exact spot where the work happens.

This isn’t AI “doing the translation” for you. It’s AI as a colleague: it takes the mechanical 80% — the context to gather, the gaps to fill, the consistency to hold — so humans keep the 20% that needs taste and judgment. That’s the experience Sonenta makes possible: your translation platform exposed over MCP, so the assistant you already use works directly with your keys — no copy-paste, no tab-switching. The approved translation then joins your deployment pipeline and ships to production without a rebuild.