Office Hours with Guy: Building an external memory store with Redis CEO Rowan Trollope

Hi everyone. Thanks so much for joining. I'm Guy Gorari, co-founder at Augment Code. Augment is an AI coding agent built for professional software engineers. And today we're going to do something a little bit different, Augment Code Office Hours, where I'm going to be pairing with Rowan to build something using Augment Code and the Redis MCP. Rowan, do you want to introduce yourself?

Yeah, thanks, Guy. Great to be doing this with you here today. Hi everybody.

I'm Rowan Trollope.

I'm the CEO of Redis. Redis is a real-time data platform for building fast applications. And, uh, In addition to being the CEO of Redis, I'm also a big Augment user, and I've got a project that I was hoping you would be able to help me with. Before we, maybe before we go there though, I know that your team just launched a Redis integration via MCP. Maybe you could tell me about that.

Yeah, so we've been partnering with Redis to put, to make it as easy as possible to use Redis inside Augment. And so building on top of Redis MCP, we make it kind of just a few clicks to go on, authenticate with Redis, and then our agent, which already has a full understanding of the codebase, then gets also a full understanding of your Redis deployment. And so you can build inside your codebase against your Redis database and it all just makes it super easy to do so.

Yeah. So that Redis MCP server, one of the ways I've experienced that sort of being a game changer using Augment is Um, I use Redis, so I've been doing a lot of work with agent memory and where Redis is the backing store for agent memory. And my server is, you know, I'm using Augment to write the code, uh, and, you know, help me write the code to, to basically store agent memories inside of Redis and then hooking up the Redis MCP server, which we did the other day, which was cool. Allows Augment to directly see the results of what has been stored in Redis. So it's, it's a much more direct connection. So now from a testing perspective, I can say, hey, you know, go implement this function and here's how I want it to work and the inputs and the outputs. Augment will write the code. I can run the code and then it can validate that what it thought it was gonna store in Redis actually got stored. And so the having that extra tool in Augment just cuts out one extra step. Cuz what I was used to do is go do all that frontend and then go literally open up Redis Insight and look in Redis and go, oh, oh, it's a problem. It stored it with the wrong key name or it did the wrong thing, et cetera, et cetera. So it's much, much more direct and frankly it makes Augment much more like the developer as opposed to being, um, you know, just like a, a cut and paste, you know, ChatGPT kind of thing. So I think that was really, really cool what you guys have done there.

Yeah, 100%. And this is, this is a trend we are seeing. I think it started when we saw how good agents are on writing backend code, because you can close the loop, you can let the agent write the tests and then run the test and anything that doesn't work, the agent will just kind of go and iterate until it does work. But that only works out of the box for things that are in your codebase. Any external system you're integrating with, like databases, cloud providers. It's true also for frontend code. You kind of have to integrate with those systems to close the loop for the agent so the agent can get the feedback on what's working and what doesn't work. And once you do that, it's like magic. The agent can go and iterate and get it working, but you have to take that extra step of integrating. And so that's why with Redis, we're really trying to make it as easy as possible for developers. Yeah.

In fact, before the MCP integration with Redis, I thought the way that what I would notice is that the Augment, uh, agent would use the Redis CLI to verify. So it's kind of one extra level of interaction. Now it can just call directly, uh, through our MCP server. So really, really nice. Um, one of the things that I've been trying to do, and maybe this is what we could work on for the office hours here, is, um, one of the things I love about Augment is that you store memories on a per-project basis. I think you store them in like an augment_memories.md, you know, per project. And I thought that would be, you know, would be really nice is to be able to, um, store that in a, uh, instead of storing it in a text file, stored in a, in an agent, agent memory server that, that I've been building. So I've been building a POC or a side project using Redis called ReMem. And ReMem is, you know, an API that uses Redis underneath the covers, the vector store, the vector set capability. And it has a store memory and recall memories, and it uses vector similarity to find relevant memories. It also does more advanced things like contextual grounding. So for example, if I'm going to store a memory and that memory has a temporal reference, like I say, you know, I need to do X by this Friday. The classic way that that's gonna store it is just literally the, the, the, the text that says this Friday. And when that gets converted into a vector embedding, This Friday is every Friday. And so we need to change that. The Remem, one of the parts of the Remem server that I've been building is, or project has been building is, it does contextual grounding. So it'll replace references like this Friday with a specific date. And so it makes the memories much better and also does other kinds of contextual grounding, spatial. If I say I need to go up north, it's like, well, where is that from here? So. A little bit better than just storing data in a raw text file. And in order to test my product, I wanted to have Augment use it as its memory backing tool. So been able to get that working. And I wanted to just walk through that with you and see how to actually, if there's a way to get Augment to use that tool more effectively.

