How Eve works

A memory layer your own assistant talks to

Eve is a memory layer — a private place that stores what matters and plugs into the AI you already use. You don't switch to Eve or chat with Eve instead of your assistant; you connect Eve to the assistant you already have (Claude, ChatGPT, anything that supports custom connectors), and from then on it remembers. Across every conversation, every new chat you spin up, you never have to repeat yourself.

The key idea is that your assistant does the thinking, and Eve does the remembering. When you talk, your own model decides what's worth keeping and when to recall it — the expensive reasoning runs on the subscription you already pay for. Eve only does the cheap part: storing those memories and handing them back when they're needed. That's what keeps Eve affordable and private — Eve isn't a second AI reading over your shoulder, Eve's a memory your AI reaches into.

And because Eve rides in through a connector rather than living inside any one model, the same memory works everywhere. Connect Eve to Claude and ChatGPT both, and they draw on the same memory — plan something in one, pick it up in the other. Your memory belongs to you and travels with you, instead of being locked inside whichever assistant you happened to use.

Connect your assistant

Connecting Eve takes about a minute, and it's two pieces: a connector (so your assistant can reach your memory) and a short instruction block (so it actually uses it).

1. Open your assistant's connector settings and add a custom connector. In Claude, that's Customize → Connectors → Add custom connector.
2. Paste Eve's connector URL — https://eve-product.fly.dev/eve-mcp/mcp — and complete the one-time sign-in prompt.
3. Add Eve's instructions. This is a separate step from the connector, and it's the one that makes your assistant actually use your memory every turn instead of ignoring it: paste Eve's instructions into your assistant's instructions field. In Claude, that's your icon (lower-left) → General → Instructions for Claude, or open a project and paste them into its Project instructions.
4. Just talk to your assistant. Eve forms memories in the background, and they'll appear on this dashboard as they land.

That's it. From here on you can also simply ask — "remember that for me," or "save this to my Eve memory" — and it'll be kept the moment it matters. Works the same way in Claude and ChatGPT.

Automatic, or whenever you ask

By default, Eve encodes memories automatically, roughly every six turns of conversation — you don't have to do anything for it to work. You can change that pace, or switch to saving only when you ask, anytime in Settings (see Tuning).

And you never have to wait for the automatic pass. Whenever something matters in the moment, just tell your assistant — "remember that for me," or "save this to my Eve memory" — and it's encoded right then.

Want to see it work? In your first couple of turns, tell your assistant a fact about yourself and ask it to remember. Then watch it appear here on the dashboard within moments.

Memory Lane

Open it: #lane
On a computer: Click **Memory Lane** in the top bar.
On a phone: Tap the view switcher in the top bar, then **Memory Lane**.

What you can do there: Read memories newest-first, open one for its full text and sources, pin, edit or delete it, and search by word or by ⟨id⟩.

Memory Lane is everything Eve remembers, newest first. As you and your assistant talk, each thing worth keeping lands here as a memory card — so you can read back exactly what Eve's holding, in the order it happened.

It's also where you shape it. Every card is yours to act on: approve what Eve got right, correct what Eve didn't, and pin anything that must never be forgotten. When something is active but not what you're working on right this minute, set it aside — and pull it back whenever you need it. Nothing is ever stuck. And if Eve hasn't captured something, you can add a memory yourself, any time.

Mindmap

Open it: #map
On a computer: Click **Mindmap** in the top bar.
On a phone: Tap the view switcher in the top bar, then **Mindmap**.

What you can do there: See how memories connect, join nodes that belong together, edit what a node holds, or let one go.

The Mindmap is your memory as a picture of how it all connects. The people, events, ideas, and places you talk about appear as nodes, and Eve draws the links between them — so you can see not just what Eve remembers, but how it relates: who's connected to what, which ideas sit near each other, what threads run through your life and work.

Nodes are colored by kind, and the brighter ones are what's active right now. You can shape the graph directly, too: connect nodes that belong together, edit what a node holds, or let one go. It fills in on its own as you talk — there's nothing to set up.

Atlas — where things stand

Open it: #atlas
On a computer: Click **Atlas** in the top bar.
On a phone: Tap the view switcher in the top bar, then **Atlas**.

What you can do there: Read where things stand chapter by chapter, with the memories each chapter was written from named as its sources.

If Memory Lane is what happened, in order, and the Mindmap is what connects to what, Atlas is the third altitude: where things stand right now. As your memory grows, Eve folds it into themes, and each theme becomes a chapter — a plain-language synthesis of what's true now, written like a wiki article about your own life and work.

What makes Atlas trustworthy is that it isn't a free-floating summary you have to take on faith. Every statement cites the memory cards it's drawn from — timestamped and clickable — so you can always check a chapter against its sources. It's time-aware, too: when something has changed, Atlas shows what's true now, with the older version one expand away ("this replaced…"), so it reads like a wiki that remembers its own history. The point isn't just the summary; it's a summary you can audit, trace, and trust.

You'll find chapters laid out in a table of contents, each one cross-linked to related themes, with a Refresh whenever you want the latest.

Board

Open it: #board
On a computer: Click **Board** in the top bar.
On a phone: Tap the view switcher in the top bar, then **Board**.

What you can do there: See projects and their status, open one for its tasks, and follow a task back to the memory it came from.

Board is your projects, as they move. A project gathers related memories into a piece of work, and the Board shows where each one stands — from Backlog, to In progress, to In review, to Done — as a lane each, the way a Kanban board works. Cards move across the lanes as the work moves. Projects can form on their own, as Eve notices work taking shape across your memories, or you can start one yourself.

