# Building Self-Coding Agents

Colin Flaherty, Augment Code

AI Engineer Summit 2025

[Talk page](https://ai.engineer/talks/Iw_3cRf3lnM-building-self-coding-agents) · [Video](https://www.youtube.com/watch?v=Iw_3cRf3lnM)

## Building an Agent That Helps Write Its Own Code

Augment’s self-coding agent connects repository context, tools, human corrections, and test feedback to implement integrations, diagnose bottlenecks, and improve its own code.

Familiarity with repository workflows, subprocesses, unit tests, and basic concurrency will help you follow the examples.

### What does it mean for an agent to build itself?

[0:17](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=17s)

How much of a coding agent can the agent itself help implement? At Augment Code, Colin Flaherty’s team explored that question while building tools for software engineering organizations. The backdrop was a rapid change in interaction: autocomplete in 2023, broader adoption of chat in 2024, and, in Flaherty’s 2025 forecast, agents becoming the next major focus. The team had spent the preceding few months building its own agent. Flaherty reports that over 90% of its approximately 20,000-line codebase was written by the agent with human supervision. Here, **self-coding means supervised development of the agent’s software**, not autonomous retraining of its foundation model.

The first concrete example is adding integrations. To work within an engineering organization, the agent needed access to Slack, Linear, Jira, Notion, Google Search, and the repository itself. Humans implemented the first few integrations, giving the agent examples of where integrations belonged and which interfaces they followed. Asked to add Google Search, it could inspect those patterns, locate the appropriate file, and implement another integration.

![Slide titled “Implementing core features” with a lines-of-code chart and the annotation “Agent writes its own 3rd party integrations.”](https://ai.engineer/api/talk-essay-media/5019d2568b2bdd6ee9ba4b9c51c2238648d905d7246541fb755dda86b9837a11)

The agent writes its own third-party integrations.

That new capability then helped build the next one. The foundation model did not know the [Linear API](https://linear.app/developers/graphql), so the agent used the Google Search integration it had previously written to find documentation and implement the Linear integration. The useful feedback loop was concrete: an implemented tool expanded what information the agent could obtain for subsequent development.

The team also asked it to add unit tests for Google Search. Writing the tests required more than file editing: the agent needed tools to start subprocesses, interact with them, read their output, and avoid hanging indefinitely if a generated test entered an infinite loop. **Execution tools turn generated tests into usable feedback.**

### Using the agent to diagnose its own slowness

[3:02](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=182s)

Feature generation and test generation were familiar demonstrations. Optimization posed a different question: could the agent investigate behavior before deciding what to change? When the team noticed that its agent was slow, it asked the agent to profile itself. The investigation followed a short loop:

1. Add print statements to its own codebase.
2. Run subcopies of itself.
3. Inspect the resulting output.
4. Identify repository file loading and hashing that happened synchronously.
5. Introduce a process pool and add a stress test to check the change.

The agent used its editing and execution tools to move from an observed symptom to a specific implementation change. Flaherty describes the optimization but supplies no measured speedup.

![Slide titled “Optimizing Itself” shows lines of code against days, with a rising green line and the annotation “Agent profiles itself, adds optimizations.”](https://ai.engineer/api/talk-essay-media/0275b9c1a5c5787ae330b5d5aca943f903d49f83cfbcf9ccd047cfdc87ab2b05)

The agent profiles itself and adds optimizations.

### Instrument, execute, clarify, and remember

[3:57](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=237s)

The walkthrough begins with deliberately simple tasks that the agent handles reliably. Asked whether it can search Google, the planning agent finds a Google Search tool, sends the query `tests`, and reports seeing the first ten results. This separates two responsibilities: the agent decides what to do, while tools let it act on external services and repository files.

The next request asks it to instrument its Google Search tool with logs and generate an example. Repository retrieval resolves that natural-language request to `services/integrations/thirdparty/google_search_tool.py`. The file-editing tool adds print statements there. The agent then runs a subcopy of itself to exercise the instrumented integration and obtain the requested output.

Execution exposes a missing piece of context: the agent believes Google credentials are unavailable. Instead of continuing with an unsupported assumption, it invokes a clarification tool and offers two alternatives—stub the Google API or guide the user through credential setup. Flaherty supplies a third answer: credentials already exist at `.augment/googleapi.json`; the agent simply missed them.

The agent then uses a memory tool to retain the credential location for future work. This is a concrete form of learning from interaction: a user correction becomes retrievable information, rather than a change to model weights. With that context, the agent produces logs for the query `Python programming language`, including returned domains `python.org` and `wikipedia.org`. The full task combines search, repository retrieval, editing, execution, clarification, and memory. No single tool performs the whole job; the planning agent connects them as new information arrives.

### The infrastructure behind the tool loop

[6:51](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=411s)

Augment did not begin by building an agent. Its earlier completion and chat work concentrated on a scalable enterprise context engine, alongside interface design that made human collaboration practical. Those investments supplied the foundation for building the agent in a couple of months. The clarification step in the logging demonstration illustrates why both matter: retrieval helps find relevant information, while the interaction design gives the user a way to repair missing context.

Flaherty identifies three essential capabilities:

- **Context access:** retrieve relevant information from the codebase and organizational sources such as Slack.
- **Foundation-model reasoning:** use a capable model to plan and decide how to act on that information.
- **Code execution:** safely run commands within a customer’s environment and observe what happens.

Context informs an action, reasoning selects it, and execution supplies evidence for the next decision.

### Measure capability by complexity

[7:54](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=474s)

A polished demonstration of an agent generating an entire website can suggest senior-engineer, or L5, capability. But professional development rarely starts from an empty repository. Existing systems contain conventions, dependencies, and messy environments that a greenfield demonstration can avoid. Agents can be useful in that setting without yet matching the broad competence implied by a senior engineering role.

That distinction changes how to organize the capability roadmap. Rather than assuming an agent will first solve back-end work, then front-end work, then testing, Augment found it more useful to think about **levels of task complexity across domains**. A general-purpose agent can handle some front-end, back-end, security, and testing work, with improvements raising its capability across those areas together.

Human job categories also encourage misleading expectations about strengths and weaknesses. Flaherty gives the example of an agent that struggles with mathematics yet implements a front-end feature very quickly. A weakness in one task does not imply the same cluster of weaknesses that it might suggest in a human engineer. Evaluate the work the agent can actually perform, rather than assigning it a human-shaped skill profile.

### Teach organizational conventions through retrieval

[9:48](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=588s)

An unfamiliar development tool exposes the limits of relying on model knowledge alone. Flaherty asks the agent to create a stack of two pull requests for a new reasoning module using [Graphite](https://graphite.com/docs/cli-quick-start). The model does not know how Graphite works, so it substitutes Git and invokes `git checkout`. That produces an action, but not the requested workflow.

Waiting for a foundation-model provider to retrain on the organization’s tools would not solve the immediate problem. Instead, the team adds a searchable knowledge base. A Markdown document explains Graphite, common commands such as `gt create`, and actions to avoid. Other documents describe the tool stack, test procedures, and style guide. The agent can dynamically retrieve these documents when it encounters something unfamiliar.

With that documentation available, the same request leads the agent to read about Graphite and invoke `gt create`. The demonstrated improvement is selecting the intended tool after retrieval. In the current Graphite CLI, `gt create` creates a branch and commit; `gt submit` publishes pull requests, with `--stack` available for a stack. The visible command invocation therefore does not establish that both requested pull requests were completed.

![Projected terminal example asks for two stacked PRs using Graphite, then displays “Reading about Graphite” and a tool invocation beginning with “gt create.”](https://ai.engineer/api/talk-essay-media/16d12840f618fc4e0d16eb4c029c44a5bcf390457ecbb72205fefb45229a785b)

The Graphite example shows knowledge retrieval followed by a command invocation.

**Onboarding is part of agent engineering.** A new human hire would receive explanations and documents, not just instructions to stare at the repository until everything made sense. An agent likewise benefits from being able to ask questions, with the resulting answers feeding back into organizational documentation.

### Cheaper implementation expands what is worth trying

[11:45](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=705s)

The integrations also changed the team’s product decisions. Initially, it was unclear which integrations, such as Linear or Slack, deserved priority. Ordinarily, the team would make educated guesses, implement a few, and learn from them. Agent assistance made it possible to build the integrations together, reducing the pressure to choose their implementation order. As implementation becomes cheaper, more ideas become practical to explore, and product insight and design can become the limiting factors.

Repository awareness lowers the cost of specifying that work, too. The earlier logging request did not name a file or give precise editing instructions. The agent resolved the intent to the appropriate integration through its knowledge of the codebase. The user could describe the desired change at the level of an engineering task.

The same context supports work beyond code editing. In another example, the team asks the agent to inspect recent pull requests and draft an announcement, which the team then posts to Slack. The announcement describes new CLI-agent tools, including Slack notifications and Linear integrations. The agent also creates the plot of interactive-agent lines of code against date shown earlier in the talk. These tasks draw on different sources and operations: repository changes, communication context, and code history.

The broader point is that context sources can complement one another. Understanding a repository helps identify what changed; access to organizational communication makes those changes useful in another workflow. Flaherty describes combined codebase and Slack access as four times as useful as either alone, an illustration of complementary context rather than a measured multiplier.

### A write lock can still lose updates

[14:01](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=841s)

The testing example exposes a more subtle failure than choosing the wrong tool. Multiple agents store information for their runs in a shared cache location. The agent-generated save function locks around the JSON dump, so concurrent agents do not write simultaneously and cause an obvious write failure. But it does not read the current shared cache before saving. Each writer can therefore overwrite information another agent has already saved. **Serializing writes does not make stale state current.**

Consider a small illustration of that failure. Agents A and B both start with an empty cache. A adds `{"a": "ready"}` locally and saves it. B adds `{"b": "ready"}` to its own still-empty snapshot, then saves after A releases the lock. The writes happen one at a time, yet the final shared cache contains only B’s entry. The vulnerable Python operation has this shape:

```python
import json


def save_cache(path, local_cache, lock):
    with lock:
        with open(path, "w", encoding="utf-8") as cache_file:
            json.dump(local_cache, cache_file)
```

For this example, the critical section would need to protect reading the current shared state, incorporating the new entry, and writing the result. A lock around only the final dump cannot preserve A’s entry when B’s input never contained it.

A serialized save overwrites another agent’s entry
The lock prevents overlapping writes, but B still replaces shared state with a stale snapshot.
Constructed example: Agent labels A and B, an initially empty cache, the keys a and b, the value ready, and the exact save order are teaching values illustrating the reported lost-update mechanism.
Agent B’s stale local cache — unchanged: {"b": "ready"}
Operation: Agent B acquires the lock after Agent A finishes, dumps its local cache to the shared file, and releases the lock.
- Agent A’s local snapshot
  - Before: After A saves, before B saves: {"a": "ready"}
  - After: After B saves: {"a": "ready"}
- Agent B’s local snapshot
  - Before: After A saves, before B saves: {"b": "ready"}
  - After: After B saves: {"b": "ready"}
- Shared cache file
  - Before: After A saves, before B saves: {"a": "ready"}
  - After: After B saves: {"b": "ready"}
The lock prevents overlapping writes, but B still replaces shared state with a stale snapshot.

### Tests provide the feedback that autonomy needs

[14:54](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=894s)

Unexpected runtime behavior exposed the cache bug. The team had no test for the relevant concurrency case, so the agent received no test signal that its implementation was wrong. A useful regression test for the illustrated case would give both agents the same initial snapshot, let each save a distinct entry, and assert that both entries survive. Testing only that a save completes or that the resulting JSON parses would miss the lost update. Caches and parallel execution need tests that check preservation of state, not just absence of exceptions.

Augment’s internal bug-fixing benchmark gives a second view of why feedback matters. Flaherty compares changing the foundation model with enabling repeated test-guided attempts:

| Change | Reported score improvement |
| --- | --- |
| Foundation-model upgrade spanning about six months | 4% |
| Four iterations of proposing a fix, running tests, and using feedback | 20% |

These are reported gains on the internal benchmark. The talk does not identify the models, baseline scores, or whether the percentages mean relative changes or percentage-point increases. The mechanism behind the larger reported gain is explicit: the agent can inspect test failures, revise its proposed fix, and try again.

**Better tests enable more autonomy** because they give the agent actionable evidence and give engineers a stronger basis for trusting the result. A test harness is therefore part of the agent’s problem-solving environment, not merely a final gate after it finishes writing code.

### Code remains; the engineering work changes

[15:58](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=958s)

Flaherty closes by contrasting the agents’ recent usefulness with their earlier limitations. When agents help implement their own tools and improvements, development can compound: a new capability becomes available for the next task. Code still matters as a specification of the system, even as engineers spend less of their effort producing every line directly.

That shift makes strong test harnesses more valuable and poorly tested parts of a codebase more consequential. It also changes product development: cheaper implementation increases the importance of deciding what to build, gathering customer feedback quickly, and turning that feedback into insight. At the time of the talk, Augment’s agent release was still forthcoming. The working prototype already showed the engineering pattern behind it—context to understand the task, tools to act, human input to resolve gaps, and tests to expose mistakes.

## Resources

- [Linear GraphQL API guide](https://linear.app/developers/graphql) — Official instructions for querying and updating Linear data through its GraphQL API.
- [Graphite CLI Quick Start](https://graphite.com/docs/cli-quick-start) — A walkthrough of creating stacked branches, submitting pull requests and updating them during review.
- [Augment Agent launch announcement](https://www.augmentcode.com/blog/meet-augment-agent) — The April 2025 announcement introduces Augment Agent, persistent Memories, terminal access and external integrations.
- [How Augment built its SWE-bench Verified agent](https://www.augmentcode.com/blog/1-open-source-agent-on-swe-bench-verified-by-combining-claude-3-7-and-o1) — Colin Flaherty and Tongfei Chen explain their benchmark agent, model ensembling, experiments and limits of benchmark coverage.
- [Augment SWE-bench agent repository](https://github.com/augmentcode/augment-swebench-agent) — An open-source coding agent with file editing, command execution, Docker evaluation and candidate-solution ensembling. Setup requires model API access.

## Slides

### From autocomplete to chatbots

AI developer tools shifted from autocomplete in 2023 toward chatbots in 2024, as chat models entered software engineering organizations.

[0:44](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=44s) [Timeline showing autocomplete in 2023 followed by chatbots in 2024.](https://assets.ai.engineer/sites/aiecode2025/sha256/0d31ad28813e422e2e14ab68945a4b33651d677391356dfc7b0a0a4f77e1ad06.webp)

2023 → 2024
auto-complete    chatbots

augment code

### Implementing core features

The codebase reaches roughly 4K lines around day 20. After humans built the first integrations, the agent added more, using its own Google Search integration to find Linear’s API docs.

[1:40](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=100s) [A graph of lines of code over days highlights the agent writing its own third-party integrations around day 20.](https://assets.ai.engineer/sites/aiecode2025/sha256/bfd17547a15e626425c43afdcf46496819839495dc27379a2a902a2a81dda783.webp)

Implementing core features
EVOLUTION OF AUGMENT AGENT

Agent writes its own 3rd party integrations.

Y-axis: LINES OF CODE
Y-axis ticks: 0, 5K, 10K, 15K, 20K
X-axis: DAYS
X-axis ticks: 0, 10, 20, 30, 40, 50

augment code

[2:22](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=142s) [A graph of lines of code over days highlights the agent writing its own third-party integrations around day 20.](https://assets.ai.engineer/sites/aiecode2025/sha256/0d7612ef85ecb64619b6fbd8f6cdc6dbfc2ecaa46c1029035dacfafb621b0c0c.webp)

Implementing core features
EVOLUTION OF AUGMENT AGENT

Agent writes its own 3rd party integrations.

Y-axis: LINES OF CODE
Y-axis ticks: 0, 5K, 10K, 15K, 20K
X-axis: DAYS
X-axis ticks: 0, 10, 20, 30, 40, 50

Event text: AIE
AI LEADERSHIP
HTTPS://AI.ENGINEER

### Optimizing Itself

Asked to profile its slow code, the agent found synchronous file loading and hashing, added a process pool, and stress-tested the change. The chart traces code growth across 50 days.

[3:04](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=184s) [A graph rises to about 18,000 lines of code by day 50, with a note that the agent profiles itself and adds optimizations.](https://assets.ai.engineer/sites/aiecode2025/sha256/9644938c4c2b9f4ab629d49bb48530909006e01982cf17a876cb1b8e48f9da6f.webp)

Optimizing Itself
EVOLUTION OF AUGMENT AGENT

Agent profiles itself, adds optimizations.

Y-axis: LINES OF CODE
Y-axis ticks: 0, 5K, 10K, 15K, 20K
X-axis: DAYS
X-axis ticks: 0, 10, 20, 30, 40, 50

Interface text:
augment code

[3:51](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=231s) [A line chart shows lines of code rising over 50 days, with a note that the agent profiles itself and adds optimizations.](https://assets.ai.engineer/sites/aiecode2025/sha256/3f203c9aaba182e3140127e665b4f4b1b86ee398b2db6aa1194f6a47f23dd943.webp)

Optimizing Itself
EVOLUTION OF AUGMENT AGENT

Agent profiles itself, adds optimizations.

Y-axis: LINES OF CODE
Y-axis ticks: 0, 5K, 10K, 15K, 20K
X-axis: DAYS
X-axis ticks: 0, 10, 20, 30, 40, 50

Interface text:
AIE
AI LEADERSHIP
HTTPS://AI.ENGINEER

### Search Tool Example

The agent finds a Google Search tool, sends a test query, and reports that it can see the first 10 results.

[4:09](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=249s) [A terminal example shows the agent finding a search tool, running a test query, and reporting ten results.](https://assets.ai.engineer/sites/aiecode2025/sha256/52cff2e9c493376263bf3a8c37023e7b407b3b6e88a380072c666f3474c9f59e.webp)

EXAMPLE

augment-agent >>> are you able to search google?

…
[general_agent] Found tool “google_search”
[google_search_tool] Querying “test”
[general_agent] Yes, I can search Google, and I see the first 10 results.
…

Interface text:
TERMINAL
augment code

### Adding Search Tool Logging

Asked to instrument Google Search with logs, the agent searches the local codebase and edits the integration file to add print statements.

[4:46](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=286s) [A terminal example shows the agent locating a search integration and editing its code to add logging.](https://assets.ai.engineer/sites/aiecode2025/sha256/531425f5c4f8231319848a395439cb25360f5c8e7c8db2ee10a792e3f21d2be8.webp)

EXAMPLE

augment-agent >>> instrument agent’s google_search_tool with logs and then generate example

[retrieval_tool] Looking for files related to Google search integration…
[file_edit_tool] Editing services/integrations/third_party/google_search_tool.py
…

Interface text:
TERMINAL
AIE
AI LEADERSHIP
HTTPS://AI.ENGINEER

### Clarification and Memory

The agent asks about missing Google credentials. After the user points to their location, it records that location in memory for later use.

[5:19](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=319s) [The agent asks about missing credentials, receives their location, and records that location for later.](https://assets.ai.engineer/sites/aiecode2025/sha256/5031ec7dd941789d92dd92b299fb5e4165ed98ca6778e1f1a0933be3e01838de.webp)

EXAMPLE

[clarify_tool]: I don’t see Google credentials. Would you like me to:
1. Add stub for Google API
2. Guide you through setting up credentials.

augment-agent >>> Credentials are in .augment/google_api.json

[memory_tool] Creating memory of where Google credentials are stored.

Interface text:
TERMINAL
AIE
AI LEADERSHIP
HTTPS://AI.ENGINEER

[5:28](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=328s) [Terminal example showing an agent asking about credentials and remembering their location.](https://assets.ai.engineer/sites/aiecode2025/sha256/ee7190557c53f82ce678e5bd877202d3b96e21ce962f6bde8fea033e97808406.webp)

EXAMPLE

[clarify_tool]: I don’t see Google credentials. Would you like me to:
1. Add stub for Google API
2. Guide you through setting up credentials.

augment-agent >>> Credentials are in .augment/google_api.json

[memory_tool] Creating memory of where Google credentials are stored.

Interface text:
TERMINAL
augment code

### Example test output

The agent runs a test search for “Python programming language” and logs three returned URLs.

[6:26](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=386s) [Terminal example showing search logs and returned results.](https://assets.ai.engineer/sites/aiecode2025/sha256/49e83298ac3492abd0d575ae70389cf21ae86cc67e8f250b48701833abfe565d.webp)

EXAMPLE

[general_agent] Here is the output from the test script:
2025-02-17 - INFO - Searching web: “Python programming language” with max results: 3
…
2025-02-17 - DEBUG - Search results URLs:
[“python.org”,
“wikipedia.org/wiki/Python_(promgramming_
language”,
“python.org/about/gettingstarted”]

Interface text:
TERMINAL
augment code

### Assumption 1: L5 agents

Website demos can make agents look like senior engineers, but professional software work rarely starts from scratch and often happens in messier environments. The speaker says the tools are still useful.

[8:22](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=502s) [Slide contrasts the claim that L5 agents are here with the observation that professional software engineering is rarely zero to one.](https://assets.ai.engineer/sites/aiecode2025/sha256/3bbe104418a51a5c754d94e18e4b39a0b93acb12e64e26ec73386844c01aa503.webp)

Assumption 1

L5 agents are here!

Professional software engineering is rarely 0->1.

AIE
AI LEADERSHIP
HTTPS://AI.ENGINEER

### Assumption 2: Task complexity

The speaker’s team evaluates agents by task complexity: their agent works across front-end, back-end and security, and they aim to improve its capability across those areas together.

[8:57](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=537s) [Slide contrasts taking over task categories with thinking in levels of complexity.](https://assets.ai.engineer/sites/aiecode2025/sha256/8cac5be37ef44c70f85c58a410ac52e49d5ac50ae4d7cf82dee2e7dd8191fd81.webp)

Assumption 2

Agents will take over entire categories of tasks!

Instead of categories of tasks, think levels of complexity.

### Agent lacks Graphite knowledge

Asked to create two stacked PRs with Graphite, the agent says it doesn't know Graphite and runs a Git checkout command instead.

[9:55](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=595s) [Terminal example shows an agent asked to create stacked pull requests using a specific tool, then choosing Git instead.](https://assets.ai.engineer/sites/aiecode2025/sha256/f8e9f403859aa477dff1f877dfa4bb5b962017bc5da8b82f734ae896a690b17d.webp)

EXAMPLE

augment-agent >>> can you create a stack of two PRs for the new reasoning module using graphite?

…
[general_agent] I don’t know what Graphite is, so I’ll use git.
[terminal_tool] Running “git checkout -b reasoning_module”
…

Interface text:
TERMINAL
augment code

[10:09](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=609s) [A terminal example shows an agent asked to create stacked PRs with Graphite; it instead runs a Git checkout command.](https://assets.ai.engineer/sites/aiecode2025/sha256/dc52d01dfae7b94f68f1fc9d5b50ba908c9701041aff95de9ef08d7a915995db.webp)

EXAMPLE

augment-agent >>> can you create a stack of two PRs for the new reasoning module using graphite?

…
[general_agent] I don’t know what Graphite is, so I’ll use git.
[terminal_tool] Running “git checkout -b reasoning_module”
…

Interface text:
TERMINAL
AIE
AI LEADERSHIP
HTTPS://AI.ENGINEER

### Graphite knowledge-base example

A Markdown knowledge-base entry teaches the agent how to create a PR with Graphite and which Git commands to avoid. The agent can search the knowledge base when it needs context.

[10:31](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=631s) [A markdown example describes Graphite, a command for creating a PR, and commands to avoid.](https://assets.ai.engineer/sites/aiecode2025/sha256/b66c77007176fa8ae7d6335e86aa156e65118033c90986e92d63f04cd850650b.webp)

EXAMPLE

## Using Graphite for version control

Graphite is version control tool for git that enables stacked PRs…

## How to create PR

Run `gt create user-branch -m desc`...

### What NOT to do

Do not use `git pull` or `git push`...

### Third-party integration tools

Unsure which integrations to prioritize, the team used agents to build them all at once, including tools for Linear and Slack.

[11:46](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=706s) [Code examples define tools for querying Linear tickets and querying or posting to Slack conversations.](https://assets.ai.engineer/sites/aiecode2025/sha256/8400c7d3fc264878b2103b1993d4c2b856b659fc7a3db854991c53a3fa7a867c.webp)

EXAMPLE

class LinearTool(LLMTool):
    """Tool for querying Linear tickets."""
    …

class SlackTool(LLMTool):
    """Tool for querying and posting to slack conversations."""
    …

Interface text:
×
×
augment code

### Instrumenting the search tool

Given a natural-language request to add logs, the agent locates and edits the Google Search tool file. The speaker credits codebase awareness for finding the file without a precise path.

[12:34](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=754s) [A terminal example shows an agent locating and editing the Google Search integration after a request to add logs.](https://assets.ai.engineer/sites/aiecode2025/sha256/e320828709ebaec184c169ad73d0a13b4e543fc7ce6685054547ffdf445fc2b6.webp)

EXAMPLE

augment-agent >>> instrument agent’s google_search_tool with logs and then generate some example logs

[retrieval_tool] Looking for files related to Google search integration…
[file_edit_tool] Editing services/integrations/third_party/google_search_tool.py
…

Interface text:
TERMINAL
augment code

### Lines of code over time

The agent made this plot of its interactive agent’s codebase. Lines of code rise from roughly 1K to over 18K across about 50 days, with a sharper climb near the end.

[13:25](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=805s) [Line chart rises from roughly 1,000 to 18,000 lines of code over 50 days.](https://assets.ai.engineer/sites/aiecode2025/sha256/981385f2f6fe3e40f382f7b18070a5b5d4d170a5849ebe5cc0cbfe33950d807d.webp)

EXAMPLE

Y-axis: LINES OF CODE
Y-axis ticks: 0, 5K, 10K, 15K, 20K
X-axis: DAYS
X-axis ticks: 0, 10, 20, 30, 40, 50

augment code

### Cache-writing bug example

An agent-written cache function locks the write but skips reading the existing cache first. The team caught this hard-to-test edge case through unexpected runtime behavior.

[14:02](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=842s) [Python function writes a cache under a lock; a comment says the cache should be read before writing.](https://assets.ai.engineer/sites/aiecode2025/sha256/79aec7885c85bb33492c42559ffbbf000d6289b8900f79a21f86da87c10a45b5.webp)

EXAMPLE

def save_agent_cache(data):
    # BUG here: should read cache
    # before writing to it
    with lock(CACHE_FILE):
        json.dump(data, CACHE_FILE)

Interface text:
×
…

### Internal bug-fixing benchmark

On an internal bug-fixing benchmark, upgrading the foundation model by about six months improved scores by 4%. Letting the agent repeatedly fix bugs and run tests four times produced a 20% gain.

[15:18](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=918s) [Benchmark results show a 4% improvement from upgrading the foundation model by six months and a 20% improvement from letting the agent run tests four times.](https://assets.ai.engineer/sites/aiecode2025/sha256/c27c0f8737fa083240ebc5939e7dadc9aa96a9df810e6880064d3f5f387b0a7c.webp)

EXAMPLE

On an internal bug fixing benchmark:

+4%
upgrading foundation
model by 6 months

+20%
let agent run
tests 4 times

augment code

## Full transcript

[0:00](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=0s) [on hold music] Hi, everyone.

[0:17](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=17s) Thanks for coming today. So I wanna talk to you about something that sounds like science fiction, but very much is reality. An AI coding agent that helped build itself.

[0:27](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=27s) My name's Colin. I'm an AI researcher at Augment Code, a company building AI-powered dev tools for software engineering orgs, and I wanna share with you a little bit about my-- our journey working on AI coding agents.

[0:41](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=41s) So zooming out, AI dev tools is a fast-changing space. Everyone remembers in twenty twenty-three, we were all talking about autocomplete models, GitHub Copilot being the one that probably really comes to mind.

[0:54](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=54s) In twenty twenty-four, chat models really started to penetrate software engineering orgs.

[1:00](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=60s) In twenty twenty-five, though, we think AI agents are gonna dominate the conversation about h- how software engineering is changing.

[1:09](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=69s) So naturally, a few months ago, we started building our own agent at Augment. I wanna show you a sneak peek of what we built and share some hard-learned lessons about how this tech works.

[1:20](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=80s) And I just wanna, you know, reiterate, I've been really amazed to see the extent to which this agent has helped build itself. Uh, one kind of fun statistic, so we have about twenty thousand lines of code in our, uh, agent code base, and over ninety percent of that was written by our agent with, with human supervision.

[1:39](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=99s) So what does it mean for the agent to write itself? Implementing core features, so one of the first things we ha- we had to add was third-party integration. So our agent, you know, if it's gonna work like a software engineer, it needs to interact with Slack, Linear, Jira, Notion, search Google, um, muck around in your code base.

[1:59](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=119s) And so we wanted to have the agent help us build these features. Uh, we had it-- uh, we found after we added the first few ourselves, when we a-asked it to, you know, give it an instruction, like add a Google Search integration, it was able to go look in our code base for the right file to add

[2:13](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=133s) it in, uh, figure out the right interface to use, and go add it. Uh, one kind of fun an-anecdote is when we were adding the Linear integration, uh, it didn't know the Linear API docs.

[2:25](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=145s) The foundation model we're using, uh, didn't have those memorized. And so it used the Google Search integration, which it had written previously, to go look up the Linear API docs, and then was able to add that.

[2:38](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=158s) Uh, we used it to write tests. So we found if we a-asked it something like, "Add unit tests for the Google Search integration," it was able to go add those.

[2:48](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=168s) Uh, in order to do this, we just had to give it some basic process management tools, things like running a subprocess, interacting with it, uh, not hanging if there's an infinite loop in some test it wrote, and, uh, reading output.

[3:02](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=182s) Um, I think this is super interesting, so everyone's seen the Twitter demos of these agents writing features and writing tests, but I haven't yet seen a compelling example of them performing some kind of optimization.

[3:15](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=195s) Well, over the course of our project, we no-noticed the agent was pretty slow, and we weren't sure why. So we asked it to profile itself, and what it ended up doing, using all these tools we'd given it, was add some print statements to its own code base, run essentially subcopies of itself, look through these print statements, and

[3:32](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=212s) it figured out there was a part of our code base where we were loading up all the files in the user's repository, uh, synchronously and hashing them synchronously. And then it added a process pool for these to speed it up and a stress test to confirm it was all working.

[3:47](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=227s) And by the end of this, we reached about twenty thousand lines of code, and again, over ninety percent of that was written by the agent with, with our help and supervision.

[3:57](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=237s) So let's walk through a quick examples-- a, a couple quick examples to see how the agent works. I focus on simple examples where it's reliable, so you can, uh, follow along easily.

[4:10](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=250s) So here I ask the agent, "Are you able to search Google?" And then it notes that it found a tool called Google Search. For those who aren't familiar with the notion of tools, I'm, I'm sure most of you are, but I'll just kinda quickly reiterate.

[4:21](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=261s) The idea is we have this kinda master-level agent that's doing all the planning, and it has access to certain tools that it can use to interact with its, its environment, whether that's the third-party integrations I talked about, like Google, or it's editing a file in the user's repository.

[4:36](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=276s) And then it wants to confirm this-- that this Google Search tool is working, so it sends a query to it of tests. And the agent, uh, uh, responds to us, "Yes, I can search Google, and I see the first ten results."

[4:48](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=288s) Let's try something a little bit more complicated. I ask it, "Instrument agent's Google Search tool with logs, and then generate an example." Then it uses our retrieval tool, which is, you know, al-allows you to search, uh, the local, uh, code base, and it's looking for a file related to Google Search integrations.

[5:04](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=304s) It finds this file deep in our directory hierarchy at services/integrations/thirdparty/google_search_tool.py. And then it calls its file editing tool to quickly and performantly edit that file to add those print statements.

[5:20](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=320s) Uh, this is a continuation of the last example. So it added those print statements, and now it wants to run, uh, a subcopy of itself, so it can look at the output of those print statements, uh, 'cause we asked it for example logs.

[5:33](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=333s) Uh, but in doing so, it finds that we don't have Google, uh, credentials authorized, so it uses its clarify tool to ask for clarification from the user. It asks, "I don't see Google credentials.

[5:43](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=343s) Would you like me to, one, add stub for Google API, or two, guide you through setting up credentials?" I know that the credentials are actually stored in .augment/googleapi.json. It, it had just missed this.

[5:57](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=357s) And then here's a, a really cool extra feature we have, which is we want the agent to continuously learn as it interacts with humans.

[6:05](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=365s) And so here it thought, well, it's probably a good idea to remember where the Google credentials are stored. So it called this memory tool to create a memory of the-- where, where the Google credentials are stored to save that for later.

[6:17](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=377s) This is another example of if you have that really good context engine, uh, it- it's really critical to getting the agent to, to work well. And so now we get our output.

[6:26](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=386s) So it prints out these logs that it searched with an example string, Python programming language, and it gives some, uh, uh, example URLs that were returned by Google, python.org, and wikipedia.org.

[6:37](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=397s) So we had the agent add logs to itself, run itself, learn from user feedback, and it used all kinds of tools: Google Search, codebase retrieval, file editing, clarification from the user, and, and memorizing, uh, useful learnings.

[6:51](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=411s) So let's fast-forward and talk through some of our lessons building this. Uh, I just wanna note, you know, we've been working on AI coding tools for a couple years now, and we didn't set out to build agents.

[7:02](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=422s) We've worked on things like completion models and chat and so forth, but our focus the whole time was around building a super powerful, scalable, enterprise-ready context engine because we knew no matter what, no matter how good these LLMs get, you're going to need that context.

[7:18](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=438s) And we also thought a lot about how do you build great UI/UX so AI can seamlessly, um, interoperate with humans. It turns out this context engine and all these thoughts around design provided a great foundation for us to quickly build this agent in just a couple months.

[7:33](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=453s) The three most important things were that access to context, so that context engine with all those different types of context sources, whether it's Slack or the codebase, the reasoning capabilities from a best-in-class, uh, foundation model, and that code execution environment, so you can safely run, uh, commands in a, a customer's, uh, environment.

[7:54](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=474s) So let's talk through a couple assumptions that we frequently fall into-- we, we have frequently fallen into and remedied and, and some of you might encounter as well.

[8:04](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=484s) Uh, so the first one is that, you know, L5 agents are here. The senior soft-- agents are at senior software engineering level. Uh, if you look at the Twitter demos, it, it oftentimes can seem like this.

[8:14](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=494s) You have an agent write an entire website all on its own.

[8:18](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=498s) In reality, professional software engineering is where-- rarely zero to one, and the environments that we're coding in are, are a lot messier than what those demos, uh, show you.

[8:28](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=508s) As a result, these tools, you know, aren't quite there yet, but they're still super useful.

[8:35](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=515s) Um, the way pe-- One framework I've seen people think through when they're trying to figure out, you know, how to use these agents and how to build them is they think agents will take over entire categories of tasks.

[8:45](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=525s) So first you build an agent that will, uh, solve back-end programming, and then you build an agent focused on front-end, and maybe one focused on testing. In reality, this technology is very general purpose.

[8:58](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=538s) And so instead of thinking about categories of tasks, we found it more helpful to think through levels of complexity. So our agent's, you know, kinda good, decently good at tasks across front-end, back-end, security, and so forth, and, and we're, we're improving the capability level along all those fronts at once 'cause, you know, again, it's a very general

[9:17](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=557s) purpose technology. Um, we've also seen people anthropomorphize agents, so they think they're just like human software engineers, and they map the characteristics of a weak software engineer to what they think a weak agent would look like and vice versa for strengths as well.

[9:34](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=574s) In reality, agents have different strengths and weaknesses than humans, and so you may have an agent that can't do math, but it can implement a whole front-end feature way faster than any human could, and it's important that we keep this in mind.

[9:48](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=588s) Uh, let's talk through a couple reflections and lessons.

[9:53](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=593s) Uh, so here I ask Augment, "Can you create a stack of two PRs for the new reasoning module using Graphite?" Unfortunately-- Uh, so Graphite is a, a version control tool for working with Git.

[10:03](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=603s) You can, like, stack PRs. It makes it a lot easier to review. Unfortunately, foundation models have not memorized how Graphite works, so our general agent responds, "I don't know what Graphite is, so I'll use Git," and then it calls our terminal tool to run a command running git checkout.

[10:18](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=618s) Well, what do we do here? We wanted it to use Graphite. We can't necessarily go tell OpenAI or Anthropic to retrain the model to understand Graphite overnight. So what we came up with was this notion of a knowledge base, which is essentially a set of, a, a, a, a sort-- a set of information that we want the

[10:35](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=635s) agent to understand that it currently doesn't. We can kinda patch holes. Um, one thing we wanted to add to it was this Graphite knowledge, so we created this markdown file describing Graphite, how to, you know, run common commands, things like how to create a PR, use gt create, some things not to do.

[10:51](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=651s) Um, we created other files in our knowledge base for things like details on our tool stack, how to run tests, the style guide. And then we added this into the context for the agent, so it can dynamically go search in this, um, knowledge base when it doesn't understand something.

[11:07](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=667s) And, uh, once we added this, then, you know, we go ask it, "Can you create a stack of two PRs for the new reasoning module using Graphite?" And it calls that knowledge graph, reads about Graphite, and then can run the gt create command.

[11:20](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=680s) So what's the learning here? Well, onboarding the agent to your organization is crucial. The analogy I like to think about is if you just hired a, a new, a new hire software engineer, you wouldn't go tell them to just stare at the codebase for three days to figure out how your tech stack works.

[11:34](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=694s) You'd let them ask you questions. Maybe there's some things they didn't understand, and you add some additional documents to your Notion. Uh, we should think similarly about agents.

[11:45](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=705s) Uh, recall I was talking about how we had all these, uh, third-party integrations we added, whether it's Linear tools or Slack tools and so forth. But when we, when we were working on these, we weren't really sure of which ones to prioritize and start with on our product roadmap.

[11:59](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=719s) In a normal world, we'd make some educated guesses, we'd implement a couple of them and go from there. But with the agents, we were able to iterate them, um, uh, build them all at once.

[12:08](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=728s) And so this starts to change the calculus around how product management works. Uh, if you can build everything at once, well then, maybe, um, maybe, uh, engineering hours aren't the bottleneck on what we build, and it starts to, uh, we start to be bottlenecked a little bit more on good product insights and good design.

[12:28](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=748s) So when code is cheap, you know, you can explore more ideas.

[12:32](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=752s) Uh, also recall earlier, we were talking through this example of, you know, instrumenting the agent's Google Search tool with logs, uh, and it was able to go find the file to edit.

[12:41](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=761s) Notice here how we didn't have to give a very precise instruction to the model. We just told it in natural language, like how we'd talk to another engineer to instrument the agent's Google Search tool, and it was able to go figure out the file to edit.

[12:53](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=773s) This only worked because we had that really good, uh, codebase awareness.

[12:58](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=778s) Um, we can also use the agent for tasks outside of writing code, but still within the software development life cycle. So here, we asked it to look at the latest PRs, uh, in our code base and generate an an- an announcement on them, and then we posted it to Slack.

[13:12](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=792s) And so, uh, it was titled New Tools for this, uh, CLI Agent, and we talked about some things around Slack notifications and Linear re- uh, Linear integrations. This only works as we had that Slack integration and, and understood our code base well.

[13:27](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=807s) This, uh, figure may look familiar from the beginning of the talk. Um, we actually had the agent make this as well. So we asked it, "Make me a plot of the interactive agent's lines of code as a function of the date."

[13:40](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=820s) Um, and so good context is critical. In all three of these tasks, we needed to pull in some different context from some different sources, and it's not just the code base.

[13:49](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=829s) Context comes in many forms. And also note that it's multiplicative, so having access to the code base and having access to Slack is four X as useful as just having access to one of those.

[14:01](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=841s) Finally, I wanna, uh, switch over and talk about, uh, testing.

[14:07](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=847s) So, uh, here's a really, uh, hard-to-test edge case in our code. The agent actually wrote this, um, and we only caught it because of some unexpected runtime behavior. So we have these caches that the agents store relevant information for their runs in.

[14:22](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=862s) Uh, we can run multiple agents in parallel, and they all write to the same cache location. And the agent wrote this save function to save to that location. And it had this lock around the JSON dump, so there were no race conditions that would explicitly fail if you had multiple agents all writing to this cache at the

[14:41](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=881s) same time. But notice here how there's no read before writing to the cache, and as a result, you could hit a race condition where if multiple agents are running in parallel, they're all overwriting each other's caches.

[14:54](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=894s) And when the agent wrote this save function, why did it miss this issue? Well, these agents sometimes make mistakes, and this is a hard-to-test situation. There's some parallel programming.

[15:04](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=904s) There's a cache involved. And so we didn't have a test, and because we didn't have a test, the agent messed up. My learning here is we need to be very careful about having sufficient tests.

[15:17](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=917s) Um, we have this pretty incredible statistic. So we have a internal bug fixit- bug-fixing benchmark. Uh, we found when we upgraded our foundation model by about six months, our scores from this benchmark improved by 4%.

[15:32](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=932s) But when we added, uh, the, uh, ability to run tests so the agent could suggest a fix for the bugs, run tests, look at the feedback, suggest another fix, run tests, and do that four times, that led to a 20% gain on this benchmark.

[15:47](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=947s) So what's the lesson? Well, better tests enable more autonomy. You can trust these agents more, and it just makes them smarter.

[15:58](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=958s) What does software engineering look like in a world of agents? Well, agents didn't work last year, but now are pretty good. If you'd asked me two years ago if we'd be working on this tech, I frankly wouldn't have guessed it.

[16:11](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=971s) There's a compounding effect where these agents are starting, starting to help build themselves, and that's only going to accelerate the pace at which they improve. Code isn't going away because it's a spec of our systems, but our relationships to it is changing.

[16:25](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=985s) Good test harnesses are becoming more important than ever, and we need to be es- especially careful about those parts of our code bases that tend to be less well-tested.

[16:35](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=995s) And the calculus of product development is changing. If code becomes super cheap to write, then the focus-- our focus is more on good product work, gathering customer feedback quickly, building insights.

[16:49](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=1009s) We're really excited for how this tech's going to positively transform our industry, and we'll be releasing our agent soon, so I'm really excited to share that with you. Uh, find me after the talk if you wanna discuss any more.

[17:00](https://www.youtube.com/watch?v=Iw_3cRf3lnM&t=1020s) Thanks. [upbeat music]