Yeah, that sounds very cool. So I'd say we have a memories feature built into Augment and I would say it's kind of a V1. Of memories, and there's a lot of other interesting improvements to explore there. Storing it in a database makes a lot of sense because then your memories get shared across all your instances. And so that, that definitely makes a lot of sense. But then also really understanding how, especially as the memory scale, how to make those effectively available to the agent is super interesting and not something we've actually solved. So that's, that's just one question that will be cool to, to to think about.

All right. So maybe I'll just show you what I've done so far, Guy, and we can kind of talk through it.

Sounds good.

Okay. Let me share my screen. So here we have what I was referencing, the re:mem project. It's a Python FastAPI project. And so far what I've done is, well, first I guess maybe just talk about the API. Um, so the API is basically store memory, recall memory. Did my readme— there we go. This is the best way to look at it. Um, so there's a store and a retrieve. And so I've, what I've done is I've got an MCP server or already built up for this thing here with all the tools. Actually, there's a good place to look at it. And then I've integrated that into, uh, Augment. So if I go here— by the way, I did get it working, so nice. There it is. So Remem memory is here. Oh, here's the tools. There we go. Store memory, search memories, stats, add an interesting tool which is AnswerQuestions, so uses an LLM under the covers. So the, the, the context engine, or sorry, the, um, I don't know how Augment will choose to use these tools, but if it wants to, it can say, does the, does the user have any preferences on, you know, uh, recursion? And, and it would be able to take that, and what the AnswerQuestions tool does is frames that, basically figures out a good vector embedding, uh, text. So reframes the question and then creates a vector embedding, does a vector search, returns it, and then reformats the memories back in essentially to an answer to the question. So I can give you an example of that just using the tool directly, CLI that'll demonstrate this. Let me make it a bit bigger. What the tool can do. So first is Augment stores per project settings. So we can go look at the Augment settings here. This right here, agent memories. Here's how you're currently storing it. Agent memory, augmentmemories.md on a per project basis. And for this particular project, here's what it's remembered essentially over time, which is cool in a text file. What we're going to do, what I did earlier is integrated the tool, and then I allowed it to migrate the memories from Augment Memories into the Redis vector set. So the way I did that, well, I can then show it to you. So I'm going to choose that one. It's, um, augment:remem. And then, so now I can query against that. I can search memory. So I can do something like What are my coding preferences? And this is going to do what I just said, the question answering. It's going to look at the vector database, it's going to pull up all the relevant memories, and then it's going to summarize them. So here you go. So you, so you prefer refactoring code by grouping similar concerns together with low-level APIs, blah blah blah. You envision memory systems being used in these scenarios. You prefer data, etc. So it's done in you know, we don't want to— I want to go and show you the translation between this and this, but I think it's done a good job. And if you look here, I can show you— actually, I can share my screen where the data is actually stored. But this data is stored in, in the Redis vector set, which is a new data type in Redis 8, native data type. So we've got all the memories in there. Let's see, /stats. So I asked it to migrate the memories from this to this, and it did it. It put 103 memories into the system. So now the question for you, Guy, is how do I get Augment to use this tool for its memory system without specifically telling it to do it, which is what I had to do earlier, right?

