[Host]: Okay, here we're here in a remote studio with Dravia Sha of Super Memory. Welcome to Lane Space.

[Dhravya Shah]: Thanks for inviting me.

[Host]: Yeah. Uh, obviously you've been blowing up on on the timeline for multiple years now. I just found out you launched Super Memory in 2023. It feels shorter than that, but also you've been doing this for a while.

[Dhravya Shah]: Yeah, I've been in the space for way too long. Super Memory has been many different products, but now it's everything at once. I I'll get back into that. But yeah, lots of things.

[Host]: Okay. So, so what is this Laura? Can can uh we looked back at your first product hunt launch. You can show us what was it originally.

[Dhravya Shah]: 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 and note-taking tool with a few other features. So like for example you can take your memories across LLMs and this is from very long ago. So we had a uh 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 Bispace. And Bspace uh you might know about Bispace is 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.

[Host]: Yeah. That's like a Gen Z accelerator that like they the founder just gave up and just like moved on.

[Dhravya Shah]: Exactly. So I was in both season 3 and season 5 of Bspace and I open sourced Soup Memory during Bspace 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 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 we the world used to think of memory and how we used to think of memory was just rag so you just embed it put it in a vector database and that's all you need to do and now then I like dug down the rabbit hole and so so vector databases like at that time and even now except a few like like Turppuffer 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 you know find other creative ways of making it really cheap for me to run and I kept tweeting about all this so my tweet was like I run soup memory on $5 a month and I have 100,000 users and this is my architecture so it was like an entire diagram and that blew up that was the first kind of you know uh famous super memory event and that led to not people being interested in the app itself, people being interested in the infrastructure that I was building.

[Host]: Yeah. I remember you open sourced it and then I was like, "Oh yeah, I need to star and fork this cuz I'm like if I ever need this, I need I need this uh setup."

[Dhravya Shah]: Exactly. Exactly. So after starting it and like after that open source, you know, it 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. and 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 true user understanding. And we'll get get to that as well like what is modern memory you know like how how should AI 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 have like 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 LLM has this very small profile of the user that it will utilize on every single turn. So I I was building all of these components into supermember and and all of these apps and I realized that okay there's 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 we build a knowledge graph is different from how people usually build knowledge graphs.

[Dhravya Shah]: So people usually have this concept of triplets.

[Host]: Triplets

[Dhravya Shah]: where they have

[Host]: object predicate object.

[Dhravya Shah]: 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 and

[Host]: this is the learning of every graph guy ever.

[Dhravya Shah]: Exactly. Exactly. Okay. So you have to like to so to find out like okay what what food does dra like you have to first get to the entity DA and you have to traverse one or two layers deep to find out like okay D likes food enjoys this thing etc etc and that leads to extremely slow and like this is just unnecessary. So we built our own knowledge graphs 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.

[Host]: Amazing update. Um I think one of those things where like I think we can get more into it. Uh what what is super memory today? Like is it a cloud business? Is it a VCbacked company? You know you're you're a young founder like tell people more just about the company itself and and what it is today because obviously we spend a bunch on the background. Yeah.

[Dhravya Shah]: Yeah. Uh well I I should have done this before but uh All right. I'll give a little bit of an intro about myself first. So I'm Draville. 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, High Fury and others. I had two companies acquired and came to the US. So I built super memory again as this thing raised $3 million um 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 self-improvement self- learning personalization We provide all of these in this one single tool which is super memory 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. Um and so we do that for developers. We provide an API for people to use, but we also still have a consumerf facing app which the the idea is that you have your own memory that you can utilize across everything you use or you can add soap memory to your agent to make it much better at remembering things. So for example, the open clothing was blowing up or claw code blew up as well. It got like 2 million impressions. Um both of them were kind of this consumerf facing like plugins that we offer.

[Host]: Yeah, it's uh it's really impressive to watch. I think a lot of people I'm gonna put open call in the in the title of this thing. Let's let's go right into the open call thing. You know, there there's there's more to go into super memory. 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 Peter levels or something? Somebody was having problems with open call memory.

