# General Translation Knowledge Base: What does the Locadex agent do?
URL: https://generaltranslation.com/en-US/kb/what-is-locadex.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Locadex is General Translation's AI agent which internationalizes your code and translates your content in your GitHub repository. Its automations run when a pull request is opened, when a commit is pushed, or when you start one, and every change arrives as a pull request.
Category: Workflow Tools
Last updated: 2026-10-21
Authors: Kevin Liu, Kevin Wu
Published: 2026-10-21

Locadex is General Translation's AI agent which internationalizes your code and translates your content in your GitHub repository, and delivers every change as a pull request. In an app in several languages, new interface text has to be wrapped in internationalization (i18n) calls and translated into each target language, and adding or removing a language means updating the configuration. Done by hand, that work happens after the code changes, so a feature ships in the source language first and its translations follow later.

| Approach | What it does well | When translation happens | What it leaves to you |
| --- | --- | --- | --- |
| An i18n library alone (`i18next`, `react-intl`, `next-intl`) | Mature runtimes for rendering translations and formatting values | Whenever someone updates the language files | Replacing each string with a key, adding it to every language file, and committing the changes yourself |
| A coding agent you drive, such as Cursor or Claude Code with General Translation's [start prompt](/docs/overview/for-coding-agents#start-prompt) | Sets up i18n in a session you supervise | When you or your CI run [`npx gt translate`](/docs/cli/reference/commands/translate) | Supervising the session, then reviewing and committing its edits |
| General Translation (Locadex) | Its **Generate code** automation wraps text in i18n calls on each run, and every change arrives as a pull request | On the trigger you choose: a pull request, a push, or **Run now** | Reviewing each pull request, or turning on **Auto-merge** |

Use an i18n library alone when translators own the language files and each release can wait for them. Use a coding agent for a one-time setup you want to watch, then run [`npx gt translate`](/docs/cli/reference/commands/translate) in CI before each build. Use Locadex when the app or docs change with most pull requests and you want each change's translations in a pull request without maintaining a pipeline step. For a stack outside Locadex's list, such as Vue or Node.js, use General Translation's libraries and the `gt` CLI.

## Video

The video is narrated in English, with English captions.

