Dot, Muse and Grok Bot now share one memory

We built Memspace at Graph Hacks so your AI assistants stop starting from zero. Here's how it works, and why it's an ontology sitting on FalkorDB.

Three assistants connected to one memory graph Dot, Muse and Grok Bot each connect to the Memspace server, which stores facts in a FalkorDB graph: Afshal Gulam works on Loop, and a dark-mode-first decision was made by Afshal about Loop. Dot OpenAI Muse Meta Grok Bot xAI Memspace MCP FalkorDB graph works on decided by about person Afshal Gulam project Loop decision Dark-mode-first UI
Dot, Muse and Grok Bot write to the same Memspace graph.

Between the three of us we use Dot, Muse and Grok Bot, and most days more than one of them. Each is good on its own. None of them knows what the others were told.

That got old quickly. Pranav would log meals with Dot, then have to tell Muse the same things again. Roshan only knew what Afshal had finished on their school project by messaging to ask.

So for Graph Hacks we built Memspace: one memory any of your assistants can read and write, which you can share pieces of with the people you work with. This post covers what it does, and spends most of its time on the two things underneath it, an ontology and FalkorDB.

01Two prompts and an MCP server

Memspace is a remote MCP server. Any assistant that can connect to MCP with OAuth can use it. We've run it with Dot from OpenAI, Muse from Meta, Grok Bot from xAI, and Codex.

Setup is the same everywhere. You sign up on the dashboard, open Connections, pick your assistant, and follow three steps:

Memspace · Connections
The Memspace dashboard's Connections page: pick Dot, Muse or Grok Bot, then step 1 Connect Memspace with a Copy install prompt button and the MCP URL, and step 2 Install the instructions skill with a Copy instructions skill button.
  1. 1

    Add the server

    Paste the Memspace MCP URL into your assistant and sign in with OAuth. No client secret, just your Memspace account.

  2. 2

    Paste the install prompt

    The assistant checks the connection by calling get_connection_status. Signing in through a browser isn't proof; a working tool call is.

  3. 3

    Paste the instructions skill

    It teaches the assistant when to save, recall, correct and share, and how to set up a timed check in its own scheduler.

After that you talk to your assistant like you always did. It saves what's worth keeping and tells you when it has. Everything any of your assistants saved shows up in one list, typed, and private until you share it.

Memspace · Memories
The Memories tab listing typed notes about the Loop project: an event, a decision, two tasks, a goal and a fact, each marked Yours.
The Memories tab on our demo account.

02Your assistants, finally caught up

Here's the first thing we wanted. Pranav uses Dot as a food log, and asked it to save yesterday's meals to Memspace, then to do the same every night at 10pm.

Muse had the same skill installed, plus a personal watch: a scheduled task that checks Memspace every 10 minutes for anything Pranav's other assistants saved. The next morning Muse already knew what Pranav had eaten the day before, popcorn included, without being told.

DotOpenAI

Add what I ate yesterday to my personal shared memory.

Saved yesterday's food intake, October 17, to your private shared memory, including the popcorn.

Do this every night at 10pm.

Set for 10pm Pacific every night. Each day's summary will be saved privately.

savedsource: dotprivate
MuseMeta
Memspace personal watch Every 10 minutes · other assistants' writes
Succeeded 9:10 AMSucceeded 9:20 AM

Dot saved your food log for October 17: a whey shake, chicken for lunch and dinner, and a medium popcorn. Roughly 2,700 calories and 178g of protein.

Pranav's setup from the demo. Dot writes, Muse's scheduled watch reads.

The trick is small. When an assistant connects, Memspace gives it its own client ID, and every memory remembers which assistant saved it. A personal watch only reports memories saved by a different assistant, so Muse never tells Pranav about something it saved itself.

The checks run in each assistant's own scheduler: a Scheduled task in Dot, a cron job in Muse, a routine in Grok Bot. You pick how often, anywhere from every 5 minutes to once a day.

03Your teammates' assistants, too

The second thing is the one we were most excited about. Roshan and Afshal are building a school project together, an app called Loop. Roshan created a shared space for it on the dashboard, invited Afshal by email as a contributor, and sent the invite link over.

From then on Afshal could share individual memories into the space. Each share is a choice; the rest of their memory stays private. When Roshan sat down to work on the UI, the first stop was one question to Grok Bot.

Memspace · Shared spaces
The 'A school project' shared space: shared notes about the Loop UI review, a dark-mode-first decision and a study-group screen task, with Roshan as owner and Afshal as contributor.
The space on our demo account, signed in as Afshal. Shared notes on the left, members on the right.
Grok BotxAI · Roshan's assistant

What has Afshal been doing for the project?

Afshal is leading Loop's UI design and front-end work. The aim is a demo-ready prototype covering 5 core screens by the end of October. They've planned an onboarding flow and a study-group discovery screen, which is still marked proposed, and decided the UI will be dark-mode-first with a single accent colour.