And that's a, that's a common question that shows up when we, when we try to provide the agent with more tools. Here it's even, there's an extra step we'll probably have to take because Augment already has a memory system. And so for this purpose, we're going to try to, we're going to need to tell it, we're going to need to sort of override its existing memory system and tell it to use this new memory system. Right. So we're going to have to try to kind of convince it to do that. We have. I think two basic places to do— so I think one thing we could do is first try to get it to use this memory system and see what happens. The next thing I think we'll run into, which is a very, it's a common issue when trying to get at these, when trying to get the agent to use these external knowledge bases, let's call them, is the agent needs to decide when to trigger them, right? It needs to decide, okay, this is my memory system. I'm not using Augments-1 anymore. I'm using the Redis one, but But when do I actually go and query it? So I suspect we'll get to that next. But first, first we, we just need to get it to use the memory system. So I think we have two levers here. One is these are presented as tools and we can control the tool definition for these tools and try to, through the description of the tools, convince the agent to use them. And another thing we have access to through Augment is user guidelines. That's where we can put extra things. In the prompt, in the system prompt. And we, in our prompt, that's kind of behind the scenes, we ask the agent to pay special attention to whatever goes in the user guidelines because we are trying to give the user, the developer, as much control as we can over how the tool behaves.

Got it.

I'd probably start there cuz that's easiest, doesn't require any code changes. So I think I would—

So do it.

Yeah.

Oh, so I've gone into rules and user guidelines. And then here, I, I just typed in this, always use Remem memory tool for your memories. Is that what you would say or how would you say it?

Yes. So first I would ask, so is Remem memory the name of the tool or is that the name of the MCP?

That is here. I think when I, when I set it up here, I gave it a name right here. So that's what it is. The name of the tool is, is Remem.

So if you— so I guess I'm referring to the, right, the 12 tools in there. I think those are the ones that is— those are the ones that are guaranteed to be visible by the agent. So I would mention like maybe a few of those names. So I would say, for example, use store memory to store it, so on, because those are the actual tool names that it's going to call.

Okay.

The MCP name is sort of this high-level name that includes all the tools.

I see. So they're actually separate.

Yes. I'm not actually sure if it sees those. Yeah.

Like store memory. Okay. How about like you have memories, you have access to aug. Tell me if I'm gonna, if this makes sense. Storing interesting memories. Instead of using that text file, please use the tools that are part of remem, like store memory. See, I prefer not to erase to store new memories and search I think that's what it's called. Search memories.

Right. So, you know, anything on the table, conditions, something like that. Something like that. I would even add, so often it helps to give it some context or like kind of a, just explain to it what we're doing. Like, trying out this new— or we're trying to develop a new memory system. So that's why we're— that's why we want you to use these other tools. We can also give it the names of the tools that we don't want it to use. So I just asked because I didn't remember what the tool names were. I just asked it, what tools do you have access to? It's telling me under memory, it's telling me the storing tool, the storing memory tool is called Remember. So we can tell it, don't use Remember. Yeah, I think that's a good starting point. Then let's see, let's see what happens. At the very least, if we ask it to store a memory or remember something, we should then see it use the new tools rather than the old ones. Yeah.

Do we have to do anything to get it to reload, or should it just immediately use it?

It should just natively use it. I think this should just work.

So then we need to go have an agent do something for us. So let's, let's just have it do something new, like create a new simple.py file. Let's see, which would be an example of what we should have it do here? How about create a test? Just to see if it calls it. Create a test. For the new CLI. So, called Augment context engine.

Yeah, it's trying to orient itself. Because it's a new agent thread, so it wants to know.

Right.

It's calling Augment context engine.

It's reading the directory.

Yep. And then we'll start doing file system operations. Yep.

I noticed that I never see it tell me that it's consulting its memories. Is that something that would be hidden or?

So the way the augment memories work is they always show up in the prompt. And so it doesn't actually need to retrieve from them.

I see. So it doesn't call it.

It doesn't call it.

But if it's gonna call the tool, will we see the tool call here?

Yes. Yes. When it calls any MCP tool, including this one, we will see it as a tool block. Just like read file is shown.

Maybe I should— didn't look like it. It said it's got a good understanding. Let's see what it does next. Maybe my prompt should be like, make sure you pay attention to things we've done before, or something, right?

So I think that's the— that— and that is going to be the, the trickier problem, I think, is to actually get it to call the tool appropriately, right? Because The issue here, I think, is the challenge is that it doesn't know what it doesn't know, right? So it doesn't know whether or not memories will be useful. I think for now we can just tell it before you do anything, consult the memories, right? Just to force it to always call them and probably will call them too much in that case.

