Introducing the globalize.now MCP: run localization from your AI agent

globalize.now is AI-powered localization infrastructure, and its new MCP server puts that infrastructure inside your AI agent. Connect the server to Claude Code, Cursor, or any Model Context Protocol client, and the agent can create projects, translate your locale files, and open translation pull requests on every push, from the same chat where you write code. The server handles the localization backend; it does not touch your source, which stays the job of the globalize.now skill.

What is the globalize.now MCP server?

It is a hosted Model Context Protocol server that gives an AI agent direct, authenticated access to your globalize.now workspace. MCP is the protocol AI editors use to plug in external tools, and within about eighteen months of its release it became the default way Claude Code, Cursor, and Copilot talk to outside systems. The globalize.now server exposes your localization backend through that same protocol.

Once connected, an agent gets a focused set of tools grouped into three jobs: project setup (create projects, add or remove languages, set project context), repository connection (link a GitHub repo, detect its framework and locale patterns), and file translation (translate locale files and pull back the results). A connected agent acts on your behalf, with your own permissions, in the workspace you last used.

How do you connect it to Claude Code or Cursor?

Point your client at the server URL and sign in. There is no separate dashboard step and no config file to hand-edit for the OAuth path.

For Claude Code, add the server from your terminal, then run /mcp and sign in through your browser:

claude mcp add --transport http globalize https://api.globalize.now/mcp

For Cursor, add the server to ~/.cursor/mcp.json. Cursor prompts you to sign in on first use:

{
  "mcpServers": {
    "globalize": {
      "url": "https://api.globalize.now/mcp"
    }
  }
}

For Claude.ai or any other client that supports the standard MCP OAuth flow, add the same URL as a custom connector and sign in when prompted, no API key needed. For clients without OAuth, generate a workspace API key and pass it as a bearer token instead. The full setup lives on the globalize.now developers page.

What can the MCP do once it is connected?

It runs the whole localization backend from your agent. You describe the outcome in chat, and the agent calls the tools.

It can create a project and add target languages from a catalog of 50-plus locales, including right-to-left languages like Arabic and Hebrew. It can translate locale files you hand it (JSON, ARB, PO, XLIFF, YAML, Android XML, or iOS xcstrings) and return the translated versions, parsed by content so you pass files as-is. Translation is ICU-aware: a plural or a {placeholder} in your source comes back with the plural categories expanded correctly for each language, and brand names and interpolation stay intact. It can also manage a per-project glossary and per-language style guides so tone stays consistent across releases.

The part that matters most for shipping is repository sync. Connect a GitHub repo through the MCP and it registers a webhook. Add a new string to your source locale file, push, and a translation pull request appears with the new keys filled in for every target language, in our testing under a minute after the push. You review the PR and merge. Nothing goes to your main branch directly.

What does a translation look like in practice?

You hand the agent a source locale file and it returns the translated ones with the structure intact. Here is a small en.json with a plural and a placeholder:

{
  "banner": "Welcome back, {name}. You have {count, plural, one {# new message} other {# new messages}}.",
  "cta": "Get started for free"
}

Ask the agent to translate it into Spanish, German, and Arabic, and the MCP returns one file per language. The Spanish output keeps the ICU syntax and expands the plural categories that Spanish needs:

{
  "banner": "Bienvenido de nuevo, {name}. Tienes {count, plural, one {# mensaje nuevo} many {# mensajes nuevos} other {# mensajes nuevos}}.",
  "cta": "Comenzar gratis"
}

The {name} placeholder is untouched, the plural now carries the extra manycategory that Spanish grammar requires, and numbers render in each locale's format at runtime. Arabic comes back ready to render right to left. No dashboard, no export, no translator queue: the agent calls one tool and writes the results where your i18n library already looks. We ran this same loop on our own site, documented in how we globalized globalize.now.

How do you keep tone consistent across languages?

Set a glossary and a per-language style guide on the project, and the MCP applies them to every job. The glossary pins how specific terms translate, so a product name or a domain word stays consistent instead of drifting between releases. A style guide is free-text guidance for one language, such as an instruction to use informal address in German, so translations match your brand voice from the first run instead of after a round of corrections. Both live on the project and travel with every future translation the agent requests.

Does the MCP internationalize my code?

No, and this is the one thing worth being precise about. The MCP works on locale files and project settings, not on your components. It will not find your hardcoded English or wrap it in translation keys.

That step is the job of the globalize.now skill, which runs inside your coding agent. Install it once from your project root:

npx skills add globalize-now/globalize-skills

Then ask your agent to set up i18n. The skill detects your framework, installs the right i18n library, and extracts your hardcoded strings into a source locale file. From there the MCP takes over: it translates those files and keeps them in sync. Think of the skill as the layer that makes your code translatable, and the MCP as the layer that translates and ships. If you are starting from an AI-built app with English baked into the JSX, the vibe coders guide walks through that first step.

How is it different from a TMS MCP server?

Translation management platforms such as Lokalise, Smartling, and Crowdin ship their own MCP servers, and they are useful: they let an agent drive the vendor's dashboard, manage keys, and kick off jobs without custom scripts. But the output still lives in that platform, and the workflow still centers on it.

globalize.now takes the other path. It is AI-powered localization infrastructure, so the output is locale files committed to your repository as a pull request you own. There is no separate platform to log into and no export step to move files back into your codebase. Pricing follows the same principle: usage-metered at €20 per month per workspace, with no per-seat and no per-language charges, and a €5 credit to start. The MCP is the agent-native front end to that infrastructure, not a remote control for a dashboard.