Maya is midway through a client call when ChatGPT states, with total confidence, that she recommended a vendor she never evaluated. The client notices. Maya doesn't know where the assistant got the idea, whether it's a hallucination or a stale note from three projects back, or how to make it stop happening. She has no way to check. That's the real failure mode: not that AI forgets, but that it remembers things wrong and gives her no way to verify, correct, or trace any of it.

Myeline exists because platform memory is a one-way mirror. You can see what an assistant says it remembers. You cannot see where that memory came from, who wrote it, or whether it was ever right. The Myeline Memory Layer closes that gap: every fact is staged before it's saved, every fact carries its source, and nothing crosses into memory without the user's approval.

The Core Problem: 'Remembered' Is a UI Claim, Not an Ownership Claim

Most AI memory today is platform-scoped, not user-owned. When Claude or ChatGPT says it remembers something about you, what actually happened is that a fact was written to a store the platform controls, not one you can inspect, correct, or take elsewhere. You didn't author the write. You can't see the record behind it. You can't export it if you switch providers or if a product you depend on changes its memory feature overnight.

A user-owned memory layer is a memory store where write permissions, audit access, and export rights belong to the person the facts describe, not to the assistant vendor. It works by keeping every fact, its source, and its approval record in a layer the user controls, one that any MCP-compatible assistant can read with permission but none can write to directly.

There's a single diagnostic question that exposes the difference in under five seconds: if the vendor disappeared tomorrow, where would your memory go? If the honest answer is 'I'm not sure,' the memory was never really yours.

What Compounding Memory Means for a Consultant Running Three Assistants

Picture a consultant running Claude for primary research and ChatGPT for client deliverables. Every tool boundary erases context. A preference noted in Claude doesn't exist for ChatGPT. A constraint the client gave last month has no path into this week's draft. The consultant re-explains the same background facts over and over, and nothing compounds.

Myeline sits outside both assistants and feeds both. It connects to Claude, ChatGPT, and any client that speaks the Model Context Protocol, and keeps what an AI learns about a person as single facts, each with its source attached. A fact approved during a Claude session is available the next time ChatGPT asks. The memory doesn't reset at the tool boundary because it was never stored at the tool boundary. It lives one layer up, in a store the user owns.

That's what compounding actually looks like in practice: a project preference logged in week one is still correctly scoped in week twelve, reachable by whichever assistant happens to be open that day.

One Brain Per Person, One Per Team: How Myeline Draws the Boundaries

Memory that is not bounded becomes memory that is not trustworthy. Myeline draws its boundaries at the brain, not at permission flags inside one shared store. Every person who signs up gets their own brain: a private memory surface no other account can query. When a group needs shared memory, that group gets its own team brain with its own MCP address, so what an engagement knows is decided by which brain a client connects to, not by a runtime permission check.

Inside a brain, organization comes from filing, not permissions. Facts carry dimensional tags like project:, person:, and account:, so a client engagement's knowledge sits on its own shelf and a person's preferences sit on another, visible and renamable by the owner. A consultant who leaves a project stops pointing their assistant at that team's brain; the brain itself does not follow them, and their personal brain never mixed with the engagement's in the first place.

Skip that boundary design and you get a flat store: a scheduling preference sitting next to a client's contract term, carrying equal weight. The structure that makes memory trustworthy at scale is which brain a fact lives in and how it is filed there, both under the owner's control.

How Does Myeline's Approval Queue Actually Work?

Every AI memory system that writes automatically is making a bet on the user's behalf: if the assistant's inference is wrong, that wrong fact lands in permanent memory anyway, resurfaces later, and gets treated as ground truth by the next assistant that reads it, and the error compounds forward from there.

From a developer's side, the flow is fixed and repeatable:

  1. Send the candidate fact through Myeline's MCP tools, tagged with its source.
  2. Review the staged card, which shows the proposed fact, where it came from, and the tags it would carry.
  3. Approve or retire the card. Approval commits the write. Retiring it discards the candidate entirely.
  4. Query the approved memory from any connected client going forward, with the source line intact.

No permission scope in that flow can approve a memory or touch billing on its own. AI clients can only propose. The person reviewing the queue is the only one who can make a candidate fact real.

Auditability: Sources, Timestamps, and the Retirement Trail

Auditability isn't a compliance feature added after the fact. It's a requirement for any memory layer where facts are meant to compound over months, because a fact with no attached source is a liability waiting to surface in a client deliverable.

Every fact Myeline stores carries four fields: the source it was drawn from, the timestamp of the write, the identity of the user who approved it, and a witnessed retirement log entry if the fact is ever retired. The source field lets a downstream assistant verify a claim instead of repeating it blindly. The timestamp shows whether a fact predates a known change. The approving-user field creates accountability at the individual level. The witnessed retirement log means retiring a fact leaves a record of what was removed and why, not a silent gap.