Because it's— so maybe I'll change the prompt here. It has valuable insights. Do not use the default Remember tool. Instead, use the— let's take this out. I'll put this first. How's that for a prize? And this is, I think, just demonstrating for people that are, are watching, is, um, the art of prompting. You, you know, like making sure that having this why we're doing it up front so that it actually pays attention, and then giving it explicit, like every time you do anything You know, that, that may, that may kick it into doing it. Let's see. So it didn't, didn't use it. So I'm gonna stop this before it starts writing code. It very likes to write a lot of code. That's one of the, it's gonna end up, I mean, one of the funny things and that I love, by the way, about your product, and I, I, I do try a lot of the other tools and use them, but like the amount of tests that this thing creates is just phenomenal. I don't know if you can see that on my screen right now, but That is a lot of tests. It's pretty awesome. Everything is tested, which is lovely. Okay, so let's try this again. Now that we've got the new prompt, create a new thing and write some new tests. Write a end-to-end test for the new CLI. See if it'll use the So if it paid attention, said every time you do anything, I want you to consult the memory system. Let's see. Look at that.

There we go.

It worked.

Yeah.

Now did it tell us what it would have learned? Yeah. I'm well aware of that. Okay. So it failed. Good. So now we can—

making progress.

So it did a query and then the output searching memories list object has no attributes get. So maybe it didn't use the tool right. What would you do now?

So I think I would now show this to Augment, um, and ask it to— ask it to fix it.

Yeah, to figure out what the problem is. Okay, so I'll say the first, you know, the next week when you're suddenly a public company and you've got— Yeah.

Mm-hmm. Yep.

And this is one of the beautiful things, I think, just again, for people watching, the power of using Augment and generally using AI agents is it's not just about writing your code, it's about building an entire system. In this case, it's actually like telling Augment how to operate and just the flexibility of the Augment agent. To be able to not just do things that have to do with writing code, but debugging and creating new projects and fixing, you know, command line errors and all that other kind of stuff is just some of the power. Like, let's see what it does here. I see the error. Let me store this information about the bug. Oh, that's cool. So did it actually store that for you guys?

So you can see it's calling store memory. So it's actually calling— it's calling you, remember, MCP, to remember because we told it you found it.

Search memories. Error storing memory. So it's failing. That's good. Object of type bool. So it's, hasn't figured out quite exactly how to call it.

Yes.

So now it's saying that didn't work. Comprehend.

So it's gonna go reproduce the, it's gonna go reproduce the problem by writing tests, I think is what it's trying to do. And then once you can reproduce the problem with tests, then you can go and, cuz based on this string alone, it's kind of hard to debug for it.

Right.

Hard to debug. So I think it's doing the sensible thing, which is let's go write a test first. Let's see what's wrong. Yeah.

But test CLI is not read file test CLI. Oh, in tests. Okay. So there is a test here for that. No, like not really. I mean, I've heard tell, but—

I think it's creating the new— this looks like a new file that it created, right?

Could be, yeah.

Yeah.

Well, let's see what it does.

Yeah, let's see if it works.

One of my questions for you, I don't know if other people were questioning, like, is there any way I can make this go faster?

Yeah, I think the speed is definitely currently a bottleneck. I don't have a quick solution for that. There are ideas, but we don't have a solution. My personal solution to it is to run a few of these in parallel working on—

Me too. Yeah.

It's a bit exhausting with all the context switching when going back and forth, but that's— it is a very productive way to work, I would say.

Yeah. I do the same. I, like in a project like this, I'll have multiple Augment windows open, one for the front end, one for the back end, actually a couple for the back end so that I can tell it to do stuff. And then the only time that I run into trouble with that is when it starts stepping on the same code. So I have to try to make sure it's working on different parts of the project, you know, explicitly.

Yes. So the way I do it is I have different copies of the repo for the different agents. And then if they work on the same place in the code, I will run into merge conflicts.

Yeah.

But those are manageable, right? Then it's like I don't lose any work and it's all under control. I still have to deal with the merge conflicts if they happen.

So you actually have cloned multiple directories on your local computer and it, and you let it operate in different directories. And then where do, when do you do the merge? Oh, I see. Then you just do the, the check-ins or the PRs and then you, and then you deal with it through Git. Oh, that's kind of cool.

Yes. Yep.

