# io.github.AronSoto/verbaly (npm · @verbaly/mcp)

i18n for coding agents: extract, check and translate an app's text, with drafts a person approves

- Trust score: 85/100 (high trust)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- npm · `@verbaly/mcp`: 85/100 (this document), [markdown](https://verifymcp.io/servers/aronsoto-verbaly/verbaly-mcp.md), [page](https://verifymcp.io/servers/aronsoto-verbaly/verbaly-mcp)

## Channel facts

- Registry: `npm`
- Package: `@verbaly/mcp`
- Version: `0.79.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 98/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 30 of 105 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to AronSoto/verbaly).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 1 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 82/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 1579 tokens (~143/item across 11 items; 9 tools + 2 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 17/100
  - Stability observed for 5 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 9 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 10 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the io.github.AronSoto/verbaly MCP server?

io.github.AronSoto/verbaly runs locally as an npm package, launched with npx -y @verbaly/mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add aronsoto-verbaly -- npx -y @verbaly/mcp
```

### Cursor

```json
{
  "mcpServers": {
    "aronsoto-verbaly": {
      "command": "npx",
      "args": [
        "-y",
        "@verbaly/mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "aronsoto-verbaly": {
      "command": "npx",
      "args": [
        "-y",
        "@verbaly/mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add aronsoto-verbaly -- npx -y @verbaly/mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "aronsoto-verbaly": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@verbaly/mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add aronsoto-verbaly --command npx --arg -y --arg @verbaly/mcp
```

### Hermes

```yaml
mcp_servers:
  aronsoto-verbaly:
    command: "npx"
    args: ["-y", "@verbaly/mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "aronsoto-verbaly": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "@verbaly/mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add aronsoto-verbaly -t stdio -c npx -a -y @verbaly/mcp
```

### Other

```json
{
  "mcpServers": {
    "aronsoto-verbaly": {
      "command": "npx",
      "args": [
        "-y",
        "@verbaly/mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-05 (score 85, +1)

No change was recorded against any check on this day. Stability & Change Management went from 13 to 17. That category is still filling its 30-day observation window: 4 days of observed history at the previous scan, 5 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-04 (score 84, +11)

- [security improvement] Known CVEs: unverified → pass
- [functional improvement] Dependency health: unverified → 0.88

### 2026-11-03 (score 73, −11)

- [security regression] Known CVEs: pass → unverified
- [functional regression] Schema quality: 119 → 143
- [functional regression] Dependency health: 0.88 → unverified
- [functional] Schema quality: good → excellent
- [functional] Package version: 0.78.0 → 0.79.0

### 2026-11-02 (score 84, +1)

No change was recorded against any check on this day. Stability & Change Management went from 3 to 7. That category is still filling its 30-day observation window: 1 days of observed history at the previous scan, 2 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-01 (score 83, +15)

- [security regression] Tool safety: pass → unverified
- [security improvement] Malware scan: unverified → pass
- [security] Stability: Stability not yet verified: we do not have a sandbox capture of the MCP schema this version of the package serves yet.
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional regression] Schema quality: 100 → unverified
- [functional improvement] Stability: unverified → 0.03
- [functional] Package version: 0.77.0 → 0.78.0

### 2026-10-31 (score 68)

First indexed and scored.

## MCP tools (9)

### `verbaly_init` (~157 tokens)

Set up Verbaly in a project

Create the config file and the locale catalogs, and detect the bundler or meta-framework so the answer names the package to add and the line to wire (what `verbaly init` does). A file already there is kept, never overwritten, so running it again is safe. Use it when verbaly_doctor finds no config; once the project is set up, verbaly_doctor is the one to run.

Input parameters:

- `dir` (string): Directory for the catalogs (default: locales)
- `locales` (array): Every locale, source included
- `root` (string): Project root holding verbaly.config (defaults to the server working directory)
- `sourceLocale` (string): The language you write in (default: en)

Output parameters:

- `configFile` (string)
- `created` (array): Files written, relative to the project root
- `found` (string): Catalogs the project already had, which the new config points at
- `host` (string): Bundler or meta-framework detected from the dependencies
- `next` (array): What a human still has to do, in order
- `refused` (array): Locales left out: not a locale tag, and no sure way to fix one
- `renamed` (array): Locales written with the hyphen a locale tag takes (pt_BR became pt-BR)
- `skipped` (array): Files already there, left untouched

### `verbaly_doctor` (~143 tokens)

Diagnose the setup

Diagnose a Verbaly project end to end (what `verbaly doctor` does). It checks the config file, the catalogs and their JSON, the bundler plugin for the detected framework, the generated types, files the parser could not read, a t imported from a package that never exports it, orphan keys, and every failure `verbaly check` would report, and it reports them all at once instead of stopping at the first. Run it first when something does not work. Read-only. For the missing or broken translations themselves, use verbaly_missing.

Input parameters:

- `root` (string): Project root holding verbaly.config (defaults to the server working directory)

Output parameters:

- `entries` (array)
- `ok` (boolean): False when an entry is an error, which is when the CLI exits 1

### `verbaly_wrap` (~191 tokens)

Wrap hardcoded JSX text

Find hardcoded user-visible text in JSX/TSX files and wrap it in a t tagged template so the compiler can extract it (what `verbaly wrap` does). This is how an existing codebase is onboarded, and verbaly_extract then adds the wrapped texts to the catalogs. It only reports unless write is set, and text already wrapped is skipped, so running it again is safe. Text it cannot wrap safely (a sentence split across markup, an expression rendering JSX) is listed as needing a human. A file that does not bind t is never written, because the rewrite would not compile. It comes back in blocked, with whether it is a client component, so you can add the binding and run again.

Input parameters:

- `root` (string): Project root holding verbaly.config (defaults to the server working directory)
- `write` (boolean): Apply the rewrites instead of only reporting

Output parameters:

- `blocked` (array)
- `changed` (array): Files the rewrite touched, or would touch
- `files` (number): JSX/TSX files scanned
- `skipped` (array)
- `wrapped` (array)
- `write` (boolean)

### `verbaly_extract` (~156 tokens)

Extract messages

Scan the source files, add new messages to the locale catalogs and refresh the generated types (what `verbaly extract` does). It writes the catalogs unless dryRun is set, and with the same code a second run changes nothing. prune also drops keys the code no longer references, translations included, and waits while any source file fails to parse. In a project without Verbaly, run verbaly_init first; for text still hardcoded in JSX, verbaly_wrap.

Input parameters:

- `dryRun` (boolean): Report what would change, write nothing
- `prune` (boolean): Drop keys no longer referenced (deletes their translations)
- `root` (string): Project root holding verbaly.config (defaults to the server working directory)

Output parameters:

- `added` (array)
- `collisions` (array): Keys written with more than one text: every place shows the text of the first site, so give each text its own key
- `dryRun` (boolean)
- `escaped` (array): Plural or format blocks inside a tagged template, which render as literal text
- `inCode` (number): How many of those messages the code writes as text: 0 when the project keeps its text in the catalog and reads it with t(key)
- `locales` (array)
- `lock` (object): This run created verbaly.lock, moved an older state file (from) into it, or rewrote it whole after a merge conflict (merged): it belongs in git with the catalogs, so tell the user to commit it
- `messages` (number): Messages the source catalog holds after this run
- `positional` (array): Messages that hand a translator a nameless value like {_0}: put the value in a named variable first
- `pruned` (array)
- `renamed` (array): Tagged templates on t under another name (const tr = useT()): never extracted, so they stay in the source language until the binding is named t
- `replaced` (array): Source texts the code wrote over: before is what the catalog said, code is the text that ships. An edit made in the code reads like this too
- `stateProblem` (string): The state file could not be read or written: the catalogs were written, drafts and outdated tracking were not
- `unparsed` (array): Source files the parser could not read: their messages are not extracted, and prune drops nothing until they parse

### `verbaly_status` (~114 tokens)

Translation coverage

Translation coverage of the Verbaly project as numbers per locale: total messages, translated, machine translations awaiting review (drafts), broken, and translations written for an older source text (outdated). It scans the source like verbaly_extract but writes nothing. Read-only. For the entries behind the numbers, use verbaly_missing (what is missing or broken) or verbaly_drafts (each draft with its source text).

Input parameters:

- `root` (string): Project root holding verbaly.config (defaults to the server working directory)

Output parameters:

- `locales` (array)
- `messages` (number): Messages the project has, source catalog plus code
- `source` (string): Source locale
- `stateProblem` (string): The state file could not be read, so drafts and outdated are counted as zero

### `verbaly_missing` (~212 tokens)

Missing and broken translations

The gate `verbaly check` runs in CI, as lists: missing translations, unknown keys, keys written with two texts (collisions: every place shows the first text) and translations that cannot render what the source renders. A dropped {param}, a lost rich tag or a flattened plural block is that last kind. Warnings never fail the gate and are listed too: an incomplete plural set for the locale, keys only a translation has (extra), texts the code and the source catalog disagree on (divergent: the text in the code ships) and translations written for an older source text (outdated). With drafts set, it also lists the machine translations awaiting review. Read-only. For counts use verbaly_status, to review drafts with their source text verbaly_drafts, and for setup problems verbaly_doctor.

Input parameters:

- `drafts` (boolean): Also list machine translations awaiting human review
- `root` (string): Project root holding verbaly.config (defaults to the server working directory)

Output parameters:

- `broken` (array)
- `collisions` (array): One key, several texts: every place shows the first site, so it fails the gate. Give each text its own key
- `divergent` (array): The source catalog says one text and the code another: the code's text ships. Never fails the gate
- `extra` (array): Keys only a translation has; files are where the code reads one, which the source language then shows as the key itself. Never fails the gate
- `missing` (array)
- `ok` (boolean): Whether `verbaly check` would pass (warnings never fail it)
- `outdated` (array): Translations written for an older source text: rewrite them, or a human keeps them with verbaly review --approve. Never fails the gate
- `stateProblem` (string): The state file could not be read, so outdated translations are not listed
- `unknown` (array)
- `unreviewed` (array)

### `verbaly_translate` (~183 tokens)

Machine-translate missing entries

Fill missing translations with the configured provider (what `verbaly translate` does). The default provider is Claude, which needs @anthropic-ai/sdk and ANTHROPIC_API_KEY. Every new translation is saved as a draft awaiting human review (`verbaly review`), which no tool here can approve. A batch the provider never answers is reported in failed and everything else stays written, so a retry only asks for what is left. dryRun lists what would be translated without calling the provider. To see what is missing first, use verbaly_missing; to save translations you wrote yourself, verbaly_write_drafts.

Input parameters:

- `dryRun` (boolean): List missing entries per locale, call no provider
- `locales` (array): Target locales (default: all)
- `root` (string): Project root holding verbaly.config (defaults to the server working directory)

Output parameters:

- `dryRun` (boolean)
- `failed` (array): Batches the provider never answered, safe to retry
- `invalid` (array): Rejected: params or tags were not preserved
- `kept` (array): Written on disk by someone else while the provider worked, so left as they were
- `pending` (array): dryRun only: what would be translated
- `translated` (array): Saved as drafts, a human still has to approve them

### `verbaly_write_drafts` (~187 tokens)

Save translations an agent wrote

Save translations you wrote yourself, so neither a catalog nor the state file is ever edited by hand. Each one is checked the way verbaly_translate checks a provider (params, rich tags and plural cases must survive), written only for keys the source catalog has, and marked as a draft awaiting human review. Existing translations are kept unless overwrite is set, which is how an outdated one gets rewritten. Approving is not a tool here: a human reads the drafts (verbaly_drafts lists them) and runs `verbaly review --approve`.

Input parameters:

- `entries` (array, required): The translations, by catalog key
- `locale` (string, required): Target locale, one of the project's non-source locales
- `overwrite` (boolean): Replace translations that already exist, for example outdated ones
- `root` (string): Project root holding verbaly.config (defaults to the server working directory)

Output parameters:

- `invalid` (array): Rejected: empty, or the params, tags or plural cases were not preserved
- `kept` (array): Already translated, left as they were (overwrite replaces them)
- `unknown` (array): Not in the source catalog, so nothing was written
- `written` (array): Saved as drafts, a human still has to approve them

### `verbaly_drafts` (~138 tokens)

Machine translations awaiting review

Every machine translation still waiting for a human, each with the source text and what the provider wrote, so a person can read both and decide. Read-only. Approving is deliberately not a tool here and never will be: a machine translation is unreviewed by definition, so accepting one is `verbaly review --approve`, run by a human. For how many drafts each locale has, verbaly_status is enough; verbaly_missing lists them next to the gate.

Input parameters:

- `locales` (array): Target locales (default: all)
- `root` (string): Project root holding verbaly.config (defaults to the server working directory)

Output parameters:

- `entries` (array)
- `total` (number)

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/aronsoto-verbaly/verbaly-mcp#diagnostics

## Score history

- 2026-11-05: 85
- 2026-11-04: 84
- 2026-11-03: 73
- 2026-11-02: 84
- 2026-11-01: 83
- 2026-10-31: 68

## Common questions

### What is the io.github.AronSoto/verbaly MCP server?

io.github.AronSoto/verbaly is an MCP server listed in the public MCP registry as io.github.AronSoto/verbaly. i18n for coding agents: extract, check and translate an app's text, with drafts a person approves. This page covers its npm package (@verbaly/mcp).

### Is the io.github.AronSoto/verbaly MCP server safe to use?

io.github.AronSoto/verbaly scores 85 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the io.github.AronSoto/verbaly MCP server expose?

io.github.AronSoto/verbaly exposes 9 tools: verbaly_init, verbaly_doctor, verbaly_wrap, verbaly_extract, verbaly_status, and 4 more. Their descriptions and schemas cost roughly 1,481 tokens of context every time the server is loaded.

### Is the io.github.AronSoto/verbaly MCP server still maintained?

io.github.AronSoto/verbaly is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the io.github.AronSoto/verbaly MCP server under?

io.github.AronSoto/verbaly declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

### What did VerifyMCP test on the io.github.AronSoto/verbaly MCP server?

VerifyMCP ran 16 checks on io.github.AronSoto/verbaly, covering Malware scan, Known CVEs, Install scripts, Dependency health and 12 more. Endpoint Security and Transport & Reachability do not apply to an npm package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- npm package: https://www.npmjs.com/package/@verbaly/mcp
- Socket report: https://socket.dev/npm/package/@verbaly/mcp
- Repository: https://github.com/AronSoto/verbaly
- Changelog RSS feed: https://verifymcp.io/servers/aronsoto-verbaly/verbaly-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/aronsoto-verbaly/verbaly-mcp/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/aronsoto-verbaly/verbaly-mcp.json
- HTML version of this page: https://verifymcp.io/servers/aronsoto-verbaly/verbaly-mcp