There's a one-question test for any memory vendor: ask what a deletion looks like in the audit log. If the answer is that deletion erases the record, the audit trail was never real. A fact removed without a trace is indistinguishable from a fact that was never there.

What Myeline Won't Do: The Design Decisions Behind the Guardrails

Myeline was founded in Portland, Oregon, in 2025, built around the architecture described above rather than retrofitted onto an existing product. The guardrails below aren't marketing language; they are deliberate non-actions built into the system.

AI clients cannot write memory directly. Every save is staged, and no permission scope, however broad, can approve a memory or change billing on its own. Myeline never reads chat history, a client's own memory, or files; it only receives what a client explicitly sends through its tools, which keeps the layer from silently absorbing context no one agreed to share.

At every plan tier, Myeline refuses to store Social Security numbers, bank and card numbers, passwords, and API keys, rejecting them before anything is saved. And when a search turns up nothing that matches an approved fact, Myeline says so. It does not guess, and it does not silently drop memories once a plan's limit is reached: a free account holds up to 200 live facts, search itself is never capped, and a new memory past the limit is refused with a clear message instead of quietly dropped.

How to Evaluate Any Memory Layer Before You Integrate

Before connecting a memory layer to a production workflow, developers can apply six questions, each mapped to a design decision rather than a marketing claim.

  1. Identify who holds the write key. A trustworthy layer puts it with the user, not the platform.
  2. Check whether writes are approval-gated. A trustworthy layer queues writes for confirmation before committing them.
  3. Confirm every fact is sourced at ingestion. A trustworthy layer refuses to write a fact with no source reference attached.
  4. Ask whether deletions are auditable. A trustworthy layer logs what was removed, by whom, and when.
  5. Request a sample export and check for provenance metadata. A trustworthy layer exports source, timestamp, and scope alongside the fact text, not fact text alone.
  6. Ask where memory lives if the vendor shuts down. A trustworthy layer hands back a portable, structured export that can move to a different system.

Every fact has a source. Every write waits for approval. Every deletion leaves a reason. That's the standard a production memory layer should meet, and it's the standard Myeline was built against from the start.

What To Do Next

For a consultant juggling Claude, ChatGPT, and a client deliverable due this week, the fix starts with connecting one assistant to Myeline's MCP endpoint and approving the first handful of facts it proposes. The review queue takes minutes, not hours, and every fact carries the source that got it in.

For a technical founder fielding a security review, the relevant starting point is the audit log and the permission-scope documentation. Look at what a connector can and cannot touch before anything else, and verify that approval and billing are genuinely separated at the permission level, not just in the interface.

For a developer already living inside Claude Code or Cursor, the fastest path is a single project-scoped connection: approve what the agent proposes, watch the source line attached to every recalled fact, and judge the workflow against the six questions above before expanding it to a second client or a second coding tool.

Frequently asked questions

What is a user-owned memory layer and how is it different from platform-scoped memory?

A user-owned memory layer stores facts with write permissions, audit access, and export rights belonging to the person the facts describe, not to a single assistant vendor. Platform-scoped memory, in contrast, is written to a store the platform controls, which the user can't inspect, correct, or take to another tool. Myeline is built as a user-owned layer accessible through a standard MCP endpoint, so memory persists across assistants rather than resetting at each one.

How does Myeline's approval queue work?

An AI client sends a candidate fact through Myeline's MCP tools, tagged with its source, and it lands as a staged card showing the proposed fact, its origin, and the tags it would carry. The user approves or retires the card; approval commits the write, and retiring it discards the candidate entirely. No permission scope can approve a memory or touch billing on its own, so a fact only becomes real once a person says yes.

What happens when Myeline can't find an approved fact that matches a question?

Myeline does not guess. If nothing in the approved memory matches what's being asked, it says so directly rather than producing a confident but unsupported answer. This is a deliberate design choice, not a gap in coverage.

Can the same memory be used across Claude, ChatGPT, and other AI tools?

Yes. Myeline connects to Claude, ChatGPT, and any client that speaks the Model Context Protocol, and keeps facts in a layer outside any single assistant. A fact approved during one tool's session is available the next time a different connected assistant asks, so context doesn't reset at the tool boundary.

What happens when a fact is deleted from Myeline?

Deleting a fact in Myeline is a witnessed retirement: the fact stops appearing in answers, but a log entry records what was removed, by whom, and why, and that reason stays in the audit log. A deletion that erased the record entirely would make the audit trail meaningless, since there would be no way to tell a removed fact from one that never existed.

Why does Myeline require manual approval instead of writing memories automatically?

Automatic writes mean an assistant is making a bet on the user's behalf every time it infers something; if the inference is wrong, the error enters permanent memory and compounds forward as later assistants treat it as fact. Myeline queues every proposed memory as a staged card instead, so nothing is saved until a person reviews and approves it.