A developer running a fintech project in Cursor and a healthtech project in Claude Code in the same week asks an assistant a question inside the healthtech workspace. The answer references an authentication scheme that was never discussed there. It was written in the fintech session three days earlier. Nobody approved that fact to cross workspaces. Nobody even saw it move.
That is the default behavior of a memory layer that treats extraction and recall as a single automated pipeline: whatever an assistant decides to remember, it can also recall, instantly, anywhere it has access. Model Context Protocol (MCP) is the open standard that lets a client like Claude Code, Cursor, or Codex connect to an external memory server as a callable tool. It works by exposing functions the assistant can invoke to propose, search, or forget memories, without ever writing directly into the active store itself.
Myeline's MCP memory server adds the step most memory servers skip: a staged-approval queue between the moment a fact is proposed and the moment it becomes recallable, scoped per client, across every coding assistant a developer runs.
Why Do Coding Assistants Need an Approval Queue, Not Just Persistent Context?
Coding assistants need an approval queue because persistent memory alone has no mechanism to stop one client's facts from surfacing in another client's suggestions. Myeline separates every account's memory into its own brain, gives each team brain its own connector address, and requires one explicit human approval before any proposed fact becomes recallable by any assistant.
Skip that approval step and three consequences follow. Client data bleeds into the wrong workspace. Suggestions get sourced from a different project's architecture decisions. And the audit trail cannot confirm which facts influenced which response, because there was never a recorded decision point to log. Myeline's review queue exists to prevent all three.
Connection tokens expire after 30 days and a disconnect severs an app on its next request, so access is also something a person decides, not a setting that silently persists forever.
How Myeline's Memory Architecture Maps to Claude Code, Cursor, and Codex
Myeline is a hosted memory server: one address, https://cortex.myeline.si/mcp, that any MCP client connects to over OAuth 2.0. The assistant proposes a fact. A person approves it in the workspace review queue. Only then does it become part of the memory any connected assistant can recall. Nothing reaches the active store without that sequence.
Isolation is structural, not a setting. Every account has a personal brain no other account can see. A team brain is shared memory that members join by invitation only, and each team brain has its own MCP address, so a client workspace connects to exactly the brain it should: a fintech team brain and a healthtech team brain are separate connectors with separate addresses, and neither can query the other.
The experience is identical across Claude Code, Cursor, and Codex, because none of them gets special plumbing: they all speak MCP to the same server, propose through the same tools, and wait for the same human approval. Three permission scopes exist (query, propose, retract), and none of them can approve a memory or touch billing; those actions belong to a signed-in person in the workspace.
Setup Guide: Connecting Claude Code (the same steps work in Cursor and Codex)
Every MCP client connects to Myeline the same way, because Myeline is one hosted server rather than a per-tool package:
- Create an account at workspace.myeline.si/sign-up.
- In your client, add a custom connector (Claude Code, Cursor, and Codex all support custom MCP connectors) with the address https://cortex.myeline.si/mcp. For a client-specific team brain, use that brain's own address, shown in Settings when the team is selected.
- Sign in with the Myeline account and approve the connection.
- Ask the assistant to remember something. It lands in the review queue at workspace.myeline.si/review, staged, not live.
- Approve it there. Now it answers, with its source attached.
There is no environment variable, no config file schema, and no install command to get wrong: the address, the sign-in, and the approval are the whole integration. Myeline's docs page carries copyable setup prompts for Claude and ChatGPT that walk through each client's own connector settings step by step.
The verification test is the same as the diagnostic: write a throwaway fact, and if the assistant can already recall it before you approved it, that is a bug worth reporting, because staged is staged.
One Brain Per Client: the Honest Version of Scope Isolation
The article you might expect here is a per-project scope field in a config file. Myeline deliberately does not have one, because a tag an assistant can set is a tag an assistant can mis-set. Isolation that matters lives at the address level:
- Found a team brain for the client in Settings (any account can; the founder becomes its admin).
- That team brain gets its own MCP address, shown in Settings while it is selected.
- Connect the client's tools to that address as their own connector. Your personal connector keeps working alongside it.
- Members join by invitation only. Members approve their own assistant's proposals; admins approve anything.
A fintech engagement and a healthtech engagement are two team brains with two addresses. Neither tool, nor its assistant, can reach across, because there is nothing to reach across: the brains are separate memories, not one memory with tags. When someone leaves the engagement, removing them kills their assistant's access on its next request.
Until a team brain is subscribed it holds the free plan's 200 facts, and nobody else can join it, so the isolation starts at founding, not at billing.
What the Audit Log Actually Records
Every decision in Myeline leaves a record a person can read:
- Every approved fact carries its source, who approved it, and when.
- Every answer an assistant gets includes the source line of each fact it used.
- Retracting a fact requires a written reason; the fact stops appearing in answers immediately, and the reason stays in the audit log.
- Every team brain keeps an audit log its members can read: who joined, who decided what, every fact approved or retired.
That is the whole receipt, and it is the same across Claude Code, Cursor, and Codex because the records live in Myeline, not in any client. A security review does not need per-tool artifacts; it needs one log with named humans at every decision point, which is what the architecture produces by default rather than as an option.
Isolating Client Memory: The Staged-Approval Queue in Practice
Picture a developer running a fintech engagement and a healthtech engagement in the same week, each with its own team brain and connector address. Inside the fintech brain, the assistant proposes: "Auth uses RS256 tokens." That proposal lands in the review queue immediately, staged, visible to the fintech brain's members, and usable by no assistant at all.
One approval in the review queue makes it live: from that moment it answers queries to the fintech brain, carrying its source, the approver, and the timestamp. The healthtech brain never sees it. Not because a filter caught it, but because it was never in that brain: separate memories, separate addresses, separate approvals.
And if the assistant is asked something the approved facts do not cover, Myeline says so instead of guessing. An agent that guesses when memory is thin will act on the guess; one that reports nothing approved matches hands a developer a clean, legible failure instead of a quiet one.
What Myeline Won't Do: The Design Decisions Behind the Approval Queue
Built in Portland, Oregon by Sandbox Group LLC, Myeline ships the approval queue as the default architecture, not an add-on toggle. Several deliberate non-actions back that design and double as trust signals for a team evaluating it.
AI clients cannot write memory directly. Every save is staged, and no permission scope granted to a client can approve a memory or touch billing. Myeline never reads chat history, a client's own memory, or files; it only receives what a client explicitly sends through its tools. Social Security numbers, bank and card numbers, passwords, and API keys are rejected at every setting, before anything is written to the pending queue. And when a query matches nothing a human has approved, Myeline says so rather than guessing: it does not silently drop memories at a plan limit, and it does not fabricate a plausible answer to fill the gap.
That last behavior matters most for coding agents specifically. An agent that guesses when memory is thin will act on the guess. One that reports nothing approved matches gives a developer a clean, legible failure instead of a quiet one.
Troubleshooting: the Three Things That Actually Go Wrong
Three situations account for most confusion, and none of them involve config files:
The assistant saved something but does not seem to know it. The memory is still staged: approve it in the review queue at workspace.myeline.si/review, and it answers from that moment. Staged is the default state for everything an assistant proposes, on purpose.
A save was refused with a plan-cap message. The free plan holds 200 live facts, and the refusal names the limit rather than dropping anything silently. Retire a fact (it frees room immediately) or subscribe on the Plan page.
A save was refused by the PII gate. The text contained something Myeline never stores at any setting: card and bank numbers, Social Security numbers, passwords, API keys. Remove it and the rest saves. Separately, if a connector stops working after about a month, its 30-day token has expired; reconnect and approve it again.
What to Do Next
For a developer standardizing MCP connectors across a small team, the place to start is the free plan: up to 200 live facts, search that is never capped, and a clear refusal message at the limit rather than a memory silently dropped. Connect one coding client first, confirm the pending-approvals dashboard is catching every proposed fact, then add the next client with its own scope.
For a consultant juggling several client workspaces across Claude Code, Cursor, and whatever tool comes next, the scope model is the thing to verify before trusting it with real client data: write a throwaway fact in each workspace, confirm it stays isolated, then start sending the facts worth keeping.
Myeline proposes nothing on its own authority. A human approves every fact before any assistant can act on it, and every approval, every retraction, and every deletion leaves a reason in the log.
Frequently asked questions
What happens to a fact an assistant proposes before it is approved?
It sits in the review queue as a staged card, visible in the workspace, usable by no assistant. Approving it makes it live; retiring it with a reason keeps the reason in the audit log. Nothing an assistant proposes goes live on the assistant's own authority.
Can one client's facts appear in another client's answers?
No. Each account's personal brain is visible only to that account, and each team brain is separate memory with its own MCP address, joined by invitation only. A fintech team brain and a healthtech team brain are separate connectors over separate memories; there is no path between them.
How does Myeline's approval queue work across Claude Code, Cursor, and Codex?
Identically, because the queue lives in Myeline rather than in any tool. Every client connects over MCP to the same hosted server, every save through any of them lands staged in the review queue, and a person approves or retires it in the workspace. No client gets special write access; no permission scope can approve.
How is Myeline different from an autonomous memory-extraction layer?
Extraction layers decide for you what becomes memory. Myeline refuses: the assistant proposes, the person decides, and every decision is recorded with its source, approver, and timestamp. The approval step is the audit trail.
What happens when I retract a fact?
You write a reason. The fact stops appearing in answers immediately, the reason stays in your audit log, and retirement is final: re-proposing the fact is the path back, which creates a new approval record rather than resurrecting the old one.
What is the most common setup problem?
Forgetting that the connector has to be enabled in the chat, and that everything starts staged. If the assistant cannot use Myeline, check the connector is on; if it saved but does not answer, check the review queue. If a connector dies after about a month, its 30-day token expired: reconnect and approve again.