And then, but that means you have to kind of sync back and forth between the different repos.

You do. So I, I actually use Graphite for that. So Graphite is a tool that lets you stack PRs. So stacking PRs is like a thing that you can do in Git. I don't actually know Git well enough to do it myself. Like Git experts can stack their PRs. But what Graphite does is it automates the stacking process for you. So it handles all the rebasing and everything. And so. It's like one command sort of to take all of your PRs if they're in a stack and, and make them all synchronized. It makes it easier to do this whole like back and forth thing.

Interesting. Okay. Let's see if this— remember that I want to install Graphite. See what it does. I can— there you go. So it's searching memories. Will it, will it add a memory? Yeah. Um, since that thing's still going, sure. Let me just share my screen. So it did follow our prompts. Well, it searched the memory. It's not clear what it searched for, and that probably failed. Yeah.

Mm-hmm. Mm-hmm.

Store memory. There we go. Did call it. Oh, they worked. User wants to install Graphite in their Next.js VectorSets browser project. They use it. Memory stored successfully with ID. Can— there's a contextual grounding. There wasn't any done. Huh, interesting. What did it store here? Successfully installed. Oh, cool. So now we can test if that worked.

Yeah, that's the command. Exactly.

This is Redis Vectorsets browser, so it should be storing in uh, re-augment-remem. That's the name that it chose. And then here's the memories that it's stored. And this is a, this is a vector, the vector set of all the data. And then, by the way, we can then search this directly. So we can go and type in, we can type in things here and it'll it'll find it. So like, let's see, what was the last one we did? We did, uh, graphite. See if it finds it. I need to fix this real quick.

Is this to turn on the indexing?

Uh, just to turn on the embedding model. There we go. Now I can type in graphite. This will actually convert that into a— there you go, I made a vector embedding for it. There you go, successfully installed with Graphite, Graphite, blah blah blah. So here's the memories all coming in. That's cool.

That's, that's super cool. Okay, so that— so if you, if you're an Augment user and you want to just hook up like a vector database to your project, all you have to do is settings Yeah. Turn on the Redis Easy MCP and voilà, you've got your agent is now— is a new superpower that you just gave your agent. Yeah. Awesome.

And, and by the way, it looks just to go back to the, it looks like it fixed it, whatever it did. I don't even have time to review it all. It did a lot of stuff and it figured out whatever was going wrong and I guess validated now it's working and cool. So it's working. We've now hooked up an external memory system, Redis Remem, this little project I was working on, into Augment. How cool. And Augment fixed it, which is even cooler.

Very meta. Yeah.

This is, this is very meta.

Very meta. Working on this.

Well, I'll try this and see. I was hope— what I was hoping eventually would work here is that, um, to actually be able to have memories that are shared across projects. So like when I express a preference for a certain style, I'm gonna have to go in and probably mess with this user guideline and tell it what to remember when and say this tool is for cross-project memories. That's what I was kind of wanted to go for is I have certain coding styles and preferences and I don't want to have to express those in every Augment project. So now that this is stored in the, in Redis VectorSet, I should be able to tell it Hey, for things that are relevant to all of my projects, store those memories in Redis. And then, you know, and that won't, it won't get polluted, right? And then it can pull it in across projects, which would be a nice, cool feature, I think, for, um, for Augment and for my workflow.

Definitely. So this would be like a classifier to tell you, okay, I have this memory. Does this memory only apply to this project or should it apply to all the projects I'm working on? Right. These are exactly the kinds of questions that we think about. Every day when we try to build these features and then you can take it a step beyond and you can ask, well, which of these memories should actually apply to my whole team? Right. Maybe I wanna share memories. Maybe they're not just relevant to me. If I learn something interesting about the codebase, maybe that's available to my whole team. Yeah. So there's definitely a lot of interesting directions memories could, could go in. And this seems like a very cool project for exploring those.

And what I did is I opened up the CLI and I asked this question, what do you know about Graphite? And it said, I found some information related to Graphite. User wants to install Graphite in the Next.js Vectors as browser project, successfully installed it, et cetera. So now we can, we can directly query our memories, which is kind of interesting in addition to having Augment in there. And we could even give it commands like forget that. Or change that. And that's another interesting sort of capability is we could say like, forget about all this Graphite stuff. I don't want that in my memory. And that should actually use the delete memory tool to wipe it out. And then that way, if something's not working, we don't have to go and be editing text files and doing weird things. There it goes. Deleted memory with ID. So now we've, erase that from the memory system. So super cool, man.

