Augment Code is Your AI Coding Agent for Real-World Codebases ⚙️

CV Deep Dive

Today, we’re talking with Guy Gur-Ari, Co-Founder at Augment Code.

Augment is an AI coding agent built for professional software teams. Co-Founded by Guy in 2022, Augment is designed to deeply understand large, real world codebases and help developers work at a higher level of abstraction. By indexing and reasoning over proprietary code, design documents, and internal context, Augment enables everything from code generation and bug fixing to code review (launching today and built on GPT 5.2), CI/CD automation, and onboarding into complex repositories.

Today, Augment is used by teams ranging from small engineering groups to organizations with thousands of developers, particularly those working in large, messy, production-scale codebases. It integrates directly into tools like VS Code, IntelliJ, and the terminal, and is increasingly being used not just for interactive development, but also to automate core parts of the software development lifecycle.

In this conversation, Guy shares how Augment was founded, why deep codebase understanding is the key differentiator for coding agents, and how AI is starting to move beyond the inner loop of development toward automating end to end software workflows.

Let’s dive in ⚡️

Read time: 8 mins

Our Chat with Guy 💬

Guy, welcome to Cerebral Valley! First off, introduce yourself and give us a bit of background on you and Augment Code. What led you to co-found Augment?

At the time, I was working at Google on large language models, focused both on training these models and on using them to solve hard reasoning tasks. Back then, I was mostly focused on solving math and science questions with large language models. This was about three years ago, and I felt like we were crossing a threshold where these generative models were actually becoming useful. At the time, it was still difficult to get useful results out of them because you needed to rely on things like few-shot prompting or even additional training to get models to do what you wanted. There was not yet much room for building products around them, but it felt close. That was the premise for Augment, that these models were getting a lot better.

We felt there was an opportunity, especially around code and building products for developers that could handle code generation. In particular, our premise was to build a product for the enterprise, because enterprises have a lot of proprietary information, both code and related assets like design documents, architecture documents, and all kinds of supporting materials around the codebase. We believed that if we could tap into that proprietary information and make it available to the best models out there, we could build the best code generation product in the world. We knew then, and people clearly see it now, that context is king. You want the best available context for the models so they can perform tasks effectively. That is how we got started. To start, we focused on code completions, which was our first feature.

We built code completions that feel like they really understand your codebase, no matter how large. Fast forward to today, and we have agents that generate code and perform other tasks on your behalf, always with deep codebase understanding under the hood.

How would you describe Augment to the uninitiated developer or AI team?

Augment is the best coding agent in the world for professional software teams. What makes it different is that from the start, it scans your codebase, indexes it, and then uses its tools to build a deep understanding of that codebase. It does not matter how large or how messy the codebase is, and every real world codebase is typically both large and messy. That does not matter. The agent will understand your codebase quite well. This means that when you try to do things with the agent, you do not need much handholding. You can stay at a higher level of communication and give it more abstract instructions.

You can ask it questions like what is our data retention policy, or you can tell it something like add a button to this page in Settings, really at that level. It will understand what needs to happen thanks to the codebase awareness and more often than not give you a good result without requiring you to specify which classes to touch or which files to edit. The feedback we hear from customers, and what we see in evaluations, is that we have the best agent out there. It requires the minimal amount of steering for doing code generation. 

Tell us about your key users today. Who would you say is finding the most value in what you're building with Augment?

We have customers ranging from teams with 10 or more developers all the way up to large organizations with thousands of developers in some cases. What we find is that the teams that benefit most from Augment are those working on large, existing codebases. For example, our customer Tekion saw that with our code review tool their average time to merge drop from 3 days 4 hours to 1 day and 7 hours - 60% faster.  If you are doing zero to one product development, just getting started and building a web app or mobile application from scratch, Augment will work just fine and deliver a great result. In that scenario, you likely will not see much differentiation between us and other agents out there.

However, if you are working on an existing codebase, both on the frontend and the backend, that is where Augment really shines. I’d say this is especially true on the backend, where you typically have a lot of complexity. That is what we consistently hear from customers like MongoDB, Redis, and Pure Storage who try our product and ultimately choose us over the competition.

Talk to us about some existing use-cases for Augment. Any interesting customer stories you’d like to highlight? 

One story I really like is a company that provides professional services to others. What they do is frequently jump into new repositories. That is one of the killer use cases for codebase understanding. If you are new to a codebase, whether because you are working on a customer’s repository, joining a new company, or moving into a part of the codebase you have not touched in a while, onboarding is hard. They would typically take weeks, if not months, to get up to speed on a new repository.

With Augment, they were able to cut that down to hours or sometimes days. You can chat with the agent about the codebase to get oriented, find your way around, and start working without spending all that time loading the entire repository into your head. That use case, developers who have to jump into a new repo every couple of months, really highlights the difference it makes to have an agent that quickly and deeply understands your codebase in real time. This scenario of jumping into a new part of the codebase is something every developer encounters.

