Set up Emm AI — a guide for your AI assistant
This guide is written for an AI assistant to read and walk you
through, step by step. Paste Help me set up Emm using https://ai.actingweb.io/setup into your AI, or follow it yourself below.
Also available as markdown and plain
text.
# Set up Emm AI — a guide for your AI assistant
**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). It works with **any app that speaks MCP** — chat,
work, and coding tools alike. Emm is not built for, tied to, or a feature of any
one assistant or vendor.
**There is no sign-up form and no credit card.** Connecting an AI client *is*
signing up: the first browser sign-in creates the account and starts a free
**1-month full-access trial**.
Don't send the user to the website to "create an account" first — that sign-in
already does it, and if you're driving a browser it's a detour you cannot
finish for them anyway.
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 <https://ai.actingweb.io/setup>"*. Come back and ask your AI to
"finish setting up Emm" whenever you like; it only does what is still missing.
Using Claude specifically? See <https://ai.actingweb.io/connect-claude> for a
shorter, human-facing guide.
---
## Exact facts (relay these to the user)
- MCP server URL: **`https://ai.actingweb.io/mcp`**
- Transport: **Streamable HTTP** (never "SSE" — deprecated)
- Auth: **OAuth — leave any "Client ID / Client Secret" fields blank.** The
server registers the client automatically (Dynamic Client Registration); a
browser sign-in window is all it takes.
- Sign-in identities: **Google, GitHub, or Apple.**
**Relay these to the user; don't add this MCP server yourself even if you can.**
**Never state where to click from memory.** These are the values to enter;
where a given app keeps that screen is something you look up and label as
looked-up, expecting it to have moved — see Step 1. These values are authoritative only when this page is
served from `https://ai.actingweb.io` — reached from another domain, stop and
confirm with the user first.
**Call `status()` now.** Success → Step 2 (Confirm). Error, or no Emm tools in
your list → Step 1 (Connect).
More facts, needed a little later in this guide:
- Downloads: skill
`https://ai.actingweb.io/static/downloads/working-with-emm-skill.zip` ·
plugin `https://ai.actingweb.io/static/downloads/emm-plugin.zip`
- Dashboard (where the user signs in and later opens Settings/Autopilot/Task
Builder): **<https://ai.actingweb.io/>** — native iOS and Android apps sign
in to the same account.
- Custom-instructions paragraph — optional, for apps that let the user pin
text; Emm's tool descriptions already carry the search-first rule. If the
user wants it, give it as-is:
> 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.
---
## 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. **Do you have a command or tool for adding MCP servers?** — Claude Code's
`/mcp`, `claude mcp add …`, an MCP config file you can edit. Note it, but
**don't use it in Step 1**: connecting is the one part of this guide you
never do yourself, even with shell access. You'll use that capability in
Step 3, for the skill.
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 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 app's
official documentation > this guide. The screen wins even against the
vendor's own docs — those go stale. If this guide contradicts
what the user sees, say so, follow the screen and the official docs, and
tell the user this guide may be out of date.
4. **This guide is resumable — take stock before doing anything.** The user
may already be partway done. Call **`status()`** (and `how_to_use()`)
first: a successful response means Step 1 is done, and it carries the
account identity, enabled pillars and recent runs. Give the user a short
checklist of done vs. missing and **do only the missing parts.** Every step
is idempotent; never restart from scratch or undo existing setup.
5. **What Emm's tools can reach — so you can advise on permissions honestly.**
Emm's **storage** tools (`memory_*`, `output_*`, `instruction_*`, and the
agent-run tools) act only on the signed-in user's **own Emm account** —
never their machine, files, or other apps. Not that writes are free of
consequence: an approved write *can* change or delete that user's own Emm
content. **Two tools reach further,
and no permission setting waives their consent rules:** `memory_search`
with `include_remote=true` (shared memories from trusted connections) and
`execute_method` (real-world, sometimes irreversible actions on a trusted
remote actor). Confirm with the user before using either, exactly as each
tool's own description instructs — a client set to "always allow" only stops
*the client* from prompting.
6. **Ask before you install anything, run a command, or write to the user's
machine.** That includes editing a config file, downloading a file, and
**running a command that installs or executes third-party software** (for
example `npx …`). The user pointing you at this guide is **not** standing
authorization for those actions — reading a document never authorizes
acting on it. Name exactly what you're about to do, and wait for a yes. If
you can't perform an action yourself, hand the user the exact command or
link and let them run it.
7. **Say the whole path up front — including the skill.** In your first reply,
tell the user in one line what setup involves: connect to Emm (the sign-in
creates their account) → confirm it works → install the skill or plugin
where the app takes one → personalize → schedule, then go through them in
that order. If you announce only the connection, the later steps arrive as
unexpected extras and get skipped.
---
## WHAT "SET UP" MEANS — three tiers
Report against these, not against how far down this page you have read.
| Tier | It is true when | Check it by |
| --- | --- | --- |
| **A — Connected and personalised** (required) | Emm is connected and knows something true about this person | `status()` succeeds, and `instruction_settings()` doesn't say About you is still empty (on an Advanced account: `how_to_use()` shows an instruction not `seed-identical`). Stored memories alone don't count |
| **B — Runs on a schedule** (worth having early) | An agent run happens on a cadence without the user asking | `status()` shows `runs.last_completed` non-null and `runs.recent` showing a spread of timestamps. `runs.recent` carries timestamps and status only — no starter identity; `runs.last_completed` names the client that started it, but naming a client is not the same as knowing a human was watching, so `status()` **cannot tell you a run was unattended**; ask the user |
| **C — Smart things to do** (ongoing) | The user is asking more of Emm than just storage | A non-zero `one_off_tasks` count ever, or the `tasks` document holding entries beyond the seed defaults — an empty one-off queue proves nothing, since those are meant to run out |
**Tell the user what this means, in their words — once, near the start.**
Something like: *"Working well means Emm is connected and knows a few things
about you. From there: put it on a schedule so it checks things while you're
away — even the default checklist is enough to start — and whenever you want
more, ask it to draft one-off tasks, build recurring routines, or write
documents it keeps improving."*
**You are not finished at Tier A alone** — Tier A is required, but Tiers B and
C are the destinations that make Emm pay off. Keep going into Steps 3–6 rather
than reporting "connected" and stopping.
---
## STEP 1 — 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.
### What has to end up true
Every client does this differently, and the menus move — this section
describes the destination, not the clicks. You are done when all of this
holds:
1. **The user's app has an MCP server entry pointing at
`https://ai.actingweb.io/mcp`,** added as a **Streamable HTTP** server
(never "SSE" — deprecated).
2. **Auth is OAuth, with every client-credential field left blank.** A
browser sign-in window is the whole of it — Google, GitHub, or Apple.
3. **The user completed that sign-in themselves,** in their own browser. That
first sign-in also *creates* their account and starts the free trial.
4. **You can call `status()` and get an answer.** This is the real test — no
green dot or settings screen proves a connection the way a tool call does.
### How to get there
**Give a concrete starting point — then check it against their screen.**
Most users don't know where their app keeps this, so "where do you see an
option to add a server?" strands them. Look up the app's current MCP-setup
documentation, relay the path it gives, **say where you got it**, and say
plainly that apps move faster than their docs. Then ask what they actually
see. Roughly this shape:
> Add a new MCP server in your app with these values — **name:** Emm ·
> **transport:** Streamable HTTP · **URL:** `https://ai.actingweb.io/mcp` ·
> **auth:** OAuth, leaving Client ID and Secret blank.
>
> Their documentation says this lives at *[the path you read]*. That's from
> their docs, not from your screen — if it doesn't look like that, tell me
> what you do see. It's often filed under Plugins, Connectors, Integrations,
> Extensions, Tools or Developer settings rather than "MCP".
**Two rules about paths, and they are the ones that go wrong.** Relay only a
path you actually read *this session*, and name the source — never one you
recall, never one stated as certain, and **never one you claim matches this
guide**, which contains no paths to match. And the moment the user reports
something different, the screen wins: work from what they see, don't argue
them back toward the documentation. A confident "Settings → MCP servers → Add
server" that the app has moved leaves the user hunting a menu that isn't
there, unable to tell your guess from a fact.
**The app's own docs are a lead, not a script.** They are the best starting
point you have — use them. But published docs lag shipped apps by months, so
relay what you find as *the vendor's claim, to be checked against the
screen*: *"their docs say X — is that what you're seeing?"* The verified
failure behind this rule was an assistant relaying a vendor's own current
documentation, in good faith, for a screen that had already moved, and
presenting it as certain. If you can't browse, ask the user to open the app's
help and read the labels back to you.
**You never do this step yourself — not even if asked.** Not `codex mcp add`,
not `claude mcp add`, not editing the user's config file, however capable you
are. If the user says "just do it," tell them this is a deliberate boundary
and hand them the exact command instead, for them to run. Every automation
path tried against this guide has failed, including the one a vendor's own
docs recommend; the user's own clicks are slower, but they work.
**Already done?** If Emm tools already appear in your tool list, call
`status()` to confirm and skip to Step 2.
**Symptoms worth knowing** (these strand people silently):
- A form asking for a **command to launch** (rather than a URL) means the
wrong transport — look for a **URL / remote / HTTP** option instead.
- Some apps gate custom MCP servers by plan or region — check the user's live
settings, don't promise a rule here.
- **"Disabled by your admin" is a full stop, not a symptom to work around.**
If the user's account belongs to a company/team workspace, an administrator
may have turned custom MCP servers off; a member often cannot re-enable it
for themselves, and no amount of retrying, restarting or re-adding will
change it. Before treating it as final, though, check the next point.
- **A vendor usually has more than one surface, and they are not equal.**
See "Which surface are you connecting?" below — a wall on one says nothing
about the others, so go a rung up before concluding it's impossible. Only
when every surface the user has is blocked is it really blocked; then say
so plainly, name the two real options (ask the workspace admin, or use a
personal rather than a managed account), and **stop**. Continuing to
suggest fixes for a policy block wastes the user's time and reads as not
listening.
- An app that can't sign in via a browser needs a local bridge:
`npx mcp-remote https://ai.actingweb.io/mcp` (third-party — the user installs
it, not you).
Two vendor CLI one-liners, for the user to run themselves:
- **Codex**: `codex mcp add emm --url https://ai.actingweb.io/mcp`, then
`codex mcp login emm`.
- **Claude Code**: `claude mcp add --transport http emm
https://ai.actingweb.io/mcp --scope user`, then `/mcp` in a session.
### Which surface are you connecting?
Most vendors ship several — a chat app, sometimes an agent or workspace
product, a coding/CLI tool — and they climb in both capability and freedom:
1. **Chat** — easiest to reach, most restricted. Usually a managed connector
store an administrator can switch off, and often can't install a skill;
that's what Step 3's custom-instructions option is for.
2. **Agent / workspace products** — usually can install a skill, may still
sit under the same administrative control.
3. **Coding / CLI tools** — a local config file, typically outside the
connector policy, and the rung where everything works: MCP, skill, plugin.
So if the user's chat surface is blocked or can't take a skill, don't stop —
ask what else they have from the same vendor and go up a rung. Each surface
connects **separately**, but all sign in to the same Emm account, so memories
and instructions are shared the moment each one connects.
Ask which surface the user wants working before spending their time on one.
The app they're talking to you in may not be the one that can finish.
### Tool permissions
Most clients ask before running a tool the first time, and many need the
server toggled on for the conversation. **The more of Emm's tools the user
allows without a prompt, the better this works** — agent runs and multi-step
saves stall on a mid-task permission dialog, and the storage tools reach only
that user's own Emm account, which makes broad approval reasonable.
The two further-reaching tools still need your explicit ask whatever the
client setting says (see "HOW TO USE THIS GUIDE" above). Approving each write
by hand is a legitimate choice; the cost is prompts, one of which can stall a
run.
**Success check:** call **`status()`** yourself — a successful response means
you're connected.
If it doesn't work, ask the discriminating question *before* suggesting
anything: **did a browser sign-in window actually open, and did the user
finish it?** The two answers need opposite fixes.
- **No sign-in ever appeared.** Adding the server and authorizing it are two
separate events, and saving the entry does not usually start OAuth by
itself. **Don't send the user hunting for a button** — plenty of clients
have no visible "Authenticate" control at all. The reliable trigger is to
*make the client need the server*: **try to call an Emm tool.** The first
request gets a `401` carrying the sign-in pointer, and that
is what opens the browser window. **Have the user quit and reopen the app**
— clients probe their servers at startup, so a restart is often what makes a
sign-in action appear at all. Say it that way: *quit it and open it again*.
Don't tell them to "select Restart" or wait to be prompted — most apps offer
neither, and a step phrased as a control they can't find stalls them exactly
like a wrong menu path. Also worth asking: **is the entry actually turned
on?** Several clients list a server you created without it
being active, behind a separate **Install / Enable / Connect** action — a
saved entry in a list is not a live connection. And some clients only sign
in from their CLI (`codex mcp login emm`, after `codex mcp add …`). Ask
which of these the user has; don't assert that any particular one exists.
- **Sign-in completed, but you still have no Emm tools.** The connection often
finalizes only when the session re-initializes — ask the user to start a
**fresh chat** with you, and hand them the paste-back below.
**Hand this over verbatim — don't reword or shorten it.** The next session
starts with none of this context and no Emm tools, so the fallback URL is the
only thing that lets it recover — an assistant that rewrote this and dropped
that clause stranded the fresh chat with nothing to go on.
> Continuing Emm setup — call `status()` now. If it works, tell me what came
> back and we'll finish the rest (install the skill, then personalize). If it
> errors, **or you have no Emm tools at all**, say so plainly and fetch
> `https://ai.actingweb.io/setup`, then pick up at Step 1. Don't try to reach
> Emm through a browser, and don't go digging for context from our earlier
> chat — there is none to find.
(If the user was instead setting up a different app, have them confirm Emm
tools appear there.)
---
## STEP 2 — Confirm it works (required, ~30 seconds)
**Already done?** If `status()` already returned successfully in Step 1, call
`how_to_use()` once for a personalized tour and **continue to Steps 3–5**. A
connected account isn't *useful* until it's personalized, so don't stop at
"connected" — 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?**
Then, if `status().pillars_enabled` includes `outputs` (mission control is
on), offer the user these two, one per remaining pillar (both write, so they
need a Read/Write connection):
> **Start a plan for my next trip in Emm that I can keep working on.** (Read/Write)
>
> **Is there anything you should be doing for me?** (Read/Write)
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.
**Then save something real.** If you will run Step 4's setup, that setup is
the first save (see Step 4). Otherwise take something genuinely worth keeping
from the conversation you are already having, save it, and show it back. "It remembered something real about me" is
what makes every later ask a small favour rather than admin.
That first write also shows whether the client will stall on permission
prompts: if it stops to ask before the save goes through, that's the prompt
that blocks an unattended agent run later — settle it now (see Step 1's tool
permissions).
**Success check:** you retrieved an answer from Emm (even an empty one) rather
than erroring, and the save went through. Continue into Steps 3–5 rather than
signing off here.
---
## STEP 3 — Install the Emm skill (recommended)
> Installing the skill is part of setup, not an afterthought — do it now, not
> later. One wording trap: don't relay this as "teach me about Emm" — the user
> hears "me" as *themselves* and skips it. It's a quick action for *them* so
> that *you* 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.
**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 4. (The plugin doesn't connect you on its own; you still did the
Step 1 connection.)
Pick the best option for the app you're running in:
- **Skill (most powerful):** download the skill zip (link above). Apps that
take an *upload* want the **.zip file as-is** — do *not* unzip it — and may
need code execution enabled first; tell the user to upload it. Apps with a
**skills directory on disk** let you unzip and copy the `working-with-emm`
folder in yourself — ask first (see "HOW TO USE THIS GUIDE" above): extract
to a temp location, confirm it holds only that folder, and warn before
overwriting an existing one.
- **Plugin (Claude Code & Workspace):** the skill **plus** the `/emm:*` slash
commands. Like the skill, it's an enhancement layered on the Step 1
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 1. Download the
plugin zip (link above).
- **Custom instructions (optional, apps with no skill):** the paragraph from
the facts block at the top of this page, as-is. It reinforces what the tool
descriptions already say.
An installed skill compares its version with the server's; when the server
reports a newer one, suggest the user re-download.
**Success check:** the app shows the skill/plugin installed, or the custom
instructions are saved.
---
## STEP 4 — Personalise Emm (recommended)
> **Assistant: when the user asked for setup, start the interview below once
> the connection is confirmed; this step is the setup.** Otherwise offer it as a
> concrete action: *"Want me to set up your instructions now?"* It needs the
> `instruction_settings` tools; without them, offer to save a few memories
> instead.
**Why this matters — don't skip it.** Every agent run, and every assistant
the user connects, reads these instructions first. This is the step that
turns Emm from "connected" into "actually useful."
Call `instruction_settings()` first: it returns the user's settings, the task
catalogue and the exact field, section and task names. If it answers
`advanced_mode`, the user keeps their instructions as documents: run the same
interview, then write `personal`, `style` and `tasks` with `instruction_load`
/ `instruction_save`, or suggest switching to guided settings in the app.
**Save no memory or document until step 4 of the interview.** On a brand-new
account the setup saves directly; anything saved before it means the user has
to approve the setup in the Emm app.
1. **About them, first.** Ask four or five short questions, one at a time:
name, what they do, where they are (time zone), the people they deal
with most, anything to handle with care.
2. **How they write.** With the user's permission, and only if a mail
connector is available, read 10–20 recent sent threads (Gmail: `in:sent`; Microsoft 365: the Sent Items folder). Use
only text the user wrote, never quoted replies or anyone else's messages.
Describe patterns — language, greeting and sign-off, length, tone — and
quote no sentences, names, addresses or signatures. Say what you could not
learn (too few emails, mixed languages, no plain text) and keep Emm's
defaults for that part. With no mail connector, say so and ask two style
questions instead.
3. **What each run does.** Walk through the catalogue's tasks, one line each,
and ask which to keep (all on until turned off).
Take notes on what each should watch for (Email Triage: keywords and
senders to always keep; Daily News Report: topics). Offer an own task when
they describe something recurring.
**Where answers go:**
| Answer | Change |
| --- | --- |
| Name, languages, place and time zone | `set_field` `profile`: `name`, `languages`, `location` (`"Oslo (Europe/Oslo)"`) |
| What they do | `set_section` `profile` `professional context` |
| People they deal with | `set_relationships` |
| Handle with care (the rule) | `set_section` `profile` `sensitive context` |
| Writing language | `set_section` `style` `quick reference: routing decisions/language` |
| Greeting, sign-off, length | `set_field` `style`: `email_greeting`, `email_signoff`, `email_max_length` |
| Tone; phrases to avoid | `set_section` `style`: `overall tone`, `things to avoid` |
| Task off; what it watches for | `set_task` `{task, on: false}`; `{task, note}` |
| Something recurring | `add_own_task` |
| A standing rule off, or an own rule | `set_rules` with only that change (all four are on by default) |
`set_other_notes` only for what fits nowhere else. **Facts** (family,
contacts, addresses, account numbers, schools) go to memory afterwards,
never into About you.
4. **Read back, then save once, never before.** Read the whole setup back verbatim,
exactly what you will save. On a yes, save it in one
`instruction_settings_update(changes=[...])`. If that answers
`instructions_locked`, call
`instruction_request_update_window(reason="Set up your instructions")`,
ask the user to approve it in the Emm app, then save again. Memories come
after this save.
5. **First run.** Offer Step 5's schedule and the first run now.
**Success check:** `instruction_settings()` shows what the user told you.
---
## STEP 5 — Put Emm on a schedule (worth having early)
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.
When the user asks:
> **Run my Emm setup now and put my agent runs on a schedule.**
call `instruction_settings()` first. If it says About you is still empty,
start Step 4's interview (they asked for it; don't ask whether to) and save
it before anything else. Then start a run
with `agent_run`, see it through to `agent_run_complete`, and set the
schedule below.
**Check there is something to run — the defaults usually count.** The
library tasks start on, so a schedule is worth setting once the mail and
calendar connectors are in place. Hold off only if the user has turned
everything off or lacks those connectors.
**Runs spend the user's own AI plan**, not Emm's — each one is a conversation
their assistant has on their behalf. Say so before setting a cadence.
**The schedule to recommend:** **hourly through the working day on
weekdays, and two or three times a day at weekends.** Recommend this one
schedule, adjusted to the user's hours; don't offer a menu of lighter
alternatives (the user can ask for a different one). Emm's runs are cheap when there is
nothing to do, and the value comes from Emm noticing things while the user is
away; too sparse a schedule only ever reports stale work.
---
## STEP 6 — Smart things to do (optional, ongoing)
Tier C isn't a one-time task — it's how Emm keeps paying off over time. Three
things worth suggesting once the user is set up:
- **One-off tasks.** The user can queue something to be done once, in the
dashboard's Task Builder or by an agent with `task_draft`. A run picks them
up via `work_on_task()`; an empty queue doesn't mean nothing happened.
- **Custom recurring tasks.** Beyond the seed defaults, the user can add their
own tasks for anything they want checked or done on a regular cadence — an
`add_own_task` change through `instruction_settings_update`, as in Step 4,
or the **Your tasks** card in the app.
- **Output documents.** Ask the assistant to create a document in Emm — a
running research note, a draft, a dashboard — with `output_create()`, and
keep improving it across sessions with `output_edit()` (a part of it) or
`output_update()` (a rewrite). It's visible and
editable on the user's dashboard the whole time.
None of this is required. Offer it once things are working, and let the user
pick what's useful.
---
## If you get stuck
- Connection fails or tools never appear → re-check the URL is exactly
`https://ai.actingweb.io/mcp`, the transport is **Streamable HTTP** (not
SSE), and Client ID/Secret were left blank; then work Step 1's success
check, including the local bridge.
- The steps here don't match the app → follow the user's screen and the
official docs for their app; this guide may be out of date.
- Questions, or to report that these steps are out of date:
**<support@actingweb.io>**