Yeah, this is awesome.

Okay, so now you've seen me fumbling around in the tool that you have built. Um, even though I called myself a power user at the beginning, I'm not sure if that actually applies. Um, any advice for me on like things I could be doing better that would improve my workflow, or, you know, things that I should maybe look into in Augment to, uh, to, to be faster and more effective?

So first I'd say one thing I really liked is the callout that Yeah, you can use the tool for more than code generation. You can use it to integrate with other systems. You can use it to edit your bash scripts, right? All this stuff, once you get used to it, I think that's a great insight. The thing I would highlight, which is this is a very common thing when we were working on the user guidelines, I think everyone's inclination is typically to give it a pretty short prompt because in our mind it makes sense, right? This is, we have the full context on what what we wanted to do, and we just tell it, do this, right? In practice, detailed prompts with lots of context tend to work really well. So one thing I want to call out is we have a prompt enhancer feature built into the input box of the agent so that you don't actually have to put in all the work to think of all the different things that should go in a prompt. You can write your short prompt, but then just click prompt enhancer and you'll get sort of a mini plan for how the agent thinks about your prompt and what it's going to do. You can edit it. So that's the one thing I would call out for just improving the prompt because we saw how important prompting was, right?

Yeah. Yeah. I do that. Now here's a question for you. I was wondering, because I use it sometimes when I feel like my prompt, I don't want to write the whole thing or be so verbose. When, why don't you do it automatically?

Yes. So the reason we don't do it automatically is because the, the prompt enhancer serves two purposes. One is Yes, a more detailed prompt will work better, right? But if you look at the enhanced prompts, they contain interpretations of what the agent thinks you're trying to do, and often those are wrong. And so by showing the prompt before sending it over, we actually give you a chance to supervise and do lightweight edits to it. I don't know if you've noticed this, but I, I see this happen is like, it thinks it needs to go edit this part. No, that's not really true. I'm just gonna go delete that before I send. And so I think that's like half the value of the Prompt Enhancer is the ability to easily supervise before it starts going and editing files and doing all these things and going off the rails.

Yeah. What I— so then this is my challenge for you. What I would like you to do is to do it automatically, but instead of acting on it, take the assumptions that are built into the better prompt and then ask me. There's really very few times when I prompt you that it actually stops immediately and says, do you mean X or Y or Z? And that would be really good in my opinion, because a lot of times you hit it and again, you're working actually multiple augment windows and you're doing multiple things. You don't realize that it's gone off into the weeds and then you have to go back and roll back to a previous checkpoint. So why don't you build your, your prompting and your chain of thought where it actually says, hey, I'm going to enhance the prompt, then I'm going to ask the user, is this what you really want?

I see. So take, take the enhanced prompt and then convert it into like these clarifying questions. Like, do you want this, this, and that? That's a cool idea. We could try that. The question is, will the model know which questions to highlight as the interesting ones? But it might. I don't know. I haven't tried it. So that, that's a, that's a cool idea.

I see that in, uh, O3 Pro in their reasoning engine. When you do deep research, it always asks you for clarification. And it usually does it once. So I'm pretty sure it's in their, their system prompt, or at least maybe the way they fine-tuned it, that it always is coming back and saying, okay, I hear what you said and here's my list of clarifying questions.

So anyway, so that's true. They, they've kind of pioneered this approach. And the reason they did that, according to them, is, well, before Deep Research goes and works for like, could be minutes, right? We want to make sure that it's on the right track so it doesn't go off the rails. They have that signal that users are looking for a long-running agent because users actively click deep research, right? For us, we didn't want to do that by default because our agent is somewhat more general, right? It could go and run off and do stuff, but you could also ask it a quick question.

It could be fast. Yeah, that's a good point.

But the, the prompt enhancer though might be a good signal for this because if you've clicked the prompt enhancer, maybe that's like some signal that you're looking for to accomplish a larger task. So that's interesting. I had not thought of that idea before, is to tie the clarifying questions to the prompt enhancer.