read from: A school project6 shared memories
Roshan's question from the demo. Grok Bot only sees what Afshal shared into this space.

So Roshan picked something else to build. No meeting, no "hey, what are you working on?" message. That answer came from facts, not a chat transcript, which brings us to the part of Memspace we spent the most time on.

04Under the hood: an ontology

An ontology is a shared model of a world: the kinds of things in it, how they can relate, and the rules for connecting them. Large companies use them for exactly this. A customer, an order and a supplier stop being rows in three different systems and become things with known relationships, so the people and the software are working from the same facts.

We wanted that for someone's personal life. Your assistants don't need a pile of old chats. They need to know that Afshal works on Loop, that a decision was made, who made it, and what's still only proposed.

13types
49relationships
1.2.0schema version
The Memspace ontology around a person Person sits in the middle. A person works at an organization, lives in a place, has skills in a topic, works on a project, wants a goal, practices a routine, owns or uses an item and owes an obligation. Events have participants, preferences belong to a person, decisions are decided by a person and tasks are assigned to a person. works at lives in has skill works on wants practices owns · uses owes has participant preference of decided by assigned to Organization Place Topic Project Goal Routine Item Obligation Event Preference Decision Task Person + 8 between people: knows, friend of…

People and places

Who and where. A name never links to someone's account.

Person Organization Place Topic

Work

Efforts, work items, outcomes and the choices behind them.

Project Task Goal Decision

Everyday life

One-off events, recurring habits, and preferences in context.

Event Routine Preference

Things and money

What you own or use, and who owes what to whom.

Item Obligation
Some of the relationships that meet at a person. See all 49.

The relationships are narrow on purpose. WORKS_AT means reported employment, not a job you want. ASSIGNED_TO doesn't mean the person accepted the task; that's ACCEPTED_BY. Visiting somewhere isn't LIVES_IN. These distinctions look fussy on paper. They're also exactly where a vaguer memory system would quietly invent facts about you.

One sentence, broken into facts

When you tell an assistant something, it calls remember. Memspace saves the note straight away. In the same write it queues a job, and a worker hands the note and the schema to a model (GPT-4.1 mini) with one request: return facts that fit. Every fact has to name a type and a relationship from the schema and quote the exact words it came from. If it doesn't validate, it's dropped and counted.

Afshal, to Muse I'm leading the UI design for Loop1. We decided it'll be dark-mode-first with a single accent colour2. I want a demo-ready prototype of the 5 core screens3. Maybe we'll add a light theme later4.

  • 1 personAfshal Gulam works on projectLoop
  • 2 decisionDark-mode-first UI decided by personAfshal Gulam

    plus: about → Loop, and the choice itself as a value

  • 3 personAfshal Gulam wants goalDemo-ready prototype, 5 screens
  • 4 no fact

    "Maybe" is a hypothetical. It stays in the note and never becomes a claim.

What the extraction returns for one message. The same facts appear in the dashboard's Ontology tab a few seconds later.

The model sees the author's own recent facts too, so "Loop" lines up with the Loop it already knows about instead of becoming a new project every time. It never sees anyone else's private graph.

Every fact keeps its receipt

Click any line in the dashboard and you get the sentence it came from, who said it, whether it's private or a shared snapshot, and which version of the note it belongs to. If the note gets corrected, the old facts drop out of normal results but stay in the history. If it's forgotten, its facts and anything shared from them go with it.

The details panel for one relationship: Loop UI dark-mode-first with single accent color, DECIDED_BY Afshal Gulam, the quoted sentence, reported by Afshal Gulam, basis explicit, visibility private, source revision 1, state active, and a button to share it into A school project.
Memspace · Ontology
The Memspace dashboard's ontology graph: an event and a decision linked to the Loop project, the decision decided by Afshal Gulam, a preference for short answers, and Afshal Gulam working on Loop.
Left: the details panel after clicking "decided by". Right: part of Afshal's private graph.

Negatives stay negative

"Pranav can't speak Tamil" is a fact too. Plenty of memory tools drop sentences like that, or worse, keep the positive half. We store the claim with negated: true, and the dashboard draws it in red as "not has skill".

The model is told to negate only what the note actually denies. "Doesn't drink coffee" isn't a negated dislike of coffee, and "Lee owes me" never turns into "I don't owe Lee".

Pranav, to DotI can't speak Tamil.

personPranav not has skill topicTamil negated: true
Stored as a negated HAS_SKILL, exactly how it shows up in the dashboard graph.

When nothing fits, it asks

Forty-nine relationships don't cover everything people say. When the extraction can't find one that fits, it can propose a new one instead of forcing the fact into the wrong shape.

proposed

Extraction suggests a new relationship

Say someone writes "Roshan mentors two first-years". Nothing in the schema fits, so the model proposes MENTORS, from person to person. At most three per note.

provisional

Usable straight away