Click into a project and you'll see its stage, the memories gathered under it, and — this is the part that matters — a link to where the editable work actually lives. Because Eve is a memory layer, Eve deliberately doesn't try to be your editor. Your documents stay where they are: your Google Docs, your assistant's artifacts, wherever the real work happens. Eve points at the editable surface; Eve doesn't replace it.

What Eve adds is legibility and good defaults. The status of each project is a shared, glanceable signal of where things are and what kind of collaboration they're ready for. Each stage carries a gentle nudge toward the right working habit — keep work-in-progress in an editable, suggest-mode surface, rather than shipping a finished, locked artifact before it's ready — guidance, never enforcement. And some lanes have a soft limit on how much can sit there at once, so the Board nudges you when work piles up instead of flowing. The whole idea is to make the work-in-progress stream more usable by default: legible, hand-markable, and keeping you in the loop where your judgment matters most.

Cortexes

Open it: #settings
On a computer: Click the gear, then **Cortexes**.
On a phone: Tap the gear, then **Cortexes**.

What you can do there: Create a cortex, rename one, archive one, or switch which cortex you are looking at.

A cortex is a separate area of memory, kept apart from the others. Keep work in one and personal life in another; keep a single client, project, or side of your life in its own cortex, so things don't bleed together.

You don't need a separate connection for each one. A single connection reaches all your cortexes — your assistant just needs to know which one you mean for a given conversation. Open with a line like "use my [name] cortex for this," and everything you save and recall in that conversation lands in the right place. Same connector URL, same instructions, every cortex — one connection, as many cortexes as you keep.

Seeing & shaping your memory

The whole promise of Eve is memory you can see, shape, and trust — and that's not a slogan, it's a set of concrete controls. Everything Eve holds is visible to you, and everything is yours to adjust.

When Eve records or infers something, you decide whether it stands: approve what's right, correct what's off, and pin the things that must never be forgotten. Set aside what's not relevant right now, and restore it when it is. Nothing Eve keeps is hidden from you, and nothing is beyond your reach to change.

And because memory changes over time, Eve keeps track of what replaced what. When a belief is superseded — you moved cities, changed roles, switched tools — Eve shows what's true now, with the older version still there to see, one expand away. You're never guessing whether Eve's working from something out of date. You can look, and you can fix it.

Consolidation & upkeep

Memory only stays useful if it stays coherent, so Eve periodically tidies what Eve holds — clearing clutter, removing duplicates, merging the same person recorded twice, and grouping related beliefs so they're easier to navigate. It's the housekeeping that keeps a growing memory legible instead of becoming a pile.

You stay in control of all of it. Every bit of upkeep is reversible — keep what you like, undo what you don't — and you can run a full pass over your cortex yourself, any time, from Settings.

Your data is yours

Your memory belongs to you, completely — and you can take it with you whenever you want. Export everything, always free, as both JSON and Markdown. There's no lock-in, by design: portability is the entire point, and your memory is meant to travel with you across models, not be held hostage by any one of them.

Privacy works the same way. Your assistant does the reasoning; Eve stores only what you let Eve keep, and everything Eve holds is visible to you — there to see, and there to remove. Nothing is kept where you can't reach it.

Keyboard shortcuts

Everything works without them, but the whole platform is keyboard-navigable. Press ? anywhere to see this list in the app. Sequences are vim-style (g then m); bare keys never fire while you're typing.

Memory tuning

In the ? panel — the dials for how Eve behaves:

• How often Eve forms memories — automatically every few exchanges, or only when you ask.
• Protect recent turns through consolidation — keep the last few turns word-for-word (shown on accounts that have web chat).
• When to consolidate — the context size Eve aims to stay under before suggesting a consolidation.

Optional features

Off by default, toggled in the ? panel — they stay out of the main flow until you switch them on.

Surfaces that grow with you

Every view is always there, but a view with nothing in it yet shows a preview of what will live there and fills in on its own as your memory grows. A brand-new account lands straight in the dashboard — no wall — with a one-line nudge to connect your assistant.

FAQ

Chat

Open it: #chat
On a computer: Click **Chat** in the top bar.
On a phone: Tap the view switcher in the top bar, then **Chat**.

What you can do there: Talk to Eve on the website itself.

Chat is Eve on the website. Most people reach Eve through their own assistant instead; this is here for when you want to talk to the memory directly. Not every cortex has it — a memory whose conversation lives in your own assistant will say so.

Settings

Open it: #settings
On a computer: Click the gear, top right.
On a phone: Tap the gear, top right.

What you can do there: Change how memory behaves, import your history, connect your assistant, see your activity, manage cortexes.

Settings is reached from the gear and is deliberately not one of the four ways of looking at your memory, which is why it does not sit in the view switcher.

Where Eve can reach

Open it: #settings/apps
On a computer: Click the gear, then scroll to **WHERE EVE CAN REACH**.
On a phone: Tap the gear, then scroll to **WHERE EVE CAN REACH**.

What you can do there: Connect Google Calendar, Google Drive or GitHub, or open your Documents.

Connecting Google Calendar starts at /auth/connect/calendar. Eve reads your upcoming events and only writes one when you ask and confirm first. Which rows appear depends on your cortex.

Import your history

Open it: #import
On a computer: Click the gear, then **Import your history**.
On a phone: Tap the gear, then **Import your history**.

What you can do there: Upload an export from ChatGPT, Claude or Gemini, choose what to bring in, review every memory before it is saved.

Import reads an export you already have. Nothing is read by a model until you say so, and nothing enters your memory until you have reviewed it.