# Jade (oci · ghcr.io/julianbei/jade-mcp:v0.0.11)

The IDE for agents: read by symbol, edit against a revision, validate with your own build, revert.

- Trust score: 30/100 (low)
- Registry status: deprecated
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-20

> **Deprecated**: this server is marked deprecated in the MCP registry. The registry records this reason: "Renamed to io.github.julianbei/arno (ARNO, Agent Repository Navigation & Operations). Same server, same maintainer; install with `https://raw.githubusercontent.com/julianbei/arno/main/install.sh.`"

## Components

- mcpb · `jade-mcp_v0.0.11.mcpb`: 9/100, [markdown](https://verifymcp.io/servers/julianbei-jade/https-github-com-julianbei-jade-releases-download-v0-0-11-jade-mcp-v0-0-11-mcpb.md), [page](https://verifymcp.io/servers/julianbei-jade/https-github-com-julianbei-jade-releases-download-v0-0-11-jade-mcp-v0-0-11-mcpb)
- oci · `ghcr.io/julianbei/jade-mcp:v0.0.11`: 30/100 (this document), [markdown](https://verifymcp.io/servers/julianbei-jade/ghcr-io-julianbei-jade-mcp-v0-0-11.md), [page](https://verifymcp.io/servers/julianbei-jade/ghcr-io-julianbei-jade-mcp-v0-0-11)

## Channel facts

- Registry: `oci`
- Package: `ghcr.io/julianbei/jade-mcp:v0.0.11`
- 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-09-20.

- **Supply Chain Security**: 0/100
  - Malware scan not yet available for this package.
  - Known CVEs could not be checked: this artifact ships no SBOM, so there is no dependency list to read. Publishing one would let us assess it.
  - Install-script risk not yet assessed.
  - Dependency health could not be checked: this artifact ships no SBOM, so there is no dependency list to read. Publishing one would let us assess it.
- **Provenance & Transparency**: 10/100
  - Repository check failed: the declared repository URL redirects; it must resolve directly.
  - Provenance check failed: no build-provenance attestation is published.
  - License check failed: no license is declared.
  - Actively maintained (last published 5 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 75/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 4094 tokens (~132/item across 31 items; 31 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **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.
- **Tool Safety**: 88/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 1 of 2 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "jade.delete_symbol" implies "delete" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 32 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 20/100
  - Spec-recency check failed: implements MCP spec 2024-11-05; the latest is 2026-07-28.

**Unverified: 2 categories.** Categories scored 0 because we could not verify them: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the Jade MCP server?

Jade runs locally as a container image, launched with docker run --rm -i ghcr.io/julianbei/jade-mcp:v0.0.11. Ready-made configuration for Claude, Cursor, VS Code, Codex and 3 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add julianbei-jade -- docker run --rm -i ghcr.io/julianbei/jade-mcp:v0.0.11
```

### Cursor

```json
{
  "mcpServers": {
    "julianbei-jade": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "ghcr.io/julianbei/jade-mcp:v0.0.11"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "julianbei-jade": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "ghcr.io/julianbei/jade-mcp:v0.0.11"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add julianbei-jade -- docker run --rm -i ghcr.io/julianbei/jade-mcp:v0.0.11
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "julianbei-jade": {
      "type": "local",
      "command": [
        "docker",
        "run",
        "--rm",
        "-i",
        "ghcr.io/julianbei/jade-mcp:v0.0.11"
      ],
      "enabled": true
    }
  }
}
```

### Hermes

```yaml
mcp_servers:
  julianbei-jade:
    command: "docker"
    args: ["run", "--rm", "-i", "ghcr.io/julianbei/jade-mcp:v0.0.11"]
```

### Netclaw

```json
{
  "McpServers": {
    "julianbei-jade": {
      "Transport": "stdio",
      "Command": "docker",
      "Arguments": [
        "run",
        "--rm",
        "-i",
        "ghcr.io/julianbei/jade-mcp:v0.0.11"
      ]
    }
  }
}
```

### Other

```json
{
  "mcpServers": {
    "julianbei-jade": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "ghcr.io/julianbei/jade-mcp:v0.0.11"
      ]
    }
  }
}
```

## 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-09-16 (score 30, +6)

- [security regression] Source repository: pass → fail
- [security improvement] Judged manipulation: unverified → pass
- [functional improvement] Schema quality: unverified → excellent

### 2026-09-14 (score 24)

First indexed and scored.

## MCP tools (31)

### `jade.capabilities` (~81 tokens)

What Jade can do in this workspace, in one call: per language, whether a grammar or a text scan reads it, which language server runs or is missing, and which formatter applies; whether git is there; the build, typecheck and test commands check would run; declared commands. Call it first in an unfamiliar repository instead of learning from failed calls.

### `jade.workspace_tree` (~88 tokens)

Return a plain, bounded directory/file structure listing for orientation (not relevance-ranked).

Input parameters:

- `budget` (integer): Size of the listing in tokens. Cut at whole entries; the rest is behind continue=<handle>.
- `continue` (string): Handle from a cut listing: its next page.
- `maxEntries` (integer): Maximum number of entries to return (default 500). Prefer budget.

### `jade.outline` (~39 tokens)

Return the declaration outline for a file, along with freshness and structured section buckets.

Input parameters:

- `path` (string, required): Repository-relative or workspace-relative file path.

### `jade.read_range` (~273 tokens)

Read a file verbatim, whole or by line range — the replacement for `cat` and `sed -n`. Omit both line numbers to read the whole file, which is how to read go.mod, a Makefile, or any JSON/YAML/TOML config that has no symbols to address. An end line past the end of the file reads to the end. A dependency's source reads as dep:<name>/<path>, read-only. Several ranges, in one file or many, go in one call: {"ranges": [{"path": "a.go", "lines": "280-400"}, {"path": "b.go", "lines": "700-760"}]}.

Input parameters:

- `budget` (integer): Size of the read in tokens (default 5000). Cut at whole lines; the rest is behind continue=<handle>.
- `continue` (string): Handle from a cut read: the rest of it.
- `lines` (string): Line range: "280-400", "280-" to the end, or "280". Omit to read the whole file.
- `path` (string): Repository-relative or workspace-relative file path.
- `ranges` (array): Several reads in one call, instead of path. A range that fails reports its error without failing the others.

### `jade.history` (~175 tokens)

List the commits that touched one symbol's lines, via git log -L — 'why does this code exist' without reading a whole file's history. Commits only by default; set includePatch for the diff hunks.

Input parameters:

- `budget` (integer): Size of the patch page in tokens (default 1500). Cut at whole lines; the rest is behind continue=<handle>.
- `continue` (string): Handle from a cut patch: its next page.
- `includePatch` (boolean): Include diff hunks for each commit.
- `limit` (integer): Maximum commits to return (default 10).
- `path` (string, required): File containing the symbol's declaration.
- `symbolId` (string): Exact symbol ID if already known.
- `symbolName` (string): Symbol name to resolve when ID is unknown.

### `jade.context` (~128 tokens)

Assemble everything needed to act on one symbol in a single call: implementation, related types, direct callers, tests exercising it, current diagnostics, and whether it changed since HEAD. Replaces find + references + test search + diagnostics round trips.

Input parameters:

- `path` (string, required): File containing the symbol's declaration.
- `purpose` (string): What the context is for: modify (default), understand, debug, test. Narrows which sections are returned.
- `symbolId` (string): Exact symbol ID if already known.
- `symbolName` (string): Symbol name to resolve when ID is unknown.

### `jade.references` (~132 tokens)

Find where a symbol is referenced. Uses gopls when available (Source=lsp, compiler-resolved); otherwise falls back to the approximate name-matched call graph (Source=approximate).

Input parameters:

- `budget` (integer): Size of the answer in tokens. Cut at whole references; the rest is behind continue=<handle>.
- `continue` (string): Handle from a cut answer: its next page.
- `path` (string, required): File containing the symbol's declaration.
- `symbolId` (string): Exact symbol ID if already known.
- `symbolName` (string): Symbol name to resolve when ID is unknown.

### `jade.rename` (~119 tokens)

Rename a symbol repository-wide via gopls, rewriting every call site deterministically. Refuses rather than guessing when gopls is unavailable or the language is unsupported — it never renames from approximate name matches.

Input parameters:

- `expectedRevision` (string): Revision expected before editing.
- `newName` (string, required): New identifier for the symbol.
- `path` (string, required): File containing the symbol's declaration.
- `symbolId` (string): Exact symbol ID if already known.
- `symbolName` (string): Symbol name to resolve when ID is unknown.

### `jade.find` (~262 tokens)

Locate declarations by name AND return their source in one call — the fused search-and-read that replaces `grep -n 'func X' -A 30`. Exact name matches win over substring ones. Use this instead of outline and read_range when you have not located the symbol yet. Pass queries to find several names in one call.

Input parameters:

- `budget` (integer): Size of the answer in tokens. Cut at whole declarations; the rest is behind continue=<handle>.
- `continue` (string): Handle from a cut answer: its next page.
- `dependency` (string): Look in this dependency's source instead of the workspace, read-only: a crate, Go module, npm or Python package name.
- `kind` (string): Narrow by kind. func/function, type/struct/class/interface, method, const, var — spellings within a family are equivalent. Empty matches any.
- `limit` (integer): Maximum declarations to return (default 5). Prefer budget.
- `maxLines` (integer): Maximum lines of each body (default 40). Prefer budget.
- `queries` (array): Several symbol names in one call, instead of query. Each is answered as query would be.
- `query` (string): Symbol name, exact or partial.

### `jade.retrieve` (~52 tokens)

Select the most relevant files and symbols within a token budget for a task query.

Input parameters:

- `maxTokens` (integer): Maximum budget to keep retrieval under.
- `query` (string, required): Task description or symbol name to retrieve.

### `jade.replace_symbol` (~110 tokens)

Replace a whole declaration. symbolId takes either the full path::Name@line ID or just path::Name when that name is unique in the file — no lookup call needed first. An ambiguous name is refused with the candidates listed.

Input parameters:

- `expectedRevision` (string): Revision expected before editing. Reject if the workspace has moved on.
- `newCode` (string, required): Replacement source code.
- `symbolId` (string, required): path::Name@line, or path::Name when unique in the file.

### `jade.insert` (~225 tokens)

Add text to a file without replacing anything — a new function, a new section, an extra case. Use this for additive work instead of rewriting a surrounding symbol. With no anchor it appends to the end of the file; with one it places the text before or after that anchor, refusing if the anchor is absent or matches more than once. Several additions or edits at once belong in apply.

Input parameters:

- `anchor` (string): Optional. Exact, unique text to place the insertion beside. Omit to append to the end of the file.
- `expectedDigest` (string): Optional. The digest from the read this edit is based on; the edit is refused if the file changed since, by anyone.
- `expectedRevision` (string): Optional. Revision expected before editing; the edit is rejected if the workspace has moved on. Omit for no precondition.
- `path` (string, required): File to add to.
- `position` (string): Optional. "before" or "after" the anchor. Defaults to after.
- `text` (string, required): Text to insert.

### `jade.replace_text` (~172 tokens)

Replace an exact, unique string in a file. An anchor string does not move when the lines around it do, which is why follow-up edits address text rather than line numbers. Refuses when the anchor is absent or matches more than once — extend it with surrounding context to disambiguate. For several sites, use apply: atomic, one validation, no diagnostics from half-done intermediate states.

Input parameters:

- `expectedDigest` (string): Optional. The digest from the read this edit is based on; the edit is refused if the file changed since, by anyone.
- `expectedRevision` (string): Revision expected before editing.
- `newText` (string, required): Replacement text.
- `oldText` (string, required): Exact text to replace. Must appear exactly once.
- `path` (string, required): File path to edit.

### `jade.create_file` (~59 tokens)

Create a brand-new file, and any missing parent directories. Refuses to overwrite an existing one — use replace_text or apply to modify existing content.

Input parameters:

- `content` (string, required): File content.
- `path` (string, required): File path to create.

### `jade.apply` (~155 tokens)

Apply several edits as one atomic unit: all land or none do. Ops: replace_text, replace_range, replace_symbol, delete_symbol, insert. Anchors are validated before anything is written, touched files are formatted, and one validation runs at the end instead of one per edit. Prefer this over several single edits when changing more than one site.

Input parameters:

- `check` (string): Run one validation after all edits: build, typecheck, tests (the edited files' tests), or impact (those plus tests of callers of touched declarations).
- `edits` (array, required): Edits to apply in order.
- `expectedRevision` (string): Revision expected before editing.
- `format` (boolean): Format touched files afterwards (default true).

### `jade.delete_symbol` (~97 tokens)

Delete one declaration entirely. The range comes from jade's parse, so the caller never has to find the closing brace; the blank line the declaration left behind is removed too.

Input parameters:

- `expectedRevision` (string): Revision expected before editing.
- `path` (string, required): File containing the declaration.
- `symbolId` (string): Exact symbol ID if already known.
- `symbolName` (string): Symbol name to resolve when ID is unknown.

### `jade.delete_file` (~54 tokens)

Delete a file, not a directory; fails if it does not exist. Reverting to an earlier checkpoint recreates it. To edit content use replace_text or apply.

Input parameters:

- `path` (string, required): File path to delete.

### `jade.check` (~227 tokens)

Run a validation command on demand and wait for the verdict: kind build (default), typecheck or tests. Uses the repository's own Makefile target, npm script or cargo command when present. Waits by default and returns pass/fail directly. Every result names the command that ran; dryRun names it without running anything. In a repository with several projects, pass target to check one; with no command at the root, the answer lists the projects.

Input parameters:

- `dryRun` (boolean): Name the command that would run, without running it.
- `kind` (string): build (default), typecheck, tests, lint or codegen. lint and codegen run the declared commands of that kind; lint with none declared runs typecheck.
- `target` (string): Project directory inside the workspace to check, e.g. services/api. Omit for the workspace root.
- `timeoutSeconds` (integer): Bound on the wait (default 90, max 300).
- `wait` (boolean): Wait for the result (default true). False returns a job ID to poll.

### `jade.replace_file` (~88 tokens)

Overwrite an existing file's entire contents — for rewriting a document rather than amending it, where there is no anchor to edit against. Refuses to create a new file; use create_file for that. Prefer replace_text or apply when only part of the file changes.

Input parameters:

- `content` (string, required): The file's complete new contents.
- `path` (string, required): Existing file to overwrite.

### `jade.telemetry` (~75 tokens)

Report how jade's own tools have been used in this workspace: calls, response bytes and timing per tool, plus the failure classes that most often end with a caller falling back to the shell. Records no arguments, no response bodies and no error text.

Input parameters:

- `reset` (boolean): Clear the log instead of summarizing it.

### `jade.grep` (~356 tokens)

Literal or regex text search across the workspace, returning path:line matches with optional trailing context — the replacement for `grep -rn`. Use this for anything that is not a declaration name: struct fields, string literals, error messages, config keys, or any search needing a path filter. Use find instead when you want a declaration and its body. Pass queries to search several patterns in one call.

Input parameters:

- `budget` (integer): Size of the answer in tokens. Cut at whole matches; the rest is behind continue=<handle>.
- `context` (integer): Trailing lines to show per match, like grep -A (max 40).
- `continue` (string): Handle from a cut answer: its next page. Other arguments except budget are ignored.
- `dependency` (string): Search this dependency's source instead of the workspace, read-only, at the version the project locks: a crate, Go module, npm or Python package name. Matches read as dep:<name>/<path>, which read_ra…
- `exclude` (string): Skip paths containing this substring, e.g. testdata.
- `glob` (string): Restrict by path, e.g. *.go or internal/code/*.
- `ignoreCase` (boolean): Case-insensitive match.
- `limit` (integer): Maximum matches returned (default 40). The true total is always reported. Prefer budget.
- `queries` (array): Several patterns in one call, instead of query. Each is answered as query would be, with the same filters.
- `query` (string): Text to find.
- `regex` (boolean): Treat query as a regular expression. grep-style \| alternation and \( \) groups work as in grep.

### `jade.run_command` (~123 tokens)

Run a command the repository declares, by name, and wait for the verdict: pass/fail with the decisive output. Use it instead of a shell for anything check does not cover. No name lists the declared commands. Nothing fits? declare_command it once.

Input parameters:

- `name` (string): Declared command to run. Omit to list the declared commands.
- `timeoutSeconds` (integer): Bound on the wait (default 90, max 300).
- `wait` (boolean): Wait for the result (default true). False returns a job ID to poll.

### `jade.declare_command` (~149 tokens)

Declare a named command in .jade/commands.json — a reproduction, a benchmark — to run with run_command in this and later sessions; the file is reviewed like any change. Declaring an existing name replaces it; do not redeclare one just to run it.

Input parameters:

- `description` (string): Optional note on what the command is for.
- `kind` (string): Optional: lint or codegen; check with that kind runs it.
- `name` (string, required): Command name: lowercase letters, digits, ':', '_' or '-'.
- `remove` (boolean): Delete the named command instead of declaring it.
- `run` (string): Shell command to run from the workspace root.

### `jade.run_tests` (~177 tokens)

Rerun a failing test, a test file, or changed files' tests; waits for pass/fail and the first failure. Full suite: check kind tests.

Input parameters:

- `file` (string): Test file to run, for scope=file (Go: its package). With scope=test, limits the name filter to this file.
- `scope` (string): all (default), file, test or changed.
- `test` (string): Test name, for scope=test: exact in Go, the runner's name filter elsewhere (jest/vitest -t, ava --match, pytest -k, cargo test <name>).
- `timeoutSeconds` (integer): Bound on the wait (default 90, max 300).
- `wait` (boolean): Wait for the result (default true). False returns a job ID to poll.

### `jade.changes` (~21 tokens)

Return the current workspace revision and a list of changed paths.

### `jade.diff` (~204 tokens)

Return the actual patch text for the workspace or one path — the 'what changed' companion to changes()'s 'how much changed'. Includes untracked files. Pass since to diff against another revision (HEAD~3, a branch, a SHA), which is how to see what a branch has done once part of the work is already committed. A large patch comes a page at a time, whole lines, with continue=<handle> for the rest.

Input parameters:

- `budget` (integer): Size of the patch page in tokens (default 2000). Cut at whole lines; the rest is behind continue=<handle>.
- `continue` (string): Handle from a cut patch: its next page.
- `since` (string): Optional git revision to diff against, e.g. HEAD~3, main, or a commit SHA. Omit for the working-tree diff against HEAD.
- `target` (string): Optional file path. Omit to diff the whole working tree.

### `jade.checkpoint` (~56 tokens)

Mark a revertible point: snapshots the files Jade has edited this session and records git's HEAD. Not a commit, and does not touch git. Checkpoints last for the session.

Input parameters:

- `note` (string): Optional checkpoint note.

### `jade.revert` (~96 tokens)

Restore the files Jade changed to their state at a checkpoint — edited files restored, files deleted since recreated, files created since removed — as one new revision, all or nothing. Only files Jade touched are restored, and git is never moved. Refuses if a commit has landed since the checkpoint, because restoring would overwrite committed work — use git to move past a commit.

Input parameters:

- `checkpointId` (string, required): Checkpoint ID to restore.

### `jade.job_status` (~31 tokens)

Fetch the status and decisive summary for a background validation job.

Input parameters:

- `id` (string, required): Background job ID.

### `jade.job_output` (~97 tokens)

Fetch the raw output for a background validation job after a summary was already returned. A long output comes a page at a time, whole lines, with continue=<handle> for the rest.

Input parameters:

- `budget` (integer): Size of the output page in tokens (default 2000). Cut at whole lines.
- `continue` (string): Handle from a cut output: its next page.
- `id` (string, required): Background job ID.

### `jade.events` (~42 tokens)

Poll the event stream starting after a cursor position.

Input parameters:

- `after` (integer): Cursor to start after.
- `limit` (integer): Maximum number of events to return.

## Diagnostics

Captured diagnostic sections: Provenance. The full working is on the page: https://verifymcp.io/servers/julianbei-jade/ghcr-io-julianbei-jade-mcp-v0-0-11#diagnostics

## Score history

- 2026-09-20: 30
- 2026-09-19: 30
- 2026-09-18: 30
- 2026-09-17: 30
- 2026-09-16: 30
- 2026-09-15: 24
- 2026-09-14: 24

## Common questions

### What is the Jade MCP server?

Jade is an MCP server listed in the public MCP registry as io.github.julianbei/jade. The IDE for agents: read by symbol, edit against a revision, validate with your own build, revert. This page covers its container image (ghcr.io/julianbei/jade-mcp:v0.0.11).

### Is the Jade MCP server safe to use?

Jade scores 30 out of 100 on VerifyMCP. 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 Jade MCP server expose?

Jade exposes 31 tools: jade.capabilities, jade.workspace_tree, jade.outline, jade.read_range, jade.history, and 26 more. Their descriptions and schemas cost roughly 3,963 tokens of context every time the server is loaded.

### Is the Jade MCP server still maintained?

Jade is marked deprecated in the MCP registry. We last reached this channel on 20 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Changelog RSS feed: https://verifymcp.io/servers/julianbei-jade/ghcr-io-julianbei-jade-mcp-v0-0-11.xml
- Changelog JSON feed: https://verifymcp.io/servers/julianbei-jade/ghcr-io-julianbei-jade-mcp-v0-0-11.json
- HTML version of this page: https://verifymcp.io/servers/julianbei-jade/ghcr-io-julianbei-jade-mcp-v0-0-11