ChatGPT Plugin

Eve Cortex

Long-term memory you control

Brand: Eve

Category: AI
Primary Subcategory: Personal AI Memory & Second Brain

Integration details

Description

Eve Cortex gives your conversations a long-term memory that lives in your own Eve account. As you work, it saves what matters (your projects, preferences, decisions and the people you work with) and recalls it in later conversations, so you don't have to repeat yourself. You can keep a private memory for yourself or a shared memory for a team, where each person's additions are attributed to them. You can read, edit, export or delete every memory in the Eve web app at evecortex.com.

Integration type: Plugin
Verification status: Not applicable
Platform: ChatGPT
Category: AI
Primary Subcategory: Personal AI Memory & Second Brain
Secondary Subcategories: None listed
Brand: Eve
Access: Account required
First tracked: 2026-10-16
Tool count: 18
Geography: US

Agent DiscoverabilityChatGPT Plugin Discovery Score

ChatGPT organic discovery is live

Your score is coming

ChatGPT now suggests Plugins on its own when they match a user's request.Your Plugin Discovery Score measures how often yours appears, and it will show here as soon as it’s ready.

ChatGPT recommends Airtable when a user asks it to update a CRM. — ChatGPT surfaces Airtable because it matches the user's request.

Primary Subcategory

Competing in ChatGPT Personal AI Memory & Second Brain

View Category

Listed in alphabetical order

Primary Subcategory

2MindComing soonGet notified

AI PassportComing soonGet notified

AI Whisper Voice Note TakerComing soonGet notified

AI WisebaseComing soonGet notified

AiAkiv MemoryComing soonGet notified

Eve CortexComing soonGet notified

Tools

18 tools agents can invoke

