Augment Context Engine is a hosted semantic indexing and retrieval system for software repositories and connected engineering knowledge. It maintains a branch-aware view, embeds code with custom context models, ranks spans by task relevance, and returns selected evidence to Auggie, IDE agents, code review, Intent, Cosmos, or external agents through MCP and SDKs. Its large-scale implementation uses approximate nearest-neighbor search and fallbacks to reduce memory and latency. It does not place an entire codebase in a model window. Its quality depends on index freshness, retrieval precision, access controls, and deterministic verification after the model acts.
- Retrieval replaces repository stuffing. The engine selects relevant spans rather than sending every file.
- The index is branch-aware. Each developer can receive a view matching the code they possess.
- Search is semantic and structural. It can connect concepts whose files do not share exact keywords.
- MCP makes the engine agent-neutral. Claude Code, Cursor, Codex, and other clients can call it.
- Intent adds coordinated work around retrieval. Specs, specialists, worktrees, diffs, and terminals stay in one workspace.
- Retrieval remains probabilistic. Types, tests, runtime checks, and human review close the loop.
The problem it solves
A serious codebase is larger than a language model's working memory. Even when a model advertises hundreds of thousands or millions of tokens, a mature repository can contain tens of millions of lines, generated files, dependencies, commit history, tickets, design decisions, and service contracts. Sending all of it would be slow, expensive, and noisy.
A coding agent therefore needs a selection mechanism. The simplest loop searches filenames and text, opens likely files, follows imports or call sites, and repeats. That works well when the task names the relevant symbol. It wastes turns when the vocabulary in the prompt differs from the implementation, a change crosses repositories, or the key invariant lives outside the apparent module.
Augment turns context selection into infrastructure. The Context Engine continuously indexes code and connected artifacts, then retrieves a ranked slice for a prompt or agent action. The model still reasons and edits. The engine aims to improve the evidence available before that reasoning starts.
| Approach | Strength | Failure mode |
|---|---|---|
| Put files in the prompt manually | Precise when the developer already knows the answer | Requires the user to perform the repository search |
| Agent grep and reads | Fresh, transparent, and works without an index | Broad exploration consumes turns and context |
| Language server navigation | Exact definitions, references, and type errors | Needs supported languages and cannot answer every semantic question |
| Semantic retrieval | Finds related concepts across names and modules | Ranking can return plausible irrelevant evidence |
| Repository summary | Cheap orientation | Compression loses details and becomes stale |
| Augment Context Engine | Combines semantic index, code signals, branch freshness, and multiple delivery surfaces | Hosted dependency, usage cost, and proprietary ranking |
Indexing and personal branch state
Augment's engineering description begins with code-specific embeddings. An embedding is a numeric representation used to compare semantic similarity. Files are divided into searchable units, custom context models encode them, and the resulting vectors enter an index. A task is also encoded, then the system searches for nearby vectors and ranks the candidate code.
Generic repository indexing has a branch problem. Two developers can possess different versions of the same path. A symbol may exist only on a feature branch. A global main-branch index can answer with code the developer cannot compile. Augment says it maintains a personal index for each developer and updates that view within seconds as the working copy changes.
Track file content
The client and backend identify code content and changes. Ignored or excluded paths should remain outside the searchable corpus according to configuration and policy.
Create code-oriented representations
Custom context models turn code spans into vectors designed to capture software relationships more usefully than a general text embedding.
Build the developer view
Shared unchanged content can reuse infrastructure, while branch-specific content changes the personal index. The relevant snapshot should match the files the developer actually holds.
Patch continuously
Edits and branch switches update the searchable view. A temporary fallback can search full embeddings when a newer optimized index is still being built.
Prove possession at retrieval
Before source content is returned from the index, the client demonstrates knowledge of the local file through a cryptographic hash. This constrains what an authenticated user can extract.
Freshness should be tested, not inferred. Create two branches with different implementations under the same symbol, index both, switch rapidly, and ask a question whose answer differs. Then edit an uncommitted file and repeat. Record how long the old result remains reachable and whether the response cites a path or state that the client no longer possesses.
How retrieval selects context
A semantic index produces candidates rather than a final answer. The Context Engine still has to decide how much evidence to return, how to combine exact and semantic matches, how to prioritize active code, and how to connect a task across repositories and artifacts.
| Signal | Example contribution |
|---|---|
| Keyword match | The prompt names PaymentRequest and the symbol exists verbatim |
| Semantic similarity | The prompt says billing timeout while the implementation uses settlement deadline |
| Structure | A route calls a service, which calls a client and writes a record |
| Activity | The developer currently edits the checkout module |
| Lifecycle | One implementation is active and another is deprecated |
| History | A commit explains why a retry limit exists |
| External knowledge | A ticket or design record defines an acceptance criterion |
| Access | The user can retrieve only repositories and sources they are allowed to possess |
Augment's public example asks for logging on payment requests and retrieves frontend, Node API, payment service, database, webhook, telemetry, and configuration files. The exact list will vary. The important behavior is mapping a product concept to the execution path rather than returning every file containing the word payment.
The selected spans are then compressed and placed into the agent's working context. Ranking too narrowly can omit a constraint. Ranking too broadly recreates the token and attention problem the engine is meant to solve. The right cutoff is task-dependent: a rename may need references, while an architectural migration needs service contracts and history.
Connected artifacts create another quality boundary. A ticket can explain user intent and a design document can explain why an API looks strange. They can also be stale, aspirational, or inconsistent with production. Retrieval should preserve source identity and time so the agent can distinguish current code from an old proposal. Ask what metadata Augment passes to the model for each connector.
Teams should evaluate retrieval separately from generation. Give engineers the retrieved spans without an agent answer and ask whether the evidence would let them solve the task. This exposes search quality directly. Then measure whether the model uses the evidence correctly, which is a different failure class.
How it scales to very large codebases
Exact vector search compares a query with every indexed vector. At 100 million lines, Augment estimated that a simple implementation would require about 2 GB of embedding memory and two seconds of CPU work per user operation. That latency is visible in completions and compounds under concurrent team load.
The company's 2025 engineering write-up describes an approximate nearest-neighbor scheme using quantization. A large vector is reduced to a compact bit representation that identifies its broad neighborhood. The engine first searches those smaller representations, creates a candidate set, and then performs the full similarity calculation only on the candidates.
Augment-reported results on its 100 million line search case.
| Metric | Before | After |
|---|---|---|
| Search memory | 2 GB | 250 MB |
| Typical latency | More than 2 seconds | Under 200 milliseconds |
| Memory reduction | Baseline | 8 times lower |
| Parity with exact results | Exact | More than 99.9 percent on typical queries |
Recent changes are especially important and least likely to appear in a finished quantized snapshot. Augment says it tracks a codebase snapshot, handles missing or new embeddings with full similarity search, can use an older quantized index while preparing a new one, and falls back entirely when an optimized index is unavailable or unnecessary. This layered fallback is more important than the headline speedup because it keeps optimization from silently excluding fresh code.
These are vendor measurements. They provide enough detail to judge the engineering approach and too little to predict a specific customer's result. Repository language mix, file size, generated code, number of developers, branch churn, geographic latency, connectors, and query distribution all change the workload. A proof of concept should measure p50 and p95 retrieval latency plus freshness under active edits.
MCP, SDK, and agent-neutral retrieval
Context Engine became strategically more valuable when Augment exposed it outside Auggie. MCP gives an agent a standard tool called codebase retrieval. The client can be Claude Code, Cursor, Codex, Gemini CLI, OpenCode, or another compatible harness. Augment also offers SDK and connector paths for custom applications.
| Mode | Where it runs | Best fit |
|---|---|---|
| Local Auggie MCP | Auggie runs on the developer machine against a workspace | Active branch and local development |
| Automatic workspace discovery | One Auggie MCP process indexes requested directories on demand | Agents that move among several local projects |
| Hosted Context Engine MCP | Augment service exposes indexed repositories remotely | Cross-repo queries and centrally connected sources |
| Context Engine SDK | Custom TypeScript or Python application | Internal agents or developer tools |
| Context Connectors | Indexed external sources available by CLI, MCP, or HTTP | Knowledge beyond repository files |
The local server can pre-index a primary workspace and discover others when the client passes a directory path. The first query to a new workspace is slower while indexing begins. Subsequent queries reuse the index. This startup behavior matters in CI and short-lived containers, where a persistent hosted index may be more useful than rebuilding locally for every job.
An MCP client decides when to invoke the tool. Poor tool descriptions or agent planning can leave a good retrieval service unused. Capture tool traces during evaluation: did the agent call Context Engine, what query did it send, what returned, and did the answer or patch rely on it? Quality gains attributed to retrieval require evidence that retrieval participated.
A shared MCP service can normalize context across agent brands, while each harness may transform results differently. Claude Code can summarize them into its session; Cursor can combine them with editor state; Codex can pair them with its sandbox and search. Common retrieval does not produce identical prompts or outputs.
Intent and the move from context to coordination
Intent is Augment's macOS workspace for humans and agents working from a shared specification. Its public product page attaches the repository, branch, files, staged changes, activity, spec, notes, MCP tools, skills, terminals, and specialists to the same work. A coordinator turns a goal into scoped workstreams and keeps the agents aligned.
The central artifact is intent in the plain-language sense: the goal, constraints, and plan the team agrees to before implementation. Agents can work on backend, frontend, tests, migration, design, or verification in isolated workspaces. As execution reveals new facts, the shared spec and activity record can be updated. The product aims to let a human review the system-level direction instead of reconstructing it from several independent chats and diffs.
| Context Engine | Intent |
|---|---|
| Finds relevant repository and knowledge spans | Organizes the goal, spec, agents, workspaces, diffs, and terminals |
| Answers what code matters | Answers who is doing which part and against what shared plan |
| Can serve any MCP agent | Supports Auggie and bring-your-own agent paths described in Augment materials |
| Improves one agent turn | Coordinates a sequence of agent tasks and human checkpoints |
| Retrieval infrastructure | Developer workspace and orchestration experience |
Intent and Cosmos address related scales. Intent is a workspace where a team guides a product change. Cosmos is the enterprise platform for recurring experts, triggers, shared memory, review, incident, migration, and other organization workflows. Context Engine supplies repository evidence to both.
The operational risk is spec authority. An agent can update a living document to match what it built, masking drift instead of exposing it. Preserve human-approved constraints, record who changed them, and require explicit review when implementation forces a requirement change. A living spec is useful only when its history remains auditable.
Security model and limits
Semantic indexing creates a sensitive derivative of source code. Even when plaintext storage is minimized, embeddings, metadata, paths, relationships, and connector content require protection. Augment's paid security position combines no training on proprietary code, encryption, proof of possession, access controls, certifications, audit, and enterprise deployment options.
Proof of possession reduces unauthorized extraction. It cannot protect against a client that legitimately possesses a file and has been compromised, an overbroad repository grant, a malicious tool with shell access, or a model prompt that includes sensitive content in an allowed request. Retrieval authorization is one layer in the agent security model.
- Index freshness can fail. A stale result may refer to deleted or branch-incompatible code.
- Semantic rank can fail. The nearest concept may belong to a different service or historical implementation.
- Connectors can conflict. A ticket, document, and code may describe three different truths.
- Access can drift. Repository, Slack, MCP, and organization permissions need synchronized revocation.
- Model use can exceed retrieval scope. An agent with shell and network tools can read or transmit data beyond Context Engine results.
- Economics can reverse. Retrieval costs may exceed token savings on simple tasks.
- Vendor dependency is real. Index format, ranking models, usage accounting, and hosted availability are proprietary.
Community and paid data terms differ. The current paid pricing and security pages exclude training, while community terms permit anonymized data use. Confirm plan enrollment, repository scope, provider retention, regional processing, deletion, export, and incident response in the contract.
How to evaluate the engine
Build a retrieval truth set
Choose 30 real tasks and record the files, symbols, tests, history, and documents a senior engineer says are needed. Include misleading neighbors and deprecated code.
Score evidence before generation
Run Context Engine queries and label each returned span as necessary, useful, harmless, or misleading. Measure recall at a fixed result count and precision.
Test freshness and access
Switch branches, make uncommitted edits, revoke a repository, change Slack membership, and retry old queries. Record stale windows and unauthorized results.
Measure downstream agent work
Hold model and agent fixed. Compare tool calls, tokens, wall time, first-pass tests, repair turns, and human corrections with and without MCP.
Test scale and failure
Measure cold indexing, p50 and p95 retrieval, concurrent queries, connector outages, and behavior when the optimized index is unavailable.
Price the net effect
Include Context Engine consumption, model savings, setup, access administration, and engineering time saved or added during validation.
Questions people ask
It is a semantic indexing and retrieval service for code, repository history, connected documents, and team knowledge. It selects relevant spans for Auggie, IDE agents, review, Intent, Cosmos, and external MCP agents.
No. The engine indexes the larger corpus, ranks candidate evidence, compresses it, and sends a relevant slice. The purpose is to reduce prompt noise, search turns, and repeated context.
Augment says it maintains a personal index per developer and updates within seconds. Proof of possession ties retrieval to content the client has. Test branch switches and uncommitted edits in your own pilot.
Yes. Auggie can expose codebase retrieval through MCP locally, and Augment offers a hosted MCP for cross-repository context. The external agent retains its own model, tools, permissions, and billing.
Intent is a macOS workspace where humans and specialist agents share a goal, spec, repository, isolated work, files, diffs, terminals, tools, and an activity record. It uses context to coordinate a product change rather than only answer a query.
Augment reports under 200 millisecond search latency on its 100 million line optimization case, down from more than two seconds, with 99.9 percent parity to exact results. These are vendor measurements and should be reproduced on the buyer workload.
It is better when relevant code uses different vocabulary or spans several systems. Grep is exact, transparent, current, and often ideal for named symbols. Strong agents use semantic retrieval, exact search, language intelligence, and tests together.
Augment publishes proof of possession, no training on paid customer code, encryption, certifications, and enterprise controls. The full risk also includes client authority, model providers, connectors, repository scopes, retention, and agent tools.
Sources
Every figure above was read from these pages on August 2026. Vendors reprice without notice; if you find a stale number, tell us.