Okay, we're here in a remote studio with Dravia Shah of SuperMemory.
Welcome to Lanespace.
Thanks for inviting me.
Yeah, obviously you've been blowing up on the timeline for multiple years now.
I just found out you launched SuperMemory in 2023.
It feels shorter than that, but also you've been doing this for a while.
Yeah, I've been in this space for way too long.
SuperMemory has been many different products, but now it's everything at once.
I'll get back into that, but yeah, lots of things.
So what is this, Laura?
We looked back at your first Product Hunt launch.
You can show us.
What was it originally?
Let's let's walk back from there.
So super memory launched as this consumer app that was supposed to be your kind of uh, better bookmarking or note-taking tool with a few other features.
So for example, you can take your memories across LLMs, and this is from very long ago.
So we had an MCP launch, and then we had another launch for the app itself.
So earlier, obviously, it was just the app, which was like a save.
You can save things to the app.
You can get things from the app.
Very simple as that.
And then we were like, okay, MCP is a thing now, so we should probably make an MCP out of it.
And this was a time when I personally was doing internships.
I was working at Cloudflare at the time and this was a side project that I did as a part of this thing called BuildSpace.
BuildSpace, you might know about BuildSpace.
It was like this place where a lot of builders used to build things nights and weekends.
And they really pushed you to building something and like talking to users and stuff like that.
It's like a gen z accelerator that, like they, the founder just gave up and just like moved on exactly.
So i was in both season three and season five of birdspace and i open sourced super memory during birdspace and it, like the project, absolutely blew up.
It got like you know, it was one of the biggest projects, like fastest growing projects of 2024.
And I kept tweeting about how I'm running this on Cloudflare on $5 a month budget.
And it was still a consumer app, but then I kept adding features to it.
So earlier, the way the world used to think of memory and how we used to think of memory was just ragged.
So you just embed it, put it in a vector database, and that's all you need to do.
And then I dug down the rabbit hole.
So vector databases at that time and even now, except a few like TurboPuffer and Chroma, were not really scalable for the scale I was getting to, where they were either getting too slow or too expensive to run.
And so I had to find other creative ways of making it really cheap for me to run.
And I kept tweeting about all of this.
So my tweet was like I run SuperMemory on 5 a month and I have 100000 users and this is my architecture.
So it was like an entire diagram.
And that blew up.
That was the first famous SuperMemory event.
And that led to not people being interested in the app itself, people being more interested in the infrastructure that I was building.
Yeah, i remember you open sourced it and then i was like oh yeah, i need to start and fork this because i'm like like if i ever need this, i need, i need this uh, setup exactly exactly.
So after starting it and like after that open source, you know, it blew up to like 10 000 stars in a few weeks.
But then i realized, like you know, a lot of companies were reaching out to me.
They were like hey, can you help us set up our memory thing?
And i also went and worked at other memory companies and it became like this entire thing, that like i was doing pretty much a lot of consultation, work around context engineering um, and i realized like all of these have very similar use cases, but with slightly different flavors, where they they not only need retrieval, they need like like true user understanding and we'll get get to that as well.
Like what is modern memory?
You know?
Like how should?
Yeah, i remember.
And then i was like okay, So to make an LLM truly good at understanding a user, you have to handle four things.
One is knowledge updates.
So you have to invalidate stale knowledge and build on top of it, which is different from the storing vectors.
You have to have some sort of temporal reasoning.
So you have to give the agent an understanding of time and how things have passed for personalization.
And you need some sort of forgetfulness to forget things that are not relevant anymore at all.
But you also need this concept we call user profiles to always, like memory is not just a retrieval call.
The lm has this very small profile of the user that will utilize on every single tone.
So i was building all of these components into super memory and on all of these apps and i realized that okay, there are some really difficult infrastructure challenges to be solved here, which is both on the extraction layer, which is how do you truly like you know, how do you train a small model that can extract things about the user and maintain the second layer, which is the knowledge graph, and the way we built our knowledge graph is different from how people usually build knowledge graphs, so People usually have this concept of triplets.
Triplets.
Object, predicate, objective.
Exactly.
Object, predicate, object, or entity, relation, entity.
And we think that triplets actually lead to worse performance because you have to traverse them a lot to get to any information.
This is the learning of every graph guy ever.
Exactly.
Exactly.
So to find out what food does Dravya like, you have to first get to the entity Dravya and you have to traverse one or two layers deep to find out.
Dravya likes food, Dravya enjoys this thing, etc.
And that leads to extremely slow and like, this is just unnecessary.
So we built our own knowledge graph.
We built our own extraction pipeline.
And I was like, this consumer app is probably not useful anymore.
This core infrastructure is more useful now.
And that is our core business now.
And that's what we offer.
Amazing update, I think.
One of those things where like, I think we can get more into it.
What is SuperMemory today?
Like, is it a cloud business?
Is it a VC backed company?
You know you're.
You're a young founder like tell people more just about the company itself and what it is today.
Cause obviously we spend a bunch on the background.
Yeah.
Yeah well, I should have done this before, but I'll give a little bit of an intro about myself first.
So I'm Dravel, I'm currently 20 years old.
Before this, I was working on agents and databases and a bunch of other things at a few companies, including Cloudflare, Hypefury and others.
I had two companies acquired and I came to the U.S.
So I built SuperMemory again as this thing, raised $3 million last year.
And since then we have been a VC backed cloud business that's mostly open source actually.
And we are trying to build a context infrastructure for the AI era.
And so what do I mean by context infrastructure, whatever external context or like that the agent would need, including just retrieval, to like user understanding memory, etc.
Like sales improvements self-learning, personalization.
We provide all of these in this one single tool, which is subman, because the way we structure the data, we can automatically provide all of these facets Because again, every single memory use case would require a different way of implementing it.
And so We do that for developers.
We provide an API for people to use, but we also still have a consumer-facing app which the idea is that you have your own memory that you can utilize across everything you use, or you can add soup memory to your agent to make it much better at remembering things.
So, for example, the open claw thing was blowing up.
Our cloud code blew up as well.
It got like 2 million impressions.
Um, both of them were kind of this consumer-facing plugins that we offer.
Yeah, it's really impressive to watch.
I think a lot of people, I'm going to put OpenClaw in the title of this thing.
Let's go right into the OpenClaw thing.
Let's do it.
There's more to go into SuperMemory.
I think more people can check it out.
You've published a lot of stuff.
But the topic of the moment is I think, was it a peter levels or something?
Someone is having problems with open core memory.
Everyone, everyone has been.
And then they're like wow okay, how do you do it?
And then, and then there's like all these different answers and i'm like wow, this is really not solved.
Yeah, exactly.
Okay.
So tell everybody what's going on.
All right.
So let's first talk about how open clock currently handles memory.
And I have, like this little cloud artifact that I prepared for my article.
But so the way open flaw has with qmd or with whatever memory plugin you use, it inherently relies on tools to search through these memorymd files that it prepares.
So what did I decide about the API?
Then agent will decide to search, and sometimes it won't decide to search, which is probably the biggest problem here.
And then it will get some results, it will do some scoring, and then it will return it back.
And the search right now is through the memory.md files or the memory folder.
So if the agent decides to not remember things explicitly, it will never show up in the results, because you don't know what to remember at injection time.
So there's a bunch of issues here.
And because these files are static, they don't handle updates.
They don't handle the forgetfulness I was talking about.
There's no temporal reasoning.
You cannot look at particular parts of the file because you don't know what is where, and other problems like that.
This is the reason why everyone is complaining about open clause memory.
This to me is surprising, because when people complain about OpenClaw's memory, or when OpenClaw even did the memory, people didn't like look into how exactly and why it's bad.
So we did all of this digging in.
And we were like, okay, what is the right way to do memory?
And we already had these plugins for cloud code, for open code.
So we had a lot of learnings about how agents should be stateful.
So we basically turn the tools-based approach to hooks-based approach.
That actually is reading from the soup memory graph, which keeps the content fresh.
So it handles updates, et cetera, et cetera.
So now you know, for every tool call or for every user message, a hook automatically will put less than 2000 tokens worth of information dynamically.
Um, so the entire context will not have more than 2000 super memory tokens and optionally it could also do a tool call if it needs more information.
And we have like contradictions resolution, we have temporal reasoning and all of that built in.
So the information is always truly fresh, no matter what.
That's the gist of it.
But we can dive more into it, because there's some things that are not in this diagram that we also do.
So yeah, that's kind of the simple why SuperMD is better.
QMD is from Toby Luca, which is really super impressive.
I think it's a very interesting... Basically...
Toby wants to do everything locally.
You obviously are Cloudflare maxi, so you're going to do it on Cloudflare.
So obviously that's a fundamentally different thing.
I think hook-based is probably right, because obviously models make mistakes and I get very, very frustrated when I use Grok in XAI and it doesn't search tweets.
Like dude.
There's only one reason I use Grok is to search tweets.
Yeah, you have to like, ask it like, please use these tools.
And most of the open claw users don't even know that tools are a thing, so they don't want to think about the tools.
So yeah, you think, do you perceive that they're non-technical?
I mean it's so, you know.
Especially, you know a lot of people have been seeing that technical in the engineering sense, but they're not technical in the agents world.
I think we're in a huge bubble right now.
And like, they won't know that, okay, this is exactly what's going on behind the scenes.
Like they will not even look into it.
So yeah, it's just curious because, as an engineer, you should, obviously you, and I think that this is the only thing that's interesting, but you know there's many other engineers who have real life yeah so okay, I think, other than this, there's another memory discussion That I think Cursor and Claude, those guys have been saying, which is like sort of file system based memory, right?
Like where you just you put, you dump a bunch of whatever dot empty into your file system and then you wrap over it.
And OpenClaude has some compaction, right?
Like some, some heartbeat stuff.
What are your takes on all those things?
So I think file system memory is actually the right way to do things in a lot of cases.
Like for most cloud code users, that is probably the right thing to do.
But you still have the same problem of you have to know what to remember in order for it to remember things.
So you have to explicitly mention that, okay, please remember this or please bring this up.
And it's limited by the files themselves.
So the files can get longer and longer. so that becomes a problem so you have to split between many files and the files still don't have any update logic etc etc unless you explicitly have the agent do that they're also really slow to traverse through so you'll have to do agent discovery to find out any context to answer any question like for example if i have something like implement its workflow it will have to you know first look through everything it knows in the memory all the workflows etc etc and then it comes to the answer now i think this is a very hot take but i think that they could like one is personalization which i'm talking about but then there's also code indexing and they could index the code and cursor does but plot code does not and i believe this is also because they are not incentivized to utilize less tokens by the end user because They're just offsetting the cost of indexing, et cetera, et cetera, to tokens and time that the user takes to run the agent, which is what they want. theoretically, you could add like code indexing, you could add personalization, it will be much better and faster.
And I'm not just saying it.
We actually ran a benchmark just yesterday.
I published this blog.
I'll share my screen again.
I published this like extremely technical report which also kind of blew up, but we ran a benchmark on longman url against three things.
Oh, the screenshot is in one of the quote tweets.
I think uh, how do i view quotes?
Twitter ui keeps changing here.
Um, So the Cloud Code one performed the worst and OpenClaw slightly more than that, and SuperMemory is the highest.
And you can see that, you know, it's like a pretty significant difference, like almost 50%.
Let me clarify.
This is your reproduction of the Cloud Code method and your reproduction of OpenClaw, or you actually use Cloud Code.
No, it is our reproduction.
So it's like pretty much important to say, yeah, it is pretty important.
And, uh, you know, we also think that benchmarks should not be trusted and cannot be trusted.
So like, you know, you should not listen to me actually.
So we build this open source kind of benchmarking evaluation platform, like Grok's open bench.
It's called memory bench. which I'll also share my screen.
So this is our implementation of exactly how it's doing.
In fact, we also literally went into it.
We implemented open clause hybrid method with the same formula, with the same everything.
And you can just view the PR to find out exactly what's being done.
But, in short, this memory bench is a way to benchmark any providers against any benchmarks, against any judge on the same kind of the base rules.
And this lets you quantify all the things.
So not only the quality of how the memory system performs, but also the latency, cost and other, like you know, juristics like the top k recall ndcg, etc.
So this is like a really good way of doing, you know, benchmarks for me and it makes it really simple as well.
I actually ask every single competitor to use this, because it actually makes it easier for our competitors to compare against soup memory as well.
Yeah, I think that's a very good infrastructure.
Okay, yeah, people should try that out.
Other than, just while we're on the topic of benchmarks and all that, there's Longman Mivel.
What's not so good?
Whatever you want to say.
Yeah, so I think we are still not there in the memory benchmarks space.
And there's a lot of reasons behind this.
I might also write a detailed post about this, but I think that launch Longman Meval is a very good benchmark because it calculates, it tests for the right things.
It tests for the right things.
The data set is great.
Everything is really good in Longman Meval, except for the fact that you can win Longman Meval by remembering as many things as possible.
Like there's a direct correlation to the number of memories extracted and the score you get on long memory.
Um, that doesn't seem because yeah, it's not too bad but, like in real world, you would spend more costs.
Like in real world, you don't want to extract everything, because extraction is not free.
To win against the benchmarks.
So it's good for like, some use cases, but in the real world that's not how people expect memory to work.
So we think that that's fine.
But long memory also does not test for forgetfulness, because how would you test if something should be forgotten or not?
It tests for updates, but not forgetfulness and a few other things.
So we still use longman well, because that's the best we have.
Then there's locomo, and locomo is like really bad because like and and people actually it's not just me, like pretty much everyone knows that locomo is not the right thing to do.
I don't know why.
So the the reason is like locomo is essentially testing for retrieval capacity and it's not testing for the real memory things like you can essentially just context dump everything in locomo and get like 100 in the latest models.
So one is the there's only 30 questions like the data set is really small.
Second is it does not test for like knowledge of great temporal reasoning multi-session, all of the other things like the important things, like preferences.
It doesn't test for anything but retrieval and like in gemini, flash or whatever, like you can just literally the, the questions, the sessions themselves are short enough that you can put the entire session in these context lands and it will work right away.
So i think and it's also very old now like in that age it probably didn't make sense, but now it's been three, four years since that and the models have gotten much better.
There's also ConvoMem, which I actually like.
It's a really good one.
It's by Salesforce and it tests for more assistant-y use cases, like assistants should do both RAG and memory, et cetera, et cetera.
So that's pretty good.
Sometimes you need both, which I also want to come to actually, but that's what I think about the benchmark space.
There's one important thing, which is there's no concept of benchmarking user profiles.
So all of these benchmarks are very retrieval, heavy like factual information.
Yeah, like you, you essentially want to, you know, fetch something, get an answer, answer the question.
But that's not all use cases.
I'll show you one, a slide, real quick, which will make this very clear.
I have it ready right here luckily, So traditionally, you have this retrieval thing that happens.
So you get a question, you retrieve something and an answer is generated based on that.
But we think that it will not work for most non-literal questions like find the best monitor for me.
If I've never spoken about a monitor, which I probably have not, it will not return anything.
It'll be like oh, it'll give some generic answer, but agent probably needs to know a lot of default things about me at all times, like user is a ceo.
But it also needs to know some episodic information, like users recently raised fund fundraising, moved into a new office last week, etc etc.
And in which case it will be like oh, you code all day and you just moved into an office, so this is probably the one that you should buy.
It's a little expensive, but this is the one for you And this can only be done if you really have like a very, extremely small, like 500 token information about the user that captures both the static things and the episodic things, like some recent episodes that's been going on.
And we also have this built into SuperMemory.
But there's no way to benchmark it.
Yeah, it's basically personalization, right?
So it's a bit hard.
Okay.
You know, I just want to close the loop on anything OpenClaw related.
I think people are using a lot of things.
What other issues crop up?
Like things like secrets, things like context confusion, if they've done like similar things.
You know, like there's a trade-off between retrieval and accuracy, or recall and accuracy, right?
Yeah, do you do you find these kinds of things?
And like, what are people doing?
Yeah, so I think like.
So the way OpenCloud does it is it essentially sends back the last 15 messages in the conversation.
And it essentially uses that back and forth.
And I mean the approach itself is not ideal because you will, like you are not doing any, like you're not utilizing any cash tokens, and because you're not utilizing the cash, you're essentially paying like insanely, like 10x more than if you would do it the right way.
So that is always a problem.
So, like we think, but that's like an open floor issue, you know, we cannot really do anything about that.
The other thing is, people are giving it access to their secrets and stuff like that and we have to like, as a memory system, we have to like make sure that no secrets end up to us.
Like in any case um, a lot of users in open cloud claw also have like really like browsers attached and stuff like that and heartbeats and heartbeats are all going on, you know, every hour, and the heartbeats are also ending up in memory, causing some pollution.
And some people want to use their open claw memories along with their clock code memories and we actually don't want to do that.
Like it should be siloed, like it's their own things, but people want that.
So we are offering configuration recall wise.
Like you know, super memory sometimes does not end up giving the right results and that's why we recently shipped a new thing for openclose.
It was a huge learning experience for us.
It's called hybrid mode.
There's always a state of between what you want to remember.
In a memory system, you always have to choose exactly what you want to remember, which is important because you want to keep them updated, you want to keep them fresh, you want to forget things, but sometimes the user you don't know what the user will ask about.
Sometimes the user will say something that was not remembered, it was not very significant.
So how do you handle those cases?
So the way we do it is, we have because we do both memory and like managed drag we can show up the memories if they exist, but we have a fallback to drag answers like it will just return the raw chunk if so many did not remember it and then in the background, it will add that to the memory as well.
So this, this essentially gives you, like you know, like we say, that so many should almost never forget anything because of the fact that we are always giving the agent the right context as long as the user is asking for it.
So yeah amazing, are we going to the hybrid stuff?
Yeah, so this was the hybrid stuff.
So essentially, you will return the memories first.
And then if there's any raw chunks that match up, we also return those to make sure the agent knows just enough information to answer the question, and no other provider does this right now.
So yeah, how important is cost like?
My perception is, people are very cost insensitive, but you obviously, like anyone who is like a real engineer um, does care about cash, hits and all that.
Uh, i don't know, do people care?
Yeah, I think people care a lot about cost actually,
Okay.
I think again.
We are in a huge bubble and a lot of our users, especially they, do care about the cost because
Because people would compare a memory system against the LLM they use.
So if the memory system is, you know, 10 for a million tokens and LLM they use is 2 per million tokens, it will be like oh, like this does not make sense to use.
It's too expensive.
I should not use this.
This happens to us and we want to make sure that like, we're giving them a lot of, you know, a lot of satisfaction on, like they should be happy about using super memory and it should not be something that you know they have to be concerned about.
So for us, we have optimized infrastructure down to it costs us two cents 400 million tokens, because we have our own model, our own database, our own everything.
So we have to price our users also really low, which we do.
So yeah.
Okay, cool.
That's a really good sort of masterclass in everything sort of memory, state of memory, including a side tangent on evals and all that.
What's next for SuperMemory?
What are the open directions for 2026 that people should think about?
Yeah, so 2026 was the year we realized that the prosumer aspect of super memory is something that people are really excited about, like this idea of having this one memory that you can connect everywhere, you can interrupt between providers, and stuff like that.
And we are continuing to do things like that, like we're going to launch the plugin with cursor today and we already have the claw open claw open code.
All of those that's good.
Next up, we are going to do a launch on voice agents, partnering with pretty much every voice agent company, because of the fact that super memory is so fast at the work it does, so it's really good for wise.
Um, That would be amazing.
We are doing more on evals.
We are building our own eval.
We are going deeper into personalization because we think that no one has done a lot of work in personalization yet.
And a lot of other, like we are building a new version of our database.
So yeah, it's going to be really exciting.
Cool.
Well, thanks for jumping on.
I think this is a great introduction, at least for Laterspace listeners to SuperMemory.
Obviously, you've been plenty famous on your own with your projects, but I think I already invited you to World's Fair.
We'll see you do more talks for that kind of stuff.
And I think just generally, I'm starting to see real startups and people taking memory seriously, compared to two, three years ago when it was all like vector data.
That was a joke, i think.
So it's really good.
Uh there's, there's more coming.
You know like the land chain has their own take.
Yeah,
You know, I think all the others.
There's Letta, Longchain, Memzero, ZEPP.
Yep.
Both Letta and ZEPP have done workshops.
So I think it's your turn.
Yep.
Amazing.
Looking forward to that.
Okay, cool.
Good to catch up and I'll see you online.
Great.
Thank you so much.
