Augment Code uses a context engine to find relevant knowledge in a codebase and pass it to models.
2
The Apollo 11 guidance computer example shows how an agent can explain obscure assembly code and the 1201 and 1202 alarms.
3
Agents work best when engineers use chat to form expectations, tests to check behavior, and small modernization steps to change legacy code.
Summary
Forrest Brazeal and Matt Ball use the Apollo 11 guidance computer as an example of difficult legacy code. The code is a large, monolithic assembly-language source file from the 1960s, so they ask Augment Chat to explain the 1202 program alarm and locate the relevant code. The agent connects the alarm to the computer running out of capacity for concurrent jobs, which allowed the astronauts to continue landing. They then use Augment Agent to create a missing Python implementation of the P65 lunar descent guidance routine and run a simulator until it succeeds. The practical advice is to begin by asking the agent questions about the codebase, use chat to predict expected behavior, have the agent write tests, and modernize small portions while checking those tests. The speakers are also direct about the limits: the agent can be wrong about an ambiguous detail such as scheduler priority, so an engineer still has to read and decide.
Matt says Augment started with the idea that high-quality model output requires high-quality input. Codebases are harder to provide as context than plain text, especially when the relevant information is spread across files and relationships. Augment spent two years building a proprietary context engine that lifts the relevant knowledge from a codebase and passes it to models. The product remains a plugin for existing IDEs, which matters for teams working in environments such as IntelliJ with a ten-year-old Java codebase. Matt also describes customer-managed encryption keys and ISO 42001 as part of its enterprise security work.
Chat and agent modes support different levels of control
Matt distinguishes between chat and agent modes. Chat is suited to simple question-and-answer exchanges or one turn at a time, when the engineer wants more control. Agents can handle larger and more complex tasks, while remote agents can keep running in the background and in parallel after the engineer closes the laptop. Forrest relates this to a workshop where several problems were solved quickly, possibly because remote agents handled tasks at the same time.
The Apollo guidance computer is a useful legacy-code test
The Apollo guidance computer helped land the lunar module and was written in assembly at MIT during the 1960s. Its source was one large monolithic file developed over several years. Forrest presents it as an extreme legacy-code example because most engineers cannot look at its two-word assembly commands and immediately understand their behavior. The source is available on GitHub, so the speakers use it as a real codebase rather than a toy explanation. Their goal is to understand enough of it to investigate the alarms that appeared during Apollo 11's descent.
The agent can connect an obscure alarm to its operational cause
Forrest asks Augment Chat what the 1202 program alarm does. The response reads the source, identifies the relevant octal value and registers, and also retrieves outside context. It explains that the computer had run out of available capacity because it was trying to track too many concurrent jobs. An external radar system had been left on, and the guidance computer responded by dropping lower-priority work while continuing mission-critical tasks. Forrest compares chat to calling mission control, with MCP servers providing additional systems to consult.
Agent mode can implement and test a missing routine
Forrest switches to agent mode and asks Augment to run simulator.py until it succeeds without changing the simulator. The repository contains a simulator that expects a descent.py file with a LunarDescentGuidance class implementing the P65 algorithm, but that file is missing. Augment reads the codebase, examines the test files, runs terminal commands, creates descent.py, and implements the vertical descent guidance routine in Python. It then runs the simulator and reports final position and velocity values within the expected zero-to-one-meter range shown in the demonstration.
An engineer should use the agent to form hypotheses and tests
Forrest's suggested workflow begins with asking the agent what the codebase and individual files do, along with any style or convention rules. The engineer can then use chat to predict what the code should do for specific inputs and ask agent mode to write tests for that behavior. He warns that the agent is not always reliable on ambiguous details. In one scheduler example, it could be persuaded that priority level zero was either the highest or lowest level. The engineer has to inspect the surfaced code, resolve the ambiguity, and apply human judgment.
Modernization should happen in small, tested portions
After understanding the legacy system and adding tests, Forrest recommends converting small portions into the desired language or style. The same tests should be applied after each change so the new implementation does not drift from the original behavior. Matt gives moving a Java 8 project to Java 17 as a real-world version of the Apollo exercise. They also say the agent can inspect dependencies across a large codebase and recover from local problems, such as finding that Python is unavailable and trying Python 3 instead.
"The Apollo 11 computer was smart enough then to offload some low priority tasks so that it could continue executing mission critical components inside the computer."07:37
Who should watch
You have a large legacy repository whose behavior is difficult to understand before making changes.
Your team wants an agent to handle code exploration, implementation, and test iteration inside an existing IDE.
You are planning a gradual migration such as moving a Java 8 project to Java 17 and need checks against the old behavior.
