# Set up Emm AI — a guide for your AI assistant *Last verified: 2026-06-24* **Emm AI** is mission control for your AI agents — standing instructions, personal memory, an output wiki, and recurring agent runs, all reached over the Model Context Protocol (MCP). This page is written for **an AI assistant to read and walk a human through setup, step by step.** If you're a person reading it directly, you can follow it too — but the easiest path is to paste this into your AI: *"Help me set up Emm using "*. You can come back and ask your AI to "finish setting up Emm" at any time — this guide is safe to run repeatedly and will only do whatever is still missing. --- ## HOW TO USE THIS GUIDE (read this first, AI assistant) **You are the assistant the user wants to connect to Emm.** These steps connect *you* — the AI reading this, running in whatever app the user is talking to you in. (Only if the user explicitly says they want to set up a *different* app do the same steps apply over there instead; otherwise assume they mean you.) Work through the steps in order. Keep each turn short; do one step, confirm it worked, then move on. **1. Check what you can do.** Before you start, note your own capabilities — they change how you help: - *Do you have a command or tool for adding MCP servers / connectors?* — for example Claude Code's `/mcp`, running `claude mcp add …`, or editing an MCP config file you can access. If so, you can make the connection yourself in Step 2 instead of asking the user to click through settings. - *Can you call tools?* Then you can verify the connection yourself by calling Emm's `status()` tool once it's connected. - *Can you browse the web?* Then you can open the official documentation links in this guide to get the exact, current UI steps for your app. - *Can you see the user's screen?* Almost certainly **no** — so don't claim a screen "matches"; instead ask the user to tell you what they see and adapt. **2. Verify by outcome, not by matching these words.** App menus change. Don't get stuck because a label here doesn't match what the user sees. Each required step below ends with a concrete **success check** — confirm *that*, and the exact clicks don't matter. **3. Trust order when things disagree:** the user's live screen > the official documentation link for their app > this guide. If this guide contradicts what the user sees, say so, follow the screen and the official docs, and let the user know this guide may be out of date (they can report it to ). **4. The server facts are authoritative; the app UI steps are approximate.** These never change and you can rely on them: - MCP server URL: **`https://ai.actingweb.io/mcp`** - Transport: **Streamable HTTP** (never pick "SSE" — it's deprecated) - Auth: **OAuth — leave any "Client ID / Client Secret" fields blank.** The server registers your client automatically (Dynamic Client Registration); a browser sign-in window is all that's needed. - Sign-in identities: **Google, GitHub, or Apple.** **5. This guide is resumable and safe to re-run — take stock before doing anything.** The user may already be partway done, or may be pointing you here a second time to mop up leftovers. So start every time by assessing the current state across *all* steps, not from the top: - If you can, call **`status()`** (and `how_to_use()`). A successful response means Steps 1–3 are already done — and it tells you the account identity, which pillars are enabled, and recent run history. If Emm tools aren't available to you yet, the user most likely still needs Steps 1–2. - Then give the user a short checklist of what's already done vs. what's still missing, and **do only the missing parts.** Every step is idempotent: re-running one when it's already complete changes nothing. Never restart from scratch and never undo existing setup. --- ## STEP 1 — Sign up (required) **Already done?** Ask: "Do you already have an Emm account — can you open a page at `https://ai.actingweb.io` and reach your dashboard?" If yes, skip to Step 2. 1. Tell the user to open **** and click **Log in / Sign up**. 2. They sign in with **Google, GitHub, or Apple**. There is **no separate account-creation form and no credit card** — the first sign-in creates the account and starts a **free 1-month full-access trial**. 3. After signing in they land on their **dashboard**. **Success check:** the user is signed in and looking at their Emm dashboard (a URL ending in `/app`). --- ## STEP 2 — Connect yourself to Emm (required — this is the key step) This connects **you** — the assistant reading this — to Emm, so you gain Emm's tools. Use the block below for **the app you are running in**. The universal facts from "HOW TO USE THIS GUIDE" point 4 apply everywhere: URL `https://ai.actingweb.io/mcp`, Streamable HTTP, OAuth, leave Client ID/Secret blank. **Already done?** If Emm tools already appear in your tool list (e.g. something like `memory_search`, or a server the user named "Emm"), call `status()` to confirm and skip to Step 3. **Can you do it yourself?** If you have an internal command or tool for managing MCP servers/connectors (e.g. `/mcp`, `claude mcp add …`, or an MCP config file you can edit), use it now with the values above — don't make the user click through settings. They'll still complete the browser sign-in, and your new Emm tools may appear only after you re-initialize or the user starts a fresh session. If you can't add connectors yourself, walk the user through their app's settings using the block below. ### Claude (claude.ai web, or the Claude desktop app) 1. Open **Settings → Connectors** (you may find it under "Customize"). Direct link: `https://claude.ai/customize/connectors`. 2. **Add custom connector** → name it (most people type *Emm*) → paste the URL `https://ai.actingweb.io/mcp` → leave Advanced / Client ID blank → **Add**. 3. Click **Connect** and sign in when the browser window opens. 4. **Enable Emm and set its tools to "Always Allow."** New connectors often surface only in a **fresh chat** — start one if Emm's tools aren't listed. In **Settings → Connectors → Emm**, Claude splits the tools into two groups — **read tools** and **write/delete tools** — each defaulting to *Ask*. For Emm to be fully functional — agent runs, saving memories and standing instructions, all without a permission prompt on every call — set **both groups to *Always Allow***. (You can leave them on *Ask* to approve each write yourself, but you'll be prompted often, and a mid-task prompt can stall an agent run.) - *Notes:* the free plan allows one custom connector. On Team/Enterprise an admin adds it once, then members connect. Mobile apps can *use* a connector but adding one is best done on web/desktop. - *Official docs:* ### Claude Code (CLI) and Claude Workspace Add the MCP connection by hand, then authenticate: ``` claude mcp add --transport http emm https://ai.actingweb.io/mcp --scope user ``` Run `/mcp` inside a session, or `claude mcp login emm` (`--no-browser` over SSH), to complete the OAuth sign-in. When Claude Code first calls an Emm tool, **allow it** — use `/permissions` to pre-allow the `emm` server so writes and agent runs aren't blocked. > The **Emm plugin** is *not* a connection method — treat it like the skill (see > Step 4). It bundles the skill and the `/emm:*` slash commands, and although it > ships an MCP server definition, **installing it doesn't connect or authenticate > you on its own** — you still add and authenticate the connection as above. So > the plugin layers *on top of* this connection; it doesn't replace this step. - *Official docs:* and ### ChatGPT (web) ChatGPT adds custom MCP connectors through **Developer mode**, currently a **beta** feature and **plan-gated** — *and OpenAI's own pages disagree about exactly which plans get full read/write.* So have the user check their live Settings; don't promise a specific plan rule. (Pro and Business/Enterprise/Edu can add custom connectors; Plus is ambiguous across OpenAI's own docs; Free can't. Web only — not the mobile apps.) 1. **Settings → Apps & Connectors → Advanced settings → enable Developer mode.** (The section reads **"Apps & Connectors"** in current accounts; some still show just **"Connectors."** This is *not* "GPT Actions.") 2. **Create** a connector → name + URL `https://ai.actingweb.io/mcp` → choose **OAuth** → create, then authorize in the browser. Leave Client ID/Secret blank — ChatGPT registers the client itself. *If the Client ID field insists it's required, that's a known ChatGPT beta quirk;* retry, or paste any value the live UI will accept. 3. **Enable the connector and approve its tools.** Turn the Emm connector on for your conversation, then approve Emm's actions when prompted — write actions ask for confirmation each time unless allowed. New tools may appear only after you start a fresh chat. 4. **On a Business / Enterprise / Edu workspace this is admin-gated.** A regular member usually **cannot add a custom connector — or set tool permissions — themselves**: a workspace **admin** must first enable Developer mode (and, on Enterprise/Edu, grant access via RBAC), and **tool approval is controlled at the workspace level by the admin**, not per member. **If Developer mode is greyed out or missing, that's why** — have the workspace admin enable it. (On an individual **Pro** account you control this yourself.) 5. If you can't enable Developer mode or write actions stay blocked, fall back to the **Custom Instructions** option in Step 4. - *Official docs:* and (read both; they differ — trust the user's live Settings). ### ChatGPT Codex (CLI) Add to `~/.codex/config.toml`: ```toml [mcp_servers.emm] url = "https://ai.actingweb.io/mcp" ``` Then `codex mcp login emm`. If tools don't appear, check `codex --version` and try enabling `[features].rmcp_client = true` (HTTP MCP has had known bugs). - *Official docs:* ### Other apps (Gemini CLI, GitHub Copilot, Cursor, Windsurf, Zed, Perplexity, Mistral Le Chat, OpenClaw, …) Most modern MCP clients support remote OAuth servers. The pattern is always the same: find where the app adds an MCP server (a settings panel or a JSON config file), enter the URL `https://ai.actingweb.io/mcp` as a **Streamable HTTP** server, complete the browser OAuth sign-in, and leave any client-credential fields blank. Field names vary (`url`, `httpUrl`, `serverUrl`). If you can browse the web, look up your own app's official MCP docs for the exact steps. - **Enable + approve the tools.** Almost every client asks you to approve a tool the first time it runs (and many need the connector toggled on for the conversation). Allow Emm's tools — choose *always allow* where offered — so calls aren't blocked, and start a fresh chat if the tools don't appear yet. - **Perplexity** needs Pro/Max; **Mistral Le Chat** works on all plans; the **consumer Gemini app is not supported** (only Gemini Enterprise) — use Custom Instructions instead. - **If the app can't do remote OAuth in its UI** (e.g. Cline, Roo Code, some builds of Cursor/Zed/Goose), use the bridge: `npx mcp-remote https://ai.actingweb.io/mcp` — it handles OAuth and exposes Emm as a local server the app can use. **Success check:** call **`status()`** yourself — a successful response means you're connected. If your Emm tools haven't appeared yet, the connection often finalizes only after the browser sign-in completes and the session re-initializes — ask the user to start a fresh chat with you, then call `status()` again. (If the user was instead setting up a different app, have them confirm Emm tools appear there.) --- ## STEP 3 — Confirm it works (required, ~30 seconds) **Already done?** If `status()` already returned successfully in Step 2, this is done — call `how_to_use()` once for a personalized tour of what Emm can do, then **continue to Steps 4 and 5**. Even an already-connected account isn't *useful* until it's personalized, so don't stop at "connected" and report success: keep going and offer the next steps as concrete actions. To confirm end-to-end, try a real request yourself — answer this for the user: > **What is known about my preferences from Emm?** A brand-new account has little stored yet, so the right outcome is that you **reach Emm without error** (you may find "nothing saved yet"). If you can't call tools in this session yet, ask the user to start a fresh chat so your new Emm tools load, then run it. **Success check:** you retrieved an answer from Emm (even an empty one) rather than erroring. **The connection works now** — but Emm isn't *useful* until you do Steps 4 and 5. They're recommended, not throwaway: Step 4 (install the skill) and Step 5 (personalize) are what make every later session actually pay off. Continue into them rather than signing off here. --- ## STEP 4 — Install the Emm skill (recommended) > **Assistant: present this as recommended, not as an optional aside to skip.** > Don't relay it as "teach me about Emm" — the user hears "me" as *themselves* > and skips it. Frame it as a quick, worthwhile action for *them* to do: install > the skill so you (the assistant) use Emm well. The skill is what makes you reliably know *when* to search Emm, *how* to save memories, and which tools exist — without the user re-explaining every session. It only takes a minute and noticeably improves every later interaction, so it's worth doing now even though setup technically works without it. **Already installed the plugin?** If you installed the Emm plugin (Claude Code / Workspace), its skill and slash commands already cover this step — skip ahead to Step 5. (The plugin doesn't connect you; you still did the Step 2 connection.) Pick the best option for the app you're running in: - **Skill (most powerful — Claude web/desktop, ChatGPT Codex, OpenClaw):** download `https://ai.actingweb.io/static/downloads/working-with-emm-skill.zip`. In **Claude (web or desktop)**, upload that **.zip file as-is** — do *not* unzip it — at Settings → Capabilities → Skills → Upload (Claude also needs "Code execution and file creation" enabled first). For file-based clients (**ChatGPT Codex**, **OpenClaw**), unzip it and copy the `working-with-emm` folder into the app's skills directory. - **Plugin (Claude Code & Workspace):** the skill **plus** the `/emm:*` slash commands. Like the skill, it's an enhancement layered on the Step 2 connection — it ships an MCP definition but doesn't connect you on its own, so it's a peer of the skill here, not a shortcut past Step 2. Download `https://ai.actingweb.io/static/downloads/emm-plugin.zip`. - **Custom instructions (any app — essential for ChatGPT web, Gemini, Grok):** give the user this **exact** text to paste into the app's custom-instructions / personalization field (hand it over verbatim — don't paraphrase or shorten it): > Before answering, search my Emm memories (via MCP) for personal context, > preferences, and past decisions, and check my Emm standing instructions and > output wiki when relevant. During our conversation, offer to save or update > memories when durable new information comes up. See the skill or how_to_use() > tool for the full list of tools and categories. If a skill is installed, it tells the AI to call `status()` first and compares its version against the server — if the server reports a newer skill version, suggest the user re-download. **Success check:** the app shows the skill/plugin installed, or the custom instructions are saved. --- ## STEP 5 — Personalize Emm (recommended) > **Assistant: offer this as a concrete action, don't just mention it.** Once the > connection is confirmed, proactively ask — e.g. *"Want me to set up your > standing instructions (who you are, your style, your recurring tasks) now?"* — > and walk the user through it interactively. Reporting "you're connected, you > could add custom instructions" and stopping there is the failure mode this step > exists to prevent. If the **instructions** pillar is enabled and you have the > `instruction_*` tools, drive the standing-instructions flow below; otherwise at > least offer to capture a few memories and point them at the Task Builder. **Why this matters — don't skip it.** An empty Emm changes nothing; every assistant still starts from zero. The payoff is in what's *stored*. Once Emm knows who the user is, their preferences, and their standing orders, every future session — with you or any other assistant they connect — starts already knowing their context: answers are tailored instead of generic, and the user stops repeating themselves. This is the step that turns Emm from "connected" into "actually useful." Two easy ways to start: - On the **dashboard**, open the **Task Builder** to capture who the user is and what they want help with. - Just talk to the user normally — when useful facts, preferences, or decisions come up, offer to save them to Emm's memory. ### Set up your standing instructions (recommended) Beyond memories, Emm holds a few **standing instruction documents** that an agent reads at the start of *every* run. Setting these up now is what makes future agent runs actually behave the way the user wants. The three worth doing first: - **`personal`** — who the user is: identity, role, key facts, how they want to be helped. - **`style`** — voice and tone: how the agent should write and format. - **`tasks`** — what the agent should *do* on a run: the list of recurring tasks. These are normally **read-only** over MCP. To change them, the user opens a short, deliberate unlock window called **Instructions-Update Mode** — a safety gate so an agent never silently rewrites the user's standing orders. Here's the interactive flow (only do this if `status()` shows the **instructions** pillar enabled and you have the `instruction_*` tools — otherwise skip this section): 1. **Ask the user to turn it on.** It's a toggle in the app: tell them to open their dashboard → **Settings** → enable **Instructions-Update Mode**. You cannot flip it yourself — it's deliberately a human action. Confirm it's on by calling `status()` and checking that `mode` is `instructions_update`. 2. **Do one document at a time** (`personal`, then `style`, then `tasks`). Use each document's **short name** — `personal`, `style`, `tasks` — *not* the `instruction_` storage form (`instruction_personal` is rejected). For each: call `instruction_load(name="")` (e.g. `instruction_load(name="personal")`) to see what's there, talk with the user about what to add or change, draft the new content, read it back for approval, then save it with `instruction_save(name="", content=...)`. Follow the live tool schema if the argument names differ. 3. **For `tasks`**, help the user describe the recurring jobs they want — e.g. "every morning, summarize my unread newsletters" or "check for anything I asked you to follow up on." Keep each task concrete. 4. **When done, tell the user they can turn Instructions-Update Mode back off** in Settings, so the documents are protected again. **This is the lever for the future, too:** whenever the user wants to change what an agent does on an agent run — or on a recurring/scheduled run (Step 6) — they re-open Instructions-Update Mode and edit these same documents. `tasks` controls *what runs*; `personal` and `style` shape *how* the agent behaves throughout. **Success check:** at least one memory or task exists, and (if you did the instructions flow) `personal`, `style`, and `tasks` reflect the user's input — re-load one with `instruction_load` to confirm the save took. --- ## STEP 6 — Put Emm on autopilot (optional) If the user wants Emm to run recurring work unattended (daily news, email triage, reminders), connected AIs that support scheduled runs can call `agent_run` on a schedule. The dashboard's **Autopilot** section has the current setup steps for scheduled runs in Claude and ChatGPT. This is for power users who've completed the steps above. --- ## If you get stuck - Connection fails or tools never appear → re-check the URL is exactly `https://ai.actingweb.io/mcp`, that the transport is **Streamable HTTP** (not SSE), and that Client ID/Secret were left blank. Try the `npx mcp-remote https://ai.actingweb.io/mcp` bridge. - The steps here don't match the app → follow the user's screen and the official docs linked above; this guide may be out of date. - Questions, or to report that these steps are out of date: ****