To the prompt enhancer. Yeah.

Yeah.

That's a good one.

That's cool.

The other one that, uh, I would love to see improvements on is, um, it, and it reminds me of my early days of software engineering. So going back many decades where what I feel like I can create with Augment is something that is like analogous to what a team of developers would create over the process of a year, but I can do it in weeks. And when I was a development manager, right, that one level up, team lead, tech lead, a big part of the job was wrangling that code over the period of the year so that it didn't get out of control. And what I've noticed when I'm doing my, my Augment projects now is they get out of control within a week, like spaghetti. And like I showed you earlier, 100 tests that are like all not even useful anymore. And so there's some part of the workflow here that needs to be like that tech lead that is constantly grooming the code base and evaluating if this new implementation fits within the style practices we've developed and et cetera, et cetera. And I just wonder how you think about what's that next step towards the augment tech lead that is working multiple agents in, in a single code base. Or even just a single developer that's just cranking really fast and ends up with a giant spaghetti code mess.

Yeah. And this is a problem we see everywhere. We see this internally as well. Even if the code that gets generated is correct, it still needs supervision because the design might be completely wrong. And if you let it keep generating slop like that for a while, you end up with a system that's just unmaintainable. One, I just expect models to overall get better at this, but the way we're thinking about it is exactly as you described it. So I think the next big jump in capabilities coming from models, I expect it to come from multi-agent systems. And this is something that we are exploring. I know others are exploring as well. One paradigm for that that seems to be working well is to have a sort of orchestrator agent that manages a bunch of subagents and delegates work to them. There are all kinds of advantages to that approach, even before solving the software design problem. For example, it helps keep the context that the orchestrator agent sees more compact. And so it helps it keep operating at a higher level of abstraction. It doesn't need to get bogged down in all the little details of, oh, I edited this line and it broke that test. And so on. And that seems to help with quality. Now I'm speculating a bit, but I feel like one thing that's happening with these models is once they decide to go down a certain path, they sort of get attached to this and it's a bit hard to pull them out of the rabbit hole they went down. And I think by splitting the context into different agents, maybe they can take a bit more of an adversarial approach. Like one agent can maybe criticize another agent's work more easily.

Yeah.

And looking at things like design. So these are all, this is a problem we see. We are working on trying to address it. I'm sure the models will also get better, but I do agree that this is something we will have to solve in order to really take it to the next level in terms of having less supervision needed on these things.

Yeah. Yeah. And a sort of a corollary of that problem of the last challenge you mentioned of like going down a rabbit hole is they're, they're highly responsive to the user's suggestions. So if I give it a, a bad idea, it's super happy to run with it. But then if you ask it, is that a good idea? It'll say, no, no, no, that's not a good idea. And so I've, I think I've kind of built that into my workflow where when I'm not totally sure about a direction, I'll say, I'm thinking about this. Is that the right idea? And by the way, one of the other requests for you, I know you have chat and agent mode. But switching between chat and agent mode is not very intuitive for me. Like, I end up just asking everything in agent mode. And the problem with that is sometimes it kind of just takes off and starts doing stuff, and I don't want it to do stuff. It's more I, I'm really asking it questions. And, and the reason that's important, by the way, is when I switch between agent and chat mode, chat has a different context window, so it doesn't remember, it doesn't know what I was talking about or what the agent was doing if I have multiple prompts in a row. And I want to, in, in the context of that thread, I wanna say, hey, what do you think about this? Or what do you think about that? And it tends to kind of leap forth and start doing stuff. So that's just something I, I don't know how you can fix that from a design perspective, but maybe have like a button that's like enable chat mode for this agent. So like, I'm gonna ask you a question in this context, but don't do anything.

Yes.

I don't know if that makes sense, but it makes sense.

We've actually built it already and this is something that we're going to ship soon. So it's actually even better than chat mode. You get the full Agent mode, but restricted to just answering questions.

Perfect. So that's what I need.

Use the context engine and all this stuff from the agent. So you get better quality answers. Yeah. So that, that's supposed to come soon. Yeah.

You guys are way ahead of me. Love it.

Awesome.

Well, Guy, thank you so much. This was fun today.

Thanks so much, Rowan. This was great.