[What does the Locadex agent do?](https://caxecubb9c64cezv.public.blob.vercel-storage.com/films/kb-what-is-locadex.mp4) (49 sec)

General Translation uses its AI agent Locadex to open pull requests that translate your app. Connect GitHub in the Dashboard and create an automation from a template: Generate code wraps untranslated text in the right i18n calls, Generate translations and push translates each change into every target language, and Keep locales in sync updates the project when languages change. Run setup with your target languages, merge its pull request, and review Locadex's pull requests or turn on auto-merge.

## What Locadex automates

Teams configure when each Locadex automation runs, what it changes, and how changes are delivered in GitHub. Each automation starts from one of three templates under **Project > Automations**:

- **Generate code** finds untranslated interface text and wraps it in i18n calls, such as the [`<T>`](/docs/react/reference/components/t) component.
- **Generate translations and push** translates new or updated source content into every target language.
- **Keep locales in sync** updates the project files when languages are added or removed.

Locadex supports Next.js; React apps built with Vite, Gatsby, Redwood, React Router, TanStack Start (its `gt-tanstack-start` library is experimental), and others; and the docs frameworks Mintlify, Fern, and Docusaurus.

## How it works

Locadex requires a Starter or Enterprise plan, and its runs are metered in Locadex Compute Units (LCUs); the [pricing page](https://generaltranslation.com/pricing) has current rates. Connect GitHub under **Project > Integrations > Catalog**, create an automation, and click **Run setup** to choose the source locale and target languages, for example, English into Spanish, French, and Japanese. In a React app, setup opens a pull request that configures translation loading and leaves your strings alone. After you merge it, **Generate code** wraps them in calls such as [`<T>`](/docs/react/reference/components/t), which in a Next.js page looks like this:

```tsx title="app/page.tsx"
import { T } from 'gt-next';

export default function Home() {
  return (
    <main>
      <T>
        <h1>Welcome to my app</h1>
        <p>This content will be translated automatically.</p>
      </T>
    </main>
  );
}
```

**Run when** sets each automation's trigger. With **A pull request changes**, Locadex runs when a pull request is opened, reopened, or marked ready for review, then opens a separate pull request and links to it in a comment on yours. With **A commit is pushed**, it runs when commits land on the target branch, usually `main`. With **Started manually**, it runs only when you click **Run now**.

**Auto-merge** is off by default; turned on, it merges Locadex pull requests when checks pass.

Locadex translations follow the [Context Groups](/docs/platform/dashboard/guides/defining-context-for-translations) assigned to your General Translation project (a Glossary that pins product terms and Custom Prompts that set tone). Edits made in the Dashboard reach GitHub the same way: the next Locadex translation run brings Dashboard edits into a pull request.

## Configure the repository

Use [pre-process commands](/docs/platform/locadex/guides/configuring-automations) to install the dependencies and tools your project needs in the [Locadex sandbox](/docs/platform/locadex/reference/vm-image). In a monorepo, set **Target directory** to the app's folder and begin pre-process commands with a `cd` into it.

Review setup pull requests manually. For later automation pull requests, **Auto-merge** requires passing checks and the repository permissions described in [Configuring automations](/docs/platform/locadex/guides/configuring-automations).

To request a run on a pull request's current revision, comment `/locadex`. The automation guide covers trigger behavior and repository settings, and the [Locadex Quickstart](/docs/platform/locadex/quickstart) has the full steps.

## Related questions

- [How do I internationalize an app with Cursor or Claude Code?](https://generaltranslation.com/en-US/kb/ai-agent-i18n-setup.mdx): Start with General Translation's Setup for Agents prompt in Cursor or Claude Code, choose a feature and target languages, and have the agent implement and verify the result. Browser sign-in, machine-readable docs, and MCP tools connect setup to translation and review. Use Locadex to automate continuing localization through pull requests.
- [How do I add i18n to a Next.js App Router app?](https://generaltranslation.com/en-US/kb/add-i18n-to-nextjs.mdx): Start with gt init to configure General Translation in a supported App Router project, then mark source content, generate translations, and verify language switching. gt-next keeps copy in JSX with translation context; the CLI, Dashboard editor, and Locadex handle generation, review, and ongoing updates. This guide also shows the explicit local-file setup.
- [How do I translate a Mintlify docs site?](https://generaltranslation.com/en-US/kb/translate-mintlify-docs.mdx): Write a translated copy of every page in a folder per language and add each language to the docs.json navigation. General Translation's AI agent, Locadex, opens a pull request that adds the translated pages and per-language navigation, then translates later changes.
- [How do I keep translations up to date on every deploy?](https://generaltranslation.com/en-US/kb/translations-in-ci.mdx): Run translation as a pipeline step before each production build, so new copy ships translated with the deploy that adds it. General Translation's gt CLI does this with npx gt translate, using a project API key and project ID stored as CI secrets.
- [Can I do i18n without translation files?](https://generaltranslation.com/en-US/kb/i18n-without-translation-files.mdx): Yes. General Translation's gt-react and gt-next libraries do React and Next.js i18n with no translation keys and no JSON file per language to maintain. Copy stays inline in JSX inside the `<T>` component, and the gt translate command generates each language's translations in your build, with context from your code. Locadex can keep them current through pull requests.

## Previous and next questions

- Previous question: [How do I translate strings outside JSX?](https://generaltranslation.com/en-US/kb/translate-strings-outside-jsx.mdx)

## Sitemap

See the [Knowledge Base sitemap](https://generaltranslation.com/en-US/kb/sitemap.md) for every article.