Another story that comes up repeatedly is that at Augment, we meet developers where they are. We do not have our own IDE. We integrate through plugins into tools like VS Code and IntelliJ.

Especially for IntelliJ, there are not many good solutions out there. Customers often come to us because they have a lot of developers on IntelliJ who do not have a good option, and that gets them to try us. But then we end up spreading within companies because developers start out using Augment on IntelliJ, see the value of the codebase understanding, and then we also win over their VS Code developers.

Walk us through Augment’s platform. Which use-cases should new customers experiment with first, and how easy is it for them to get started? 

I’d say there are two parts to this. One is what I’d call interactive software development, and the other is automation. For interactive software development, you can try it out in your preferred IDE. It could be VS Code, IntelliJ, or you could use our CLI tool if you prefer working in the terminal. We are seeing that more and more, because in the terminal it is very easy to parallelize agents and have them run in the background. All of these agents in Augment work in essentially the same way. You get the same Augment agent with deep codebase understanding.

For interactive software development, you can use it for almost anything. Feature development, bug fixing, and performance optimization are all common use cases. You can also use the agent for tasks beyond code generation. When I use Augment, I use it for all of these things, and I also use it to create pull requests and generate pull request descriptions. Augment integrates with GitHub, your ticketing system such as Linear or Jira, and your documentation tools like Notion or Confluence. The agent can read from and write to all of these surfaces.

You can use it to generate the code, create the pull request, and then handle feedback. If you get comments on your pull request, you can tell it to go read those comments and address them. It will update the code, respond to code review comments, and reply to reviewers on your behalf. You can also use it to write specs in Notion.

Anything related to code generation, plus all the interactive tasks around code generation, even when they involve interacting with other systems, is within scope. That includes deploying your system and keeping it running. For example, if you have a staging environment, that is another common use case. All of this falls under interactive software development.

What we are seeing more and more now is automation, which is the reason we built the CLI agent. We felt it was the right product surface for automating more parts of the software development lifecycle. There are several examples of customers using this for automation. Code review is a very popular one and benefits greatly from deep codebase understanding. Triaging and fixing CI/CD failures is another common use case. Ticket to PR is another. If you have an issue, you can tag Augment and it will generate a pull request for you.

These are all classic code generation or code understanding tasks that perform much better when the agent truly understands the codebase end to end.

How are you measuring the impact and/or results that you’re creating for your key customers? What are you most-heavily focussed on metrics-wise? 

Measuring impact with these tools is definitely a challenge. For interactive software development, we mostly look at adoption as the most basic metric. Developers today have a lot of choice in the tools they use and often mix and match between them. We look at whether developers adopt Augment and whether they stick with it over long periods of time. As we start building more tailored experiences beyond general agents, we can introduce more specific metrics. A concrete example is the code review feature we are building, where more targeted measurement becomes possible.

For code review specifically, we look at things like the percentage of comments made by the code review bot that are actually addressed by developers. This tells us whether the comments are genuinely useful or just noise. We can also calculate ROI by measuring how much time developers spend on code review with and without the bot. That allows us to quantify how much time is being saved and tie it directly to ROI. This kind of measurement is really only possible with more tailored experiences, where you can clearly define the task, such as reviewing a specific pull request.

It is more of a setup where you know exactly what the input is and exactly what the output is. With interactive software development, things are much more open ended, which makes it harder to measure impact with complete precision.

There are a number of companies working on AI coding agents. What sets Augment apart from a product or technical perspective? 

For us, the main differentiation is our context engine. This is what gives the agent and all the other features a deep understanding of the codebase. It is the result of work we spent the first year of the company developing. We saw early on that giving AI models a deep understanding of a codebase is a technically challenging problem, and we went through several different approaches before having a real breakthrough. We arrived at an approach that works well and also scales to very large repositories. That approach ended up powering our completion feature, then next edit, then chat, and now the agent. Based on what we have seen so far, we have a unique solution in this space.

Specifically, it is a context engine, or search engine for your codebase, that actually works and delivers better results than any other agent out there. This is especially clear when you compare it to agents that rely only on basic tools like reading files or grepping. If an agent depends solely on those tools, you run into what is called a semantic gap. If you do not know the exact string you are looking for, it becomes very hard to find the relevant part of the codebase, especially when it is large and messy. What our solution does instead is allow the agent to ask higher level questions. It can search the codebase using natural language.

It does not matter if the agent knows exactly what a class or function is called. The models driving the search engine are smart enough to surface the relevant pieces of code even when the query is not exactly phrased the same way. This closes the semantic gap and leads to much better results from the agent. This is why, with our agent, you do not need much handholding. The retrievers and the search engine make it possible to stay at a high level and still quickly get to the relevant code.

Could you share a little bit about how Augment’s platform actually works under the hood? What’s the reasoning behind some of the architectural decisions you made?

