---
name: edge
version: 0.6.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, the Claude app and ChatGPT, the Free
  and Pro plans, what data it sends, and how to remove it.
---

# Edge setup guide

Edge is an MCP server that finds a public agent skill for a task. It is published by getedgehq as the MIT-licensed npm package `@getedge/mcp` (getedge.cc; not the Microsoft Edge browser).
On Claude Code, setup adds one `edge` MCP entry, a local prompt hook, one marked line in `~/.claude/CLAUDE.md` and up to 30 `edge-*` skill folders in `~/.claude/skills`; `npx -y @getedge/mcp@0.6.34 setup claude --remove` undoes all of it.

Setup on Claude Code with Node.js 20+ and npx (Free plan, no key, no questions):

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

Setup ends with the user's next steps: restart, then a first task to send
in the new session. Other routes and clients are below; every change has a
removal command in "Remove".

Each search sends a task description (up to 300 characters), optional keywords and connection metadata, but not file contents or conversation history; see "Data" for the full details.

**In the Claude app (claude.ai, desktop or mobile), setup has nothing to
run.** The user adds Edge as a connector themselves: Settings > Connectors >
Add custom connector, name `Edge`, URL `https://getedge.cc/mcp`, then Add, and
a new chat. Free plan, no key, nothing installed on their computer, and nothing
is added until they confirm. Links to that dialog lose their settings when
shown in a chat, so the steps work better than a link. On a Team or Enterprise plan an
Owner adds connectors, in Admin settings > Connectors.
Second step, also done by the user: in Claude Settings > Instructions for
Claude, paste this one line, so Claude checks Edge before specialist work
(without it, Claude rarely calls Edge on its own):
`Before specialist work, call Edge's find_skill.`
Claude does not save that line itself.
**In ChatGPT on the web (chatgpt.com), setup has nothing to run either.**
The user adds Edge themselves, in four steps:
1. Open chatgpt.com/plugins, then Add > Add custom MCP server.
2. Name `Edge`, Description `Finds expert skills for a task`, URL
   `https://getedge.cc/mcp`, Authentication "No authentication".
3. Tick "I understand and want to continue", click "Create as a plugin",
   then "Connect Edge".
4. In a new chat, click + in the message box, scroll down the list and
   pick Edge.
Pro: in step 2 use the name `Edge Pro`, the URL `https://getedge.cc/mcp/pro`
and Authentication "OAuth"; after Create, ChatGPT opens a getedge.cc page
where the user clicks Allow (a browser not yet signed in to Edge asks for the
key once, on getedge.cc; the key never goes into ChatGPT). Custom MCP servers may be unavailable on some
ChatGPT plans or workspaces; then Codex (below) is the route.
The rest of this guide is for Claude Code, Codex and Cursor.

This file is a setup guide, not a skill to install;
`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@0.6.34 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:** free for now, then $25 per month, no card
  (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

The Free plan needs no key, so it is the default: setup without a key
installs 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.

Ranking installed skills is off by default, so it needs no answer before
setup: run `setup claude` without `--local-skills`; setup asks nothing. On
the npm connector, Edge asks one question in chat, once, the first time a
search could use your installed skills, 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@0.6.34 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@0.6.34
npx -y @getedge/mcp@0.6.34 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.

**Hosted Edge without the plugin**, with any Node.js or none: one command
adds the hosted connector over HTTP, and nothing is installed or downloaded.

```bash
claude mcp add --transport http -s user edge https://getedge.cc/mcp
```

Pro: add `--header "Authorization: Bearer edge_YOUR_KEY"` to that command.
This route adds no prompt hook and no instruction line, and the hosted
connector cannot rank your installed skills. Edge's `health` tool reports
`auth: pro` when the key is accepted.

**Edge already connected through the Claude account.** Claude Code also
loads the connectors added in the Claude app, listed as `claude.ai Edge` in
`claude mcp list`. Run `setup claude` anyway, as above: that connector brings
no prompt hook and no instruction line, and without them Claude Code rarely
calls Edge on its own. If the entry is listed but failing, setup warns about
the stale entry.

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.

Setup's output ends with "Next steps for you": restart Claude Code (quit it
and open a new session, since Edge's tools load when a session starts),
then a first task picked on this machine. The first task is a prompt that
carries its own sample text, so it is long by design; it is how the user
sees Edge work for the first time, and the user has no other copy of it.

## First-run message

After setup in Claude Code, a summary for the user looks like this, with the
first task from setup's output in step 2, and "Pro" instead of "Free, no
account" on the Pro plan:

````markdown
**✅ Edge is ready**

1. **Restart Claude Code**: quit it and open a new session, since Edge's tools load when a session starts
2. **Then ask:**
   ```
   <the first task from setup's output>
   ```
3. **Look for `🧠 Edge ·`** at the start of the answer. It names the expert skill Edge found and Claude loaded, plus a supporting fact.

Free, no account · Added: Edge connector, local prompt hook, 1 line in `~/.claude/CLAUDE.md`, Edge skills in `~/.claude/skills`

Undo setup: `npx -y @getedge/mcp setup claude --remove`
````

If setup printed none (plugin and hosted routes), step 2 is:

```
Use Edge to find a skill for a weekly task and run it on one real example. Ask me for both first.
```

## Codex and the ChatGPT desktop app

Both read `~/.codex/config.toml`. With Node.js 20 or newer and npx, one
command does it:

```bash
npx -y @getedge/mcp@0.6.34 setup codex
```

It writes the Edge entry with direct tools, the startup-wait line below and
a package warm-up, keeping other settings. Pro: then add
`EDGE_KEY = "edge_YOUR_KEY"` to its `[mcp_servers.edge.env]` table.

**By hand**, this block goes in that file as shown (Free):

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

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 (Codex 0.160 and later otherwise also hide them behind code
mode). 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. `setup codex` ends with
the same "Next steps for you": restart, then a first task.

## 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: add a second connector with
  the URL `https://getedge.cc/mcp/pro`, then click Connect: a getedge.cc page asks for the key once, and Claude
  gets a revocable token. Or keep `https://getedge.cc/mcp` and add the header
  `Authorization: Bearer edge_YOUR_KEY` under "Add header" in the same dialog.
  Never put the key in the URL or in a chat.

## Claude app: the instruction line

The second Claude app step. Paste this line into Claude Settings >
Instructions for Claude yourself, so Claude reaches for Edge on specialist
work. 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@0.6.34 setup claude --ref CODE`, and Codex
`npx -y @getedge/mcp@0.6.34 setup codex --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@0.6.34 setup claude --remove` (the
instruction line), `claude plugin uninstall edge@getedge`, then
`claude plugin marketplace remove getedge`.

Hosted connector added with `claude mcp add --transport http`:
`claude mcp remove edge -s user`.

npm connector: `npx -y @getedge/mcp@0.6.34 setup claude --remove` (Claude Code: the
connector, the hook and the instruction line, in one command; Codex:
`npx -y @getedge/mcp@0.6.34 setup codex --remove` or `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.