---
name: connect-innernet
title: connect innernet to this ai
kind: skill
version: 1.0.0
description: >
  connect the person's innernet memory to the ai reading this, over MCP. a coding agent
  wires itself in with one command or one config entry; a chat app is walked through its
  own settings one step at a time. then prove it with one call.
when_to_load: >
  when someone pastes this link and asks you to connect innernet, their memory, to you.
authored_by: innernet
author_url: https://innernet.live
updated: 2026-10-21
schema: https://innernet.live/connect/ai.json
---

# connect innernet to this ai

you are helping someone connect innernet to the ai they are talking to, which is you. innernet is their one memory across every ai tool (innernet.live): their projects, their decisions, what they like and how they work. it is a remote MCP server, and it signs in with their browser the first time, so there is no key and no password anywhere in this.

**the server:** `https://innernet.live/api/mcp`

if the message they pasted carries a link of its own, use that one: it is the same server, and it lets their connections page name this connection the moment it calls.

## first, find yourself

you know which app or agent you are. find it below. if you truly cannot tell, ask one question: "which app is this, and on which device?". keep the rest of the conversation short: one step at a time, in plain words, no lectures.

- **you can run commands or edit files** (Claude Code, Codex, Gemini CLI, VS Code with Copilot, Cursor, Windsurf, Antigravity, Continue): do it yourself, under **you can do it yourself**.
- **you are a chat app** (Claude on the web, the desktop or the phone, ChatGPT, Notion, Zed, Cline, anything else): you cannot add a connector for them. walk them through their own settings, under **walk them through it**.
- **this app cannot hold an MCP server** (the Gemini app, Grok, Perplexity, Meta AI, Microsoft Copilot, DeepSeek): say so plainly, in one line, and offer what is under **when there is no place for it**.

on a phone, a connector is added on the web (claude.ai, chatgpt.com) once, and the phone app has it from then on.

## you can do it yourself

tell them in one line what you are about to do, then do it. the command or the file below wires only you. their browser opens to sign in to innernet; they sign in there (or make an account), and come back.

if they would like every ai on this machine connected at once, `npx -y innernet connect` signs in once and wires all of them (and asks before it connects the folder you are in to a memory). it waits for the browser sign-in, so run it where they can see it.

### Claude Code
you can do this yourself.
run:
```
claude mcp add --transport http --scope user innernet https://innernet.live/api/mcp
```
then: in Claude Code, type /mcp, choose innernet and sign in with the browser. new tools load in a new session.
if you cannot, give them these steps instead: open a terminal · run the command below. it signs you in and wires every tool it finds
the command:
```
npx innernet connect
```
so it stops asking every time: type /permissions in Claude Code, then choose Allow and add mcp__innernet__*.
the standing instruction goes in: your project's CLAUDE.md.

### Cursor
you can do this yourself.
add innernet to `~/.cursor/mcp.json` (merge it under the existing key; create the file if it is not there):
```
{
  "mcpServers": {
    "innernet": {
      "url": "https://innernet.live/api/mcp"
    }
  }
}
```
then: in Cursor, open Settings → Tools & MCP, find innernet and press the sign in button beside it.
if you cannot, give them these steps instead: press "open in Cursor" · press Install · sign in when your browser opens
one press, if they are on that machine: cursor://anysphere.cursor-deeplink/mcp/install?name=innernet&config=eyJ1cmwiOiJodHRwczovL2lubmVybmV0LmxpdmUvYXBpL21jcCJ9
so it stops asking every time: in Cursor, open Settings → Agents, then turn on auto-run for MCP tools.
the standing instruction goes in: your project rules (.cursor/rules).

### VS Code
you can do this yourself.
run:
```
code --add-mcp '{"name":"innernet","type":"http","url":"https://innernet.live/api/mcp"}'
```
then: VS Code asks to sign in the first time a tool runs. say yes and sign in with the browser.
if you cannot, give them these steps instead: press "open in VS Code" · press Install · sign in when your browser opens
one press, if they are on that machine: vscode:mcp/install?%7B%22name%22%3A%22innernet%22%2C%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Finnernet.live%2Fapi%2Fmcp%22%7D
so it stops asking every time: when Copilot asks before a tool call, choose "always allow".
the standing instruction goes in: your .github/copilot-instructions.md.