[Dhravya Shah]: Everyone everyone has been

[Host]: and then they're like, well, 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.

[Dhravya Shah]: Yeah, exactly.

[Host]: Okay. Okay. So, so tell everybody what what's going on.

[Dhravya Shah]: All right. So, let's first talk about how OpenCL claw currently handles memory. And I have like this little claw artifact that I prepared for my article. But so the way OpenClaw has with QMD or with whatever memory plug-in you use, it it inherently relies on tools to search through these memory. MD files that it prepares. So you know like 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. So and this search right now is through the memory MD files or the memory folder. So if you 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 uh like 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 like you know this is the reason why everyone is complaining about open clause memory. This to me is surprising because when people complain about open clause 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 turned 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 etc etc. So now you know for every tool call or for every user message a hook automatically will put less than 2,000 tokens worth of information dynamically. Um so the entire context will not have more than 2,000 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.

[Host]: QMD is is from Toby Luca which is like really super impressive. I think it's a very interesting basically Toby wants to do everything locally. You you obviously are Cloudflare Maxis. are you going to do on Cloudflare? [laughter]

[Dhravya Shah]: Yeah.

[Host]: So obviously that's like a fundamentally different thing. I think hookbased is probably right because obviously models make mistakes and I get very very frustrated when like I use Grock in XAI and it doesn't search tweets. Like I'm dude there's only one reason I use Grock is it search tweets.

[Dhravya Shah]: 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.

[Host]: Do you think do you perceive that they're not technical? I mean is

[Dhravya Shah]: so you know

[Host]: especially you know a lot of people have been seeing they're technical in the engineering sense but they're not technical in the agents world. I think we're in a huge bubble right now

[Dhravya Shah]: and like they won't know that okay this is exactly what's going on behind the scenes like they would not even look into it. Um so yeah

[Host]: it's just curious because as an engineer you should this is obviously you and I think that this is the only thing that's interesting but uh you know there's many other engineers who have real life. Yeah. So, so okay, I think other than this there's another memory discussion that I think cursor and claude those guys have have been saying which is like sort of file system based memory right like where you just you put you dump a bunch of

[Dhravya Shah]: whatever empty to your file system and then you wrap over it and

[Host]: open claw has some compaction right like some journal some heartbeat stuff what are your takes on all those things

[Dhravya Shah]: so I think file system memory is actually the right way to do things in a lot of cases like for most claw code users because 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 agentic discovery to find out any context to answer any question. Like for example, if I have something like implement this 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 flot 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 etc etc to tokens and time that the user takes to run the agent which is which is what they want. So theoretically you could add like code indexing, you could add personalization, it would 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. Um I published this like extremely technical report which also kind of blew up but we ran a benchmark on long against three things. Oh, the screenshot is in one of the code tweets I think. Uh how do I view quotes? Twitter UI keeps changing here. Um so the claw code one performs the worst and open class slightly more than that and super memory is the highest and you can see that you know it's like a pretty significant difference like almost 50%.

[Host]: Let me let me clarify this is your reproduction of the cloud code method and your reproduction of open claw or you actually use cloud code.

[Dhravya Shah]: No it is our reproduction. So it's like pretty much

[Host]: important I say yeah

[Dhravya Shah]: 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 built this open-source kind of benchmarking evaluation platform like Gro's open bench. It's called memory bench which I'll also share my screen. So we like this is our implementation of exactly how it's doing. In fact we also literally like 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 BL 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 uristics like the top K recall NDCG etc. So this is like a really good way of doing you know benchmarks for memory 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.

[Host]: Yeah, I think that's a very good infrastructure. Okay. Yeah, people should try that out. Other than uh just just while we're on the topic of benchmarks and all that, there's long memory val um what's not so good. Whatever you want to say.

[Dhravya Shah]: 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 long my mal 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 long mual except for the fact that you can win long meal 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 meal. Um that doesn't seem bad

[Host]: because