The fact is stored and searchable. Later notes reuse MENTORS instead of inventing COACHES; names with the same root, like SPEAKS and CAN_SPEAK, collapse into one.

reviewed

A person decides

approveIt becomes a normal relationship.
mergeExisting facts are rewritten to an existing one.
rejectIts facts are retired and unshared.
To stop the schema sprawling, each person can add five a day and only 100 can wait for review at once. The example is ours, for illustration.

Teammates meet at one node

Private graphs are never merged. Your "Afshal" and Roshan's "Afshal" are separate nodes, because a matching name isn't proof it's the same person.

Shared spaces are different, because there we know exactly who the members are. When a shared fact mentions a person and the name matches exactly one member (their full name, a first name nobody else in the space has, or the author talking about themselves), it points at that member's node. If two members are called Alex, it links to neither.

Roshan's note, shared

Afshal is handling the Loop UI.

mentions "Afshal"
Afshal's note, shared

I'm designing the onboarding flow for Loop.

mentions "I"
Afshal Gulammember of A school project
Two authors, two ways of naming the same person, one node in the space. When someone joins or leaves, the space is re-linked.
Memspace · Ontology · A school project
The Ontology tab scoped to A school project: Afshal Gulam is shown as a person and member, decided the dark-mode-first decision, wants the demo-ready prototype goal and works on Loop; tasks and an event are part of Loop.
The shared space in the dashboard's Ontology tab. Afshal appears once, marked as a member.

05Why it all lives in FalkorDB

Every part of Memspace is one FalkorDB graph: people, memories and their versions, shared spaces, every fact, the search indexes, and even the queue of extraction jobs.

FalkorDB is a graph database. It stores data as nodes and the relationships between them, you query it with Cypher, and it has full-text and vector search built in. That last part mattered more than we expected. Three things in Memspace can't work without it.

You Space Memory MEMBER_OF SHARED_IN Removed active: false, no path

Permissions are paths

There's no access table. You can read a memory if you wrote it or a live path reaches it through a space. Removing a member flips one edge, and their next read comes back empty.

? match Loop note note

Recall follows relationships

Recall finds keyword matches, then hops one edge through the people, projects and spaces they mention. It returns related notes that share no words with the question, and says what connected them.

full-text vector fuse path check

Search runs inside the graph

Facts are found by full-text and by meaning (768-dimension vectors in an HNSW index), merged by rank, and every hit is checked against the same permission path before you see it.

Here is the permission check itself. It's appended to every memory read, and to every hop recall takes:

Can this person read this memory?src/memory.ts
MATCH (m:Memory {id:$id})
OPTIONAL MATCH (m)-[:SHARED_IN {active:true}]->(:Space)
               <-[membership:MEMBER_OF {active:true}]-(:Person {id:$user})
WITH m, count(membership) AS memberships
WHERE m.deletedAt IS NULL AND (m.owner = $user OR memberships > 0)
RETURN m

FalkorDB plans it as an index lookup on the memory followed by two traversals to the reader, so its cost depends on that memory's own connections, not on how big the graph is. Each person and each space also gets its own search index, so someone else's vectors never crowd yours out of the results.

FalkorDB Browser · shared_memory_demo
FalkorDB Browser showing a sample Memspace graph: people, their memories, the entities they mention, and a shared space.
A sample graph in FalkorDB Browser. npm run graph:demo in the repo builds it through the product's own code.

Pushing to assistants didn't work out

Our first version tried to notify teammates' assistants with webhooks. Every host handles them differently, and we pulled it out. Letting each assistant check on its own schedule turned out simpler, and the assistant is the one that knows how it wants to be woken.

Names are a trap

Merging people by name is tempting until you picture two Alexes in one space. In Memspace a name links to a person only inside a space, and only when exactly one member matches.

Make the model quote

Every fact has to carry the exact words it came from, or it's dropped. A quote doesn't prove the model read the sentence right, but it gives you something to check. On our eight synthetic test cases GPT-4.1 mini got all eight, in 0.6 to 7.3 seconds each. Eight cases is a regression check, not a benchmark.

Read the database's fine print

FalkorDB's vector search returns a distance in a column called score, so lower is better. A newer version rejected an inline {id:$space} right after an index call. The full list is here.

Some things are still rough

The same project mentioned in four separate notes can show up as four "Loop" nodes, because we'd rather leave them apart than merge on a guess. Recall only expands one hop. Its first step still scans every memory.

Dates are harder than they look

In our demo space, "end of the month" was stored as 23:59 UTC on October 31, a time zone nobody gave. Grok Bot noticed and said so while summarizing the space. The extraction rules tell the model to leave relative dates vague rather than invent a timestamp.

07Try it

Memspace is live and the code is open. Sign up, connect whichever assistant you use, and tell it something worth remembering.

We built this for FalkorDB's Graph Hacks, in the Agent Memory and Coordination track. If you try it and something breaks, open an issue. We'd like to hear about it.