Pin where a memory's living document, file, or calendar item lives, so later recalls point at the current copy. `memory_id` comes from an eve_recall row. PREFER A URL — it is clickable, a typed path is not. Pass the readable name as `title`. Fall back to `locator` ("their Google Drive, /Clients/Acme/plan.md") only when there is no url, with optional `locator_kind` (project_instructions | google_drive | google_calendar | url | file | other). CALENDAR EVENTS: pass the event link as `url`, locator_kind ="google_calendar", and cache its current time in `event_start` (ISO 8601), `event_allday`, optional `event_status`. Recall then shows the date, not just a label. When the event MOVES, call again on the same memory with the new `event_start` — it refreshes in place rather than stacking a duplicate. VERSIONING: attaching a newer version of a doc already there (same url, file or path) auto-stales the previous one and keeps it in history; `replaces` supersedes a specific one. REMOVING: pass `remove="<aid or url>"` with `memory_id`, only when the user asks — to mark a doc out of date, attach the newer version instead. `space` names a cortex.
eve_attach
TEST-ONLY benchmark affordance — backdate SEVERAL memories to one date in a single call. Same gating + semantics as eve_set_memory_date. Apply dates in true session-chronological order across calls: eve_history orders prior versions by date, so backdating out of order renders a misleading trail. `memory_ids` is a list of ⟨id⟩ values; `date` is YYYY-MM-DD or full ISO 8601; `space` targets a separate cortex.
eve_backdate
Check what happened to a saved memory, or retry one that failed. `receipt` is the id returned when you saved it. mode="status" reports it; mode="redrive" retries a save that was set aside after repeated encoding errors. ONE TOOL WITH A MODE, not two tools: the host's tool budget is shared with every other MCP the user has installed (the reasoning at :1188 and :2282), and status/redrive are one workflow — you look, then you retry. Decided by sill 2026-08-17.
eve_memory_status
Fold recent memories together — cluster near-duplicates, merge duplicate people/topics, link what's related. The slow-integration counterpart to eve_remember's fast capture. Call it at a lull, a session's end, roughly every ~20 exchanges. Reversible, and cheap when there is little to do. Returns IMMEDIATELY and keeps running in the background, so NEVER report it as finished. Calling again supersedes a pass still in flight. `space` names a cortex.
eve_consolidate
Delete a memory, or erase a FACT everywhere it is recorded. ONLY when the user explicitly asks — never on your own initiative. `memory_id` comes from an eve_recall row. Two modes; if which they meant is ambiguous, ASK before using the second. `forget_fact` EMPTY (default) — delete this one memory. Reversible: it moves to 'recently deleted' and they can restore it. Tell them so — it's recoverable. Other memories carrying the same fact are left alone; you are told about them. `forget_fact` SET to the value ("Zypherix Labs", "James") — erase it from every memory, previous versions, the restore buffer and pending saves. For "forget that I work at X" / privacy requests, not for tidying a card. NOT reversible, no restore. Erases memories WHOLE — anything recorded alongside the fact goes too, and the result says how many; read that back to the user rather than summarizing it away. `space` names a cortex. In a SHARED one, erasing a fact is refused on purpose — it is other members' memory too — and surfaced to them.
eve_delete_memory
Correct an existing memory's text — fix a wrong fact, a name, an out-of- date detail. Call this ONLY when the user tells you a stored memory is wrong or asks you to change it; never rewrite their memories on your own. `memory_id` comes from an eve_recall row. `new_text` replaces the main text — a belief's content, a person/topic's name, a note, an event's title. `new_detail` sets an Event's longer body when its substance changed; omit for a simple title fix. Tell the user specifically what you changed. `status` changes a memory's STANDING instead of its text, alone or with a correction: • a contingency ("IF … → … (not yet in effect)") whose condition has now happened → 'fired', and eve_remember the value it implies. 'retired' if it no longer applies. • a thread/task → 'resolved' to close, 'reopen' to bring it back. Editing an Event or Belief keeps the PRIOR value as a dated entry in version history, so "what did it used to be" stays answerable — see eve_history. Other kinds (Person, Topic, Concept, Place, Document, Question) are edited IN PLACE and the previous value is not kept. `space` names a cortex.
eve_edit_memory
A cheap table of contents of what's stored, without a full recall. Call it at the START of a conversation and right after any compaction. Returns what's salient now, the areas Eve holds memories about, and a `complete` flag. Use it to decide when NOT to recall: a topic clearly absent from the map AND `complete: true` means nothing is stored — answer directly. If `complete: false`, or the topic plausibly maps to a listed area, recall normally. When in doubt, still recall. `space` names a cortex. `budget` has the same approx-token contract as eve_recall (default 4000; floor 1000).
eve_orient
List the user's separate cortexes, or open one with `create="<short name>"`. Each is independent; target one by passing its name as `space` on other calls. At the START of a conversation, call this bare to see what exists, then ASK the user which they're continuing in — or whether to start fresh.
eve_spaces
Keep a short note salient right now — a focus for this stretch of work, a temporary instruction ("keep replies tight"), a thread to pick back up. Pinned notes surface in every eve_orient until released, so they survive context compaction and session boundaries. NOT eve_remember: remember files a durable fact into the graph, recalled later by topic. Pin holds something in view now. "This is true about the user" → remember. "Keep this in front of me" → pin. One crisp line. `lasting=True` also marks it a standing ask going forward. To RELEASE, pass `release="<word from the note>"` instead of `note`; every pinned note containing it is removed. `space` names a cortex.
eve_pin
How Eve works, and how to open each view — the product manual. NOT the user's memories and NOT their documents: this reads Eve's own manual, so you can tell someone where a thing lives and hand them a link that opens it. Call it when they ask how to do something IN Eve — "how do I see my memories", "where is the Atlas", "how do I connect my calendar", "how do I import my ChatGPT history". No `topic` lists every section. Pass a `topic` (a section name, an anchor, or a word from its title) to read one. A view's section carries the URL that opens it, the click path on a computer and on a phone, and what you can do there — quote the click path as written and give them the link. The connector walkthroughs come back with the date each was last checked. Say that date if the user is following steps: these paths move.
eve_manual
Read the user's Eve documents — the doc log Eve writes into with eve_write_doc (plus anything they've uploaded). Call with NO `ref` to see everything filed, by folder. Pass `ref` (a document id from that listing, or its filename) to read one document's full text. Reach for this when they refer back to something written earlier — "the outline we did", "what did I say about chapter 3" — or before writing a new doc, so you file into a folder that already exists and extend the existing document instead of starting a near-duplicate. Documents are per-cortex: `space` targets one of their named cortexes, omitted means their main one. A long document comes back truncated with a note saying so.
eve_docs
Read memories IN FULL by id. eve_recall rows are truncated at ~1000 chars, so a long memory's tail never shows there — reach for this when a row looks cut off, or when you need the complete body to answer precisely. Returns kind, headline, the whole detail, provenance markers, status (including whether it was superseded and by which id), dates and attachments. `ids` takes up to 10 ⟨id⟩ values from eve_recall (a comma-separated string also works). `space` names a cortex. `budget` has the same approx-token contract as eve_recall (default 4000; floor 1000).
eve_read_memory
Recall from the user's persistent Eve memory (their long-term cortex). Call before answering whenever the user refers to themselves, their past, preferences, projects, or people in their life. Eve is governed: it surfaces the CURRENT value of a fact and suppresses stale ones — trust it over your own guesses. When a result carries a date (· YYYY-MM-DD), use it to order results yourself for "over time" / earliest-to-latest questions. Two dials, both cheap by default: `depth` — "node" (default) ranks the best matches, right for almost everything; "connected" adds their linked people/events/topics, tagged with the connection; "deep" walks several hops for answers that chain. `mode` — "ranked" (default) may cap the list. Use "all" for enumeration ("list all my X", "how many Y") where a partial answer is wrong. A ranked result flagged as a capped slice on a list question means re-call with mode="all". PAGING: only a reply that does NOT say "showing N (page …)" is the whole set — trust the stated total, never a single page; walk the rest with `page=1`, `page=2`, … or narrow the query. `anchor_id` seeds recall from one memory's ⟨id⟩ — what's folded under it, plus its neighbourhood with depth. `space` names a cortex. `budget` caps how much of YOUR CONTEXT one result may spend, in approx tokens (default 4000). An ordinary `limit=8` call is ~1,900 and is never touched. When a result would go over, whole rows are cut from the END — the ranking is never reordered — and the ones that did not fit come back as one-line previews carrying their ⟨id⟩, so you can pull any of them with eve_read_memory. A cut result says so at the TOP, with the true total. Raise `budget` when you genuinely need the whole thing in one result; the floor is 1000. `all_spaces=True` searches ALL of your own cortexes at once and groups the results by cortex — for "which of my rooms has this?" when you don't know where something was filed. Shared cortexes are not included. It cannot be combined with `space` (that would be asking for one room and all of them). Archived cortexes are skipped and the count of them is reported; add `include_archived=True` to sweep those too.
eve_recall
Save a durable memory. One clear, self-contained sentence. Eve picks the memory's kind for itself — Event, Belief, Person and the rest — because the encoder reads the text as it files it. There is no kind argument to pass. If the shape matters, say it in the sentence ("Alexa believes…", "On Tuesday she…") and the encoder follows that. A ceiling, not a quota: most turns leave nothing durable, a rich exchange can leave several. Save what a FUTURE conversation would need — a preference, decision, identity detail, ongoing project, relationship fact — and let it settle first, one memory once it's clear rather than a card per turn. Skip chatter, your own replies, and this-conversation logistics. To attach a link at save time, pass `attach_url` plus `attach_title` — same URL-first rule as eve_attach. `attach` takes a plain locator ("their Google Drive, /Clients/Acme/plan.md") when there is no url, with optional `attach_kind`; a url passed there is treated as `attach_url`. To attach to an EXISTING memory, use eve_attach. `space` names a cortex. `wait=true` blocks until the encode is live, for harnesses that must recall it in the next step; default acks immediately and encodes in the background. `source` (optional) is WHERE this came from, in a few words, when you know it — "the grant draft thread", "their onboarding call". It is shown on the memory card. Leave it out rather than guessing: an empty source reads as "unsaid", and a wrong one is worse than none. It is a short label, not the conversation: long values are cut. Never save passwords, API keys, one-time codes, card or bank numbers, or government ID numbers, even if asked: Eve is not a secret store.
eve_remember
TEST-ONLY benchmark affordance — backdate ONE memory's origin timestamp to a real session date. Disabled in normal operation and restricted to the benchmark subject; for ordinary use it always refuses. It stamps the kind-correct origin column(s) so BOTH a recall row and eve_history show `date` for that memory. For an edited fact, pass the CURRENT version's id (the prior version keeps its own earlier date, so the version chain renders in order). `date` is YYYY-MM-DD or full ISO 8601. `space` names a cortex.
eve_set_memory_date
Copy ONE memory the person already has into a shared cortex, by name. Offer before you call this, or act on their ask. Nothing reaches a shared cortex by inference: their own memory is the default for everything, whatever it is about. It COPIES — their memory stays where it was — and the copy keeps the name of whoever WROTE it, not whoever shared it. `project` files it under a project that already exists on that cortex's board; pass it when the memory belongs to one. `from_space` names the cortex the memory is in now, if it is not their main one.
eve_share_memory
A memory's version history — the dated trail of prior values behind the current one. For "what did it used to be?", "how has X changed?", the timeline of a value: questions a current-value recall cannot answer. `memory_id` comes from an eve_recall row; any id in the chain works. Current value first, then earlier ones, each dated. `space` names a cortex.
eve_history
Write a NEW document into the user's Eve doc store and attach it to a memory as a clickable chip. Use it when you draft something FOR them that should live on a memory card — a guide, a plan, a write-up. `memory_id` comes from an eve_recall row; `content` is the full markdown body. To point at a doc that lives ELSEWHERE, use eve_attach instead — this one creates a new Eve doc. `space` names a cortex.
eve_write_doc

FAQs

Eve Cortex ChatGPT Plugin FAQ

How the directory, categories and Discoverability Score work.

Read the methodology

How do I improve Eve Cortex's ChatGPT Plugin discoverability?

The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.

What are Eve Cortex alternatives on ChatGPT?

As of 2026-10-16, Eve Cortex competes with 2Mind, AI Passport, AI Whisper Voice Note Taker, AI Wisebase, AiAkiv Memory, Arkon Vault, ASR (에사), Auto and 92 more in ChatGPT Personal AI Memory & Second Brain, ranked by public Discoverability Score.

Where is this profile measured?

This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.