---
name: edge
version: 0.5.0
license: MIT
description: >-
  Setup guide for Edge, an MCP server that finds a fitting public agent skill
  for a task. Covers Claude Code, Codex, Cursor and the Claude app, the Free
  and Pro plans, what data it sends, and how to remove it.
---

# Edge setup guide

This file is a setup guide, not a skill to install. It explains how to add
Edge to an agent and what that changes. Edge here is the skill search from
getedge.cc, not the Microsoft Edge browser. The guide is plain Markdown;
`curl -s https://getedge.cc/SKILL.md` prints the full text.

Edge is an MCP server from getedge.cc. When a task needs specialist know-how
(a slide deck, a security review, a data analysis), it searches over 100,000
public agent skills, withholds skills that fail its security checks, and loads
the best fit's instructions for that task. Loading is read-only: the
instructions apply to that task only, as text your agent reads and then
follows or ignores, and nothing is installed. Before a skill is shown, Edge
checks it against independent security scanner audits: a skill that fails is
withheld, and a skill with no audit yet is marked as having no security
evidence. This guide is published
under the MIT license with the `@getedge/mcp` npm package:
https://www.npmjs.com/package/@getedge/mcp.

Setting up Edge on Claude Code, at a glance:

- The route depends on Node.js 20 or newer and npx. With them, one MCP
  server entry named `edge` (`claude mcp add`), which runs the
  `@getedge/mcp` npm package with `npx`; without them, the hosted Edge
  plugin instead.
- Local Edge also adds, with `npx -y @getedge/mcp setup claude`, a prompt
  hook and one marked line in your own `~/.claude/CLAUDE.md`. Both apply to
  every project. The hook runs on your machine and sends nothing itself; on
  a prompt that looks like specialist work it adds one sentence suggesting an
  Edge search (`EDGE_NUDGE=off` silences it). The line asks Claude to check
  Edge before specialist work and not for routine edits; setup prints it in
  full.
- Each search sends the task sentence to getedge.cc, as listed under "Data".
  File contents, paths and conversation history are not sent.
- Local Edge also sends two daily signals, listed under "Data".
  `EDGE_TELEMETRY=0` turns them off.
- Every change has a removal command at the end of this guide.

## Plans

- **Free:** no account and no key. Unlimited searches with task-fit ranking,
  your installed skills ranked alongside if you opt in, and loading a skill
  for the current task.