### Continue
you can do this yourself.
add innernet to `~/.continue/config.yaml` (merge it under the existing key; create the file if it is not there):
```
mcpServers:
  - name: innernet
    type: streamable-http
    url: https://innernet.live/api/mcp
```
then: reload Continue and sign in with the browser when it asks.
if you cannot, give them these steps instead: open ~/.continue/config.yaml · add the block below. if mcpServers is already there, add the item under it · reload Continue and sign in when your browser opens
the standing instruction goes in: your Continue system message.

### Windsurf
you can do this yourself.
add innernet to `~/.codeium/windsurf/mcp_config.json` (merge it under the existing key; create the file if it is not there):
```
{
  "mcpServers": {
    "innernet": {
      "serverUrl": "https://innernet.live/api/mcp"
    }
  }
}
```
then: in Cascade, refresh the MCP list and sign in with the browser when it asks.
if you cannot, give them these steps instead: in Cascade, open the … menu → MCPs → Open MCP config file · add the block below under mcpServers and save · sign in when your browser opens
the standing instruction goes in: your Windsurf rules.

### Antigravity
you can do this yourself.
add innernet to `~/.gemini/config/mcp_config.json` (merge it under the existing key; create the file if it is not there):
```
{
  "mcpServers": {
    "innernet": {
      "serverUrl": "https://innernet.live/api/mcp"
    }
  }
}
```
then: in the agent panel, open … → MCP Servers, refresh, and sign in with the browser when it asks.
if you cannot, give them these steps instead: in the agent panel, open … → MCP Servers → Manage MCP Servers · press View raw config, add the block below under mcpServers, and save · sign in when your browser opens
the standing instruction goes in: your agent instructions.

### Gemini CLI
you can do this yourself.
run:
```
gemini mcp add --transport http --scope user innernet https://innernet.live/api/mcp
```
then: restart gemini, run /mcp auth innernet and sign in with the browser.
if you cannot, give them these steps instead: open ~/.gemini/settings.json · add the block below under mcpServers · restart gemini, run /mcp auth innernet, and sign in
the block:
```
{
  "mcpServers": {
    "innernet": {
      "httpUrl": "https://innernet.live/api/mcp"
    }
  }
}
```
the standing instruction goes in: your GEMINI.md.

### Codex
you can do this yourself.
run:
```
codex mcp add innernet --url https://innernet.live/api/mcp
codex mcp login innernet
```
then: the login command opens the browser to sign in. restart codex so the tools load.
if you cannot, give them these steps instead: open a terminal · add the block below to ~/.codex/config.toml · run codex mcp login innernet and sign in
the block:
```
[mcp_servers.innernet]
url = "https://innernet.live/api/mcp"
```
the standing instruction goes in: your AGENTS.md.

## walk them through it

you cannot open their settings, so be their eyes: one step per message, the exact words of the button to press, and the link exactly as given. when a step does not match what they see (apps move their menus), ask what they see and adapt; never invent a menu.

if their app offers to add a connector from its own directory right here in the chat, and innernet is listed there, offer that first: it is the shortest way.

### Claude Desktop
walk them through it. one step per message, wait for "done" before the next.
1. in Claude, open Customize → Connectors and press Add
2. name it innernet, paste this link, press Continue
3. press Connect, then allow access in the tab that opens
it goes in: Customize → Connectors → Add custom connector → Remote MCP server URL
the link they paste: https://innernet.live/api/mcp
so it stops asking every time: open Customize → Connectors → innernet, then set both tool groups to Always allow.
the standing instruction goes in: Settings → General → Instructions for Claude.

### ChatGPT
walk them through it. one step per message, wait for "done" before the next.
1. turn on Developer mode in Settings → Security and login
2. open chatgpt.com/plugins and press +
3. name it innernet, paste this link, tick "I understand", press Create
4. type @innernet in a chat and allow access
it goes in: chatgpt.com/plugins → + → Connection
the link they paste: https://innernet.live/api/mcp
so it stops asking every time: when ChatGPT asks before a write, choose "remember for this conversation".
the standing instruction goes in: Settings → Personalization → Custom instructions.