Once you install Augment, whether in VS Code, IntelliJ, or through the CLI with permission, we index the code in the background. As a developer, your code is sent to our systems and indexed using our embedding models so we can retrieve from it later. This all happens behind the scenes and is fairly quick. For typical repository sizes, the initial indexing takes seconds or minutes at most. From that point on, you and anyone else on your team can get up to speed very quickly, because we do not need to repeat that indexing process.

Another thing we built into the system is a proof of possession mechanism. We want to make absolutely sure that when someone tries to retrieve files, they are never able to access files they do not already have permission to see. The system is designed so that you have to prove you have local possession of the files before you can retrieve results from them. Even on large teams where some developers work on confidential parts of the codebase, it is guaranteed that each developer only gets retrieval results from code they actually have access to, even though indexing is deduplicated. From that point on, the agent and all other features can safely access the indexed code.

As the codebase evolves, the index stays up to date in real time. That means if I am working on one branch and that branch changes, I get retrieval results from that branch in real time, while another developer on a different branch gets retrieval results from their own branch. That, in a nutshell, is how our context engine and codebase search works. It indexes the code continuously and then surfaces it to the agent as a tool.

The agent also has access to all the other standard tools. It can read files, grep, and do everything you would expect. We put a lot of effort into making sure these tools are well balanced. The agent knows when it should use the codebase search, when it should read files directly, and when other tools are the right choice.

What has been the hardest technical challenge around building Augment into the platform it is today? 

The hardest challenge has definitely been building the context engine and the codebase search, both from a research perspective and an engineering perspective. From the research side, imagine a repository with hundreds of thousands of files. We have a customer with close to a million files in their monorepo. That is a huge amount of data. You want to take a query against this massive corpus and surface only the relevant pieces of information. You also need to keep the result fairly small so you do not exhaust the LLM’s context window, which is limited. And you need to do all of this in a short amount of time, typically within hundreds of milliseconds. All of that has to work reliably.

In addition, you need a way to maintain the index. Maintaining the index means indexing the files, deduplicating them, and allowing retrieval against different versions of the codebase, because developers can be on different branches. You also need to keep the index up to date in real time, which is not a natural operation for most embedding systems. There was the research challenge of training the models that drive the context engine, and then the engineering challenge of serving these models, keeping the index fresh in real time, and querying it in a way that scales to millions of files. Those were the main challenges we faced when building the product.

How do you foresee Augment evolving over the next 6-12 months? Any product developments that your key users should be most excited about? 

We believe interactive software development has made huge progress, and we believe we have the best product in that category. It will continue to evolve. What we are seeing now is a lot of pull into automation use cases because the agents have gotten good enough that we can go beyond the inner loop of software development and start automating more pieces of the software development lifecycle. Today we launched a code review product. Our customers are using Augment to handle CI/CD fixes, ticket to PR, and automatically generating documentation. There are many different use cases emerging. I’d say this is the next major opportunity in AI for code, figuring out how to automate more of the SDLC. That will be our focus for the next year.

That means giving developers general tools they can use to automate their own processes, and also building more tailored experiences like a code review bot or ticket to PR integrations with systems like Linear or Jira. These are very common tasks in the SDLC that benefit from a more polished, dedicated product experience. Those are the two areas where I expect us to invest heavily over the next year.

Lastly, tell us a bit about the team at Augment. How would you describe your culture, and are you hiring? What do you look for in prospective team members joining the company? 

We are operating in a space that is moving very fast. We are looking for people who care deeply about AI for code, who care about the revolution happening right now in how software development is done with AI, and who are passionate about building products in this space. It is really about bridging this new technology, models that keep getting better every few months, with turning that progress into products developers genuinely find delightful.

We are looking for people who are truly passionate about that mission. That could mean working on the research side with models and prompting, or working on engineering, whether frontend or backend. If that describes you, we would be very happy to talk.

Anything else you'd like our readers to know about the work you’re doing at Augment?

I’d say at Augment we are really pushing the envelope on what is possible with a coding agent. It does not matter whether you have never tried an AI coding assistant or whether you have already tried all the others. I highly recommend giving Augment a try. You will see what a next generation AI agent looks like. If you have used these tools before, you probably know they require a lot of handholding and steering. With Augment, you get much more freedom. You can think and operate at a higher level. It almost feels like you become the tech lead for your agents, able to get a lot more done with far less prompting and guidance.

Conclusion

Stay up to date on the latest with Augment Code, follow them here.

Read our past few Deep Dives below:

• Arcade - A New Kind of Marketplace 🔍

• Strong Compute - Your High-Performance Training Infra Platform 🔋

• V7 Go - AI Agents for Complex Document Workflows 🎛

• Zencoder’s Repo Grokking - Your AI coding unlock 🔑

• Rime - Authentic AI Voices for Real-time Conversations at Scale 🗣️

If you would like us to ‘Deep Dive’ a founder, team or product launch, DM our chatbot here. 

CV • Instagram • X • All Events