- **Pro:** $99 per month (https://getedge.cc/pricing/), as a key that starts
  with `edge_`. Same search, and your ratings count under your key. The key
  is set as the `EDGE_KEY` environment variable of the `edge` entry.

## Your plan

Nothing is added until you agree. The Free plan needs no key, so agreeing
without one sets up Free. A Pro key (it starts with `edge_`) can be given at
the same time or added later. A finished setup says which plan is in use.

## Your installed skills

Only a connector that runs on your machine can rank installed skills: the
npm connector (Claude Code, Codex, Cursor) can, the hosted connector (Claude
Code plugin, Claude app) cannot. `setup claude` prints which one is
installed, as `canReadLocalSkills` true or false. On the hosted connector
this question does not come up.

On the npm connector, setup asks one question, with Yes as the recommended
answer: "Rank your installed skills too? Edge and its ranking provider
receive skill names and short descriptions, never skill contents." That is up
to 40 per search, to getedge.cc and to TypeSafe, on Free and Pro.
With no answer it stays off. A yes to the older question, which named only
Pro, counts on Free once you say yes again. Claude Code records the answer with
`--local-skills on` or `--local-skills off` on `setup claude`; Codex and
Cursor with `on` or `off` in `~/.config/edge/local-skills`, plus `2` in
`local-skills-consent` next to it for a yes. In the `edge`
entry, `EDGE_LOCAL_SKILLS_EXCLUDE` (patterns such as
`acme-*,~/work/client/**`) keeps matching skills on your machine, and
`EDGE_LOCAL_SKILLS=0` turns ranking off.

## Claude Code

The route is chosen from the runtime before anything is installed;
`node --version` and `npx --version` show which one applies.

**Node.js 20 or newer, and npx: local Edge.** One command, for all your
projects:

```bash
npx -y @getedge/mcp setup claude
```

It adds the `edge` connector (`claude mcp add`, running the `@getedge/mcp`
package on your machine, pinned to the release that ran setup), a prompt
hook and one marked instruction line in your own `~/.claude/CLAUDE.md`,
never in a project's files. It checks that the hook fires, runs one sample
search, and prints what it added and how to remove it. It also downloads
the package, so a chat opened before it finishes misses Edge.

Pro uses local Edge, with your key added first:

```bash
claude mcp add edge -s user -e EDGE_KEY=edge_YOUR_KEY -- npx -y @getedge/mcp
npx -y @getedge/mcp setup claude
```

**No Node.js 20+, or no npx: hosted Edge**, as the Edge plugin:

```bash
claude plugin marketplace add getedgehq/edge-plugins
claude plugin install edge@getedge
```

The plugin is public at https://github.com/getedgehq/edge-plugins. It adds
the hosted Edge connector (`https://getedge.cc/mcp`), a short `edge` skill
that tells Claude when to call it, and a prompt hook that runs locally and
sends nothing. The hosted connector cannot rank your installed skills.
`claude plugin list` then shows `edge@getedge` as enabled. When npx runs but
Node.js is older than 20, `setup claude` makes the same check and installs
the plugin itself.

Use one route, not both. If an `edge` entry already exists,
`claude mcp get edge` shows it, and `claude mcp remove edge` clears it
before adding it again with a key.

Edge's tools (`find_skill`, `use_skill`) appear in the next Claude Code
session. A finished setup reports the plan in use ("Edge is set up on the
Free plan" or "Edge is set up on the Pro plan"), the capability mode
("Capability mode: local" or "Capability mode: hosted"), what was added and
how to remove it, and that a new session picks it up.

## Codex and the ChatGPT desktop app

Both read `~/.codex/config.toml`. This block goes in that file as shown
(Free):

```toml
[mcp_servers.edge]
command = "npx"
args = ["-y", "@getedge/mcp"]
omit_tools_from = ["deferred"]
```

Pro: add one more line inside the block, `env = { EDGE_KEY = "edge_YOUR_KEY" }`.

The `omit_tools_from` line exposes Edge's tools directly in clients that
defer MCP tools. It is recommended for this setup, rather than required
for the MCP connection. Tool discovery depends on your client and
configuration. An existing `[mcp_servers.edge]` block is replaced by this
one; reading the file back confirms the block.

`mcp_optional_startup_grace_ms = 10000` also goes on its own line at the top
of the file, above the first `[section]` (if that line exists, set it to
10000). Codex otherwise waits only 1 second for MCP servers that are still
starting when the first message is sent, and an `npx` start takes longer,
so the first chat misses Edge. Running `npx -y @getedge/mcp --version` once,
until it prints the version number, downloads the package before the first
chat.

Edge's tools appear in the next Codex or ChatGPT chat. A finished setup
reports the plan in use, "Edge is set up on the Free plan" or "Edge is set
up on the Pro plan", and that a new chat picks it up.

## Other clients

- **Cursor:** in `~/.cursor/mcp.json`:
  `{ "mcpServers": { "edge": { "command": "npx", "args": ["-y", "@getedge/mcp"], "env": { "EDGE_KEY": "edge_YOUR_KEY" } } } }`
  (leave out `env` for Free), then `npx -y @getedge/mcp --version` once.
- **Claude app** (claude.ai or desktop): Settings, Connectors, Add custom
  connector, URL `https://getedge.cc/mcp`. Pro: header
  `Authorization: Bearer edge_YOUR_KEY`, or the URL
  `https://getedge.cc/mcp?key=edge_YOUR_KEY` where there is no header field.

## Claude app: optional instruction

If you want Claude to reach for Edge on specialist work, you can paste this
line into Claude Settings > Instructions for Claude yourself. The same line
has a copy button at https://getedge.cc/docs/setup/ (Claude app tab).

```text
Before specialist work, call Edge's find_skill.
```

## Referral codes

If you came from a link with `?ref=CODE`, set `EDGE_REF=CODE` in every host's
Edge MCP environment. Claude Code also accepts
`npx -y @getedge/mcp setup claude --ref CODE`. The code is stored locally and
sent with later calls.

## Data

| | What and how long |
|---|---|
| Edge receives | The task sentence the agent writes (up to 300 characters) and optional keywords. The agent writes it as a generic task, such as "seed pitch deck outline", without names of people, candidates, clients or companies, and Edge removes email addresses, URLs, file paths, keys and phone numbers before anything is stored (local Edge already does this on your machine, before sending). Edge also receives a random install ID (`~/.config/edge/install-id`) or session ID (in ChatGPT, a one-way hash of ChatGPT's anonymous user ID, so one person counts once), the Pro key if set, and the client name and version. Ratings and issue reports when the agent sends them. Installed skill names and short descriptions only if you opt in. |
| Daily signals | Local Edge (the connector that runs on your machine) sends at most two signals per UTC day: "ready" when it starts, and "nudged" when the prompt hook suggested an Edge search. Each holds only the install ID, the date, the app name and version, and the connector version and type: no task text, prompt, skill name, key or count. They show whether Edge ran on days it was not used. `EDGE_TELEMETRY=0` turns both off. |
| Edge stores | All of that, daily signals included, except installed skill names and descriptions (only their count), with the skills shown and loaded. Search text has no scheduled expiry: 31 days in daily files, then a compressed archive. Backups are encrypted. |
| Never receives | File contents, paths, repository names and conversation history are not sent. |
| Who else sees it | To rank candidates, TypeSafe (api.typesafe.ai), under Edge's own service key, gets the task sentence and candidate skill descriptions, with no install ID or key. With installed-skill ranking on, that includes your installed skills' names and short descriptions. |
| How to delete | `npx -y @getedge/mcp@0.6.14 forget` deletes this install's records (with `EDGE_KEY` set, the key's too) and prints the counts. Or email fede@getedge.cc. |

Details: https://getedge.cc/privacy/

## Remove

Claude Code plugin: `npx -y @getedge/mcp setup claude --remove` (the
instruction line), `claude plugin uninstall edge@getedge`, then
`claude plugin marketplace remove getedge`.

npm connector: `npx -y @getedge/mcp setup claude --remove` (Claude Code: the
hook and the instruction line), `claude mcp remove edge` (Codex:
`codex mcp remove edge`), then `rm -rf ~/.config/edge`.

Removing Edge deletes nothing stored on the server; `forget` does.

Older setups may also have saved `~/.claude/skills/edge/`. Edge no longer
needs it.

## Tools

Once connected, Edge offers these tools:

- `find_skill`: searches for a fitting skill at the start of a new task that
  involves UI or visual design polish, documents or slides, images/video/media,
  data analysis or charts, security review, or a specific framework or API,
  or when you ask for a skill. Renames, small fixes, basic questions and
  same-task follow-ups need no search; a task uses at most two searches and
  two loads.
- `use_skill`: loads one returned skill's instructions for the current task only.
- `rate_skill`: optional after the task, says how a followed skill did.
- `report_issue`: reports a bug or idea about Edge itself.
- `scan_skill`: shows the security audits Edge holds for a catalog skill, or
  scans a skill installed on this machine, offline.
- `benchmark`: compares candidate skills on your own tasks, only when you ask
  and after you approve the plan (not available in the Claude app).
- `feedback`: deprecated alias of `report_issue`, kept so older setups keep
  working.

Installed skills are not read or sent unless you opt in. With a Pro key, the
first search that could use them asks once, and the answer is no unless you
say yes.

## First tasks

Once Edge shows as connected (its tools are listed in a new session), these
three starter tasks are a good first use. Each starts by asking for your own
input. They are also at https://getedge.cc/first-tasks.

1. Use Edge to find a sales-enablement skill. Turn these product and competitor notes into a sales battlecard with buyer objections, responses and proof gaps. Ask me for the notes first.
2. Use Edge to find a data-storytelling skill. Turn my monthly revenue CSV into a short decision brief with a clear chart, the main trend and its limits. Ask me for the CSV first.
3. Use Edge to find a pricing skill. Review my current pricing tiers against our customer segments. Suggest clearer packaging and list assumptions to validate. Ask for the tiers and segments first.