### Cline
walk them through it. one step per message, wait for "done" before the next.
1. open MCP Servers → Remote Servers
2. name it innernet and paste this link
3. set the transport to Streamable HTTP and press Add Server
4. sign in when your browser opens
it goes in: MCP Servers → Remote Servers → Server URL
the link they paste: https://innernet.live/api/mcp
the standing instruction goes in: your Cline custom instructions.

### Zed
walk them through it. one step per message, wait for "done" before the next.
1. open Settings → AI → MCP Servers → Add Server → Add Remote Server
2. name it innernet and paste this link
3. sign in when your browser opens
it goes in: Add Remote Server → url (settings.json context_servers)
the link they paste: https://innernet.live/api/mcp
the standing instruction goes in: your Zed assistant rules.

### Notion
walk them through it. one step per message, wait for "done" before the next.
1. open a custom agent's settings → Tools & Access
2. press Add connection → Custom MCP server and paste this link
3. sign in when your browser opens
it goes in: custom agent → Tools & Access → Custom MCP server
the link they paste: https://innernet.live/api/mcp
the standing instruction goes in: Notion AI's custom instructions.

### any other MCP client
walk them through it. one step per message, wait for "done" before the next.
1. open your tool's MCP settings
2. add a remote server and paste this link
3. sign in when your browser opens
the link they paste: https://innernet.live/api/mcp
the standing instruction goes in: your tool's standing instructions.

## prove it works

as soon as innernet's tools are in your list, call `innernet_list_projects`, then tell the person, in a line, what you can see: their projects by name, or that the memory is new and empty. that first call is also what makes the connection show up as live on their connections page.

a chat app usually loads a new connector in a new chat. if the tools are not in your list yet, ask them to open a new chat here and say: "innernet, what do you know about me?"

## so it keeps working

innernet is most useful when the ai reaches for it on its own. offer, once, to keep this standing instruction where the tool reads one (each tool above says where).

- a coding agent: offer to add it to the file the tool reads (AGENTS.md, CLAUDE.md, GEMINI.md, the rules file). ask before you write.
- a chat app: give them the text to paste into the place named above.

```
innernet is connected to this chat as an MCP server — my versioned memory across every AI tool (innernet.live). When a conversation touches a project innernet tracks (its product, strategy, roadmap, brand, design, code, or past decisions), call innernet_load_project before answering — innernet_list_projects finds the slug — and follow the returned capture_protocol. When work produces a decision or insight worth keeping, save it back with innernet_save_context.

When you learn something durable about me (a preference, a tool I rely on, a person in my life, how or when I work, a standing instruction), call innernet_self_capture at that moment, quietly. What you send is kept as your note, not my words: write it in your own voice, name who did what, never write your work or suggestion as mine, and pass my exact words in user_words whenever the note is about something I said, decided or prefer. When several captures pile up, call innernet_self_sync to fold them into facts. When personalising tone, defaults, or assumptions would help, read innernet_self_facts. Surface a relevant memory when it helps, and flag anything that looks stale or contradicted instead of asserting it.

When you save, write the present: if what you save supersedes something a dimension states, replace it in the body (never leave old and new side by side) and add one dated line under a "## history" heading at the end of that dimension — "- YYYY-MM-DD — <what changed>: was … → now …".

Keep all of this quiet and ambient — don't narrate the bookkeeping unless I ask.
```

## when there is no place for it

- the innernet browser extension carries the memory into the chat sites it knows (ChatGPT, Claude, Gemini) from Chrome, Edge, Brave, Arc, Opera, Vivaldi, Firefox and Safari: https://innernet.live/connect/extension
- or connect a coding agent on the same machine (Claude Code, Codex, Gemini CLI, Cursor), which reads the same memory

## never

- never ask for a password, a code from an email, or an api key. the sign-in happens in their browser, on innernet.live.
- never remove or rewrite other servers in a config file. add innernet beside them.
- never press a confirm or allow button for them in a settings page. they press it.
- never invent a menu that is not there. if a step does not match what they see, ask what they see and adapt.

the same facts, as a schema: https://innernet.live/connect/ai.json