Introduction
The semantic interface between coding agents and live codebases.
Context Engine gives coding agents a semantic interface to the live codebase. Instead of reconstructing relationships from raw files, an agent can navigate symbols, resolve types and consumers, and fetch only the source ranges the current task needs.
Files store text. Agents need code.
A file is the storage format, but code has structure that does not live at fixed line coordinates:
- symbols have exact boundaries and meaningful parts;
- definitions connect to callers, implementations, and dependencies;
- types and parameter names form contracts;
- a changing workspace must remain synchronized with its language servers.
Context Engine makes those relationships directly addressable. Structural analysis maps the codebase, language servers resolve semantic identity, and handles let the agent request a specific symbol again without repeating discovery.
The agent chooses what to fetch
Context Engine does not rank text chunks and silently discard the rest. The agent asks an explicit question—such as “what does this file expose?”, “where is this identifier defined?”, or “which code uses this symbol?”—and receives the corresponding source-backed context.
That keeps selection under the agent’s control:
| Starting point | First tool |
|---|---|
A diagnostic, stack trace, or exact file:line | line_context |
| An identifier visible in source | jump |
| A symbol name with no known location | grep_definition |
| A known file whose structure is unfamiliar | outline |
| A handle from an earlier result | extract |
| A symbol whose consumers matter | show_usage |
| A visible identifier whose type or documentation is enough | hover |
| A known exact line range | smart_read |
The tools are designed to compose. A typical investigation moves from discovery to a precise symbol, then follows only the definitions, usages, or implementation details needed to complete the task.
Live, local semantics
Analysis runs locally against the project files and configured language servers. Context Engine combines a polyglot structural layer with live language-server semantics, then watches the workspace so later requests reflect current source rather than a pre-built semantic snapshot.
Dependencies participate in the same navigation model as workspace code. An agent can follow a visible symbol into the standard library or a third-party package and inspect the API or implementation selected by the project.
Continue
Follow the Quickstart to connect Context Engine to a coding client, or open a tool page from the sidebar when you already know the operation you need.