[Dhravya Shah]: yeah it's not too bad but like in real world you would spend more cost 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 also does not test for forgetfulness because how would you test if something should be forgotten or not? It test for updates but not for forgetfulness and a few other things. So we still use long man well because that's the best we have. Then there's locomo and locomo is like really bad cuz like and and people actually it's not just me like pretty much everyone knows that locom is not the right thing to to say. 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 the data set is really small. Second is it does not test for like knowledge upgrade, temporal reasoning, multi session, all of the the other things like the important things like preferences. It doesn't test for anything but retrieval and 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 lens and it will work right away. So I think and it's also very old now. Like in that age it it probably did make sense but now it's been 3 4 years since that and the models have gotten much better. There's also convo me which I actually like. It's a really good one. It's by Salesforce and it tests for more assistanty use cases like like assistants should do both rag and memory etc etc. So that's pretty good and sometimes you need both which I also want to come to actually but that's what I think about the the the benchmark space.

[Dhravya Shah]: There's one important thing which is there's no concept of benchmarking user profiles. So all of these benchmarks are very retrieval heavy

[Host]: like factual information.

[Dhravya Shah]: 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 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 nonliteral 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 user 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 theodic things like some recent episodes that's been going on. And we also have this built into Super Member, but there's no way to benchmark it.

[Host]: Yeah, it's basically personalization, right? So, it's a bit hard. Okay. Uh, you know, I just want to close the loop on anything open claw 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 there's a trade-off between retrieval and accuracy or like recall and accuracy, right?

[Dhravya Shah]: 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 going 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 so that but that's like a open floor issue you 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 claw code memories and we actually want 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 Otherwise 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 open claw so it was a a huge learning experience for us so it's called hybrid mode there's always a trade-off 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 rag we can show up the memories if they exist but we have a fallback to rag answers like it will just return the raw chunk if sum 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 summe 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.

[Host]: Amazing. Are we going to the hybrid stuff?

[Dhravya Shah]: Yeah. Yeah. So this was the hybrid stuff. So essentially you we'll 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.

[Host]: How how important is cost? Like my perception is people are very cost insensitive but you obviously like anyone who's like a real engineer um does care about cash hits and all that. Uh I I don't know I don't do people care.

[Dhravya Shah]: Yeah I think people care a lot about cost actually. Okay. Like I think again we are in a huge bubble and a lot of our users especially like you know they do care about the cost because like 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 the LLM they use is $2 for a million tokens, it will be like oh like this does not make sense to use. It's too expensive. I should not use this. And this happens to us and we want to make sure that like we're giving them a lot of you know lot of satisfaction on like they should be happy about using memory and it should not be something that you know they have to be concerned about. So for us we have optimized our infrastructure down to it cost us 2 cents for a 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.

[Host]: Okay cool. It's a really good sort of master class in everything sort of memory uh state of memory including a side tangent on on evals and all that. What's next for super memory like what is sort of the open directions uh for 2026 that people should think about?

[Dhravya Shah]: Yeah, so 2026 was the year we realized that the proumer aspect of memory is something that people are really excited about. like this idea of having this one memory that you can connect everywhere you can interop between providers and stuff like that and we are continuing to do things like that like we're going to launch the plug-in 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 at the work it does so it's really good for Um that would be amazing. We're doing more on evals. We're building our own eval. We are going 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 of our database. So yeah, it's it's going to be really exciting.

[Host]: Cool. Well, thanks for jumping on. I think this is uh a great introduction at least for space listeners to Super Memory. obviously like you've been plenty famous on your own with your with your projects, but I I think I already invited you to World's Fair. We'll see you like do more talks for 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.

[Dhravya Shah]: That was a joke.

[Host]: Uh I think it's really good. Uh there's there's more coming, you know. I think Lchain has their own take.

[Dhravya Shah]: Yeah. You know, I think all all the others

[Host]: there's letter chain mem Zap. Yep.

[Dhravya Shah]: Both Leta and Zep have done workshops, so I think it's your turn.

[Host]: Yep. [laughter] Looking forward to that. Okay, cool. Um, good to catch up and I'll see you online.

[Dhravya Shah]: Great. Thank you so much.