The failure begins after decomposition
A long project rarely stays in one AI conversation. Strategy is discussed in one session, implementation in another, testing in a third, and a specialist agent may handle only one subsystem. Each session can produce a sensible answer and the project can still fail.
The reason is structural. A local task description says what to do now, but often drops the project decision that created the task, the constraint it inherited, and the neighboring artifact it must still fit. The result is locally correct work that cannot be assembled into a coherent whole.
Context Map is Agentlas's attempt to make that missing structure explicit and carry only the required part into each concrete task.
One change, many consequences
Imagine an aircraft program that changes capacity from 180 passengers to 220. The sentence is short. Its consequences are not: fuselage geometry, seat layout, wing loading, engine requirements, landing gear, emergency exits, certification work, price, and schedule may all require review.
A software change behaves the same way. Changing one customer identifier or plan limit can cross a database schema, API, frontend, tests, billing logic, and deployment configuration. A session working on the UI may never use the same words as the original business decision, yet that decision remains mandatory.
This is where similarity search is insufficient on its own. The important question is not only which old text resembles the current prompt. It is which requirement, decision, interface, or dependent artifact still governs the work.
Memory retrieves; project structure obligates
Long context gives a model more material. Conversation memory helps it recover earlier facts. Project memory keeps files and discussions nearby. Those are useful, but none of them automatically decides what the current task is required to inherit.
Agentlas treats project context as a living chain of authority. A current decision can replace an older one. A requirement can constrain several artifacts. One artifact can consume another's output. A change can mark downstream work for review. The map stores those connections so a task does not have to rediscover them from prose.
This is not a claim that graphs, task decomposition, requirements traceability, or digital threads are new. The research question is whether those established ideas can be compiled into bounded execution context for independent LLM sessions, and whether doing so improves whole-project integration.
How the context reaches a real task
The system waits until a task is concrete. It then reads durable project purpose and decisions, refreshes the code index against the current source fingerprint, projects the functional relationships into the Sitemap, and follows the relevant dependencies outward from the task target.
The result is a Context Slice: a bounded packet containing the purpose, current constraints, related definitions and backlinks, adjacent artifacts, recent changes, and completion conditions needed for this task. The entire project map is not placed in every prompt.
After the task, the same dependency paths produce an impact set. Completion verification remains blocked until the affected files are reviewed or explicitly accounted for. The map therefore participates before work begins and again before success is declared.
A map on disk is not proof of use
The implementation is deliberately observable. A refresh counts only when the local Core process exits successfully and a canonical Code Map with definitions and reverse references is present. Merely starting a process does not count as a successful map.
Desktop separately records when project memory, Code Map, and Sitemap enter runner-context assembly. These receipts prove that a source crossed that host boundary. They do not prove that the model understood it, complied with it, or produced a correct result.
The Context Map remains local. Remote discovery may help choose an agent, but private source, project paths, and project memory are attached by the local executing runtime rather than sent to a marketplace.
What the 800-case structural benchmark found
Before release, we froze one source snapshot for each of four product surfaces—Core, Terminal, Desktop, and Web—and generated 200 exact-symbol change-impact cases per surface. For every case, the required file set was the symbol's indexed definition file plus every indexed reference file. The dependency slice returned the exact required set in all 800 cases, with precision and recall of 1.0 under that definition.
A context packet assembled at session start, before the task symbol was known, recovered 38.01 percent of the required paths. The task-time slices averaged approximately 334 token-equivalents using a four-characters-per-token proxy, compared with approximately 443,505 token-equivalents for the full maps—a 99.92 percent reduction in supplied map context.
This is a structural self-conformance result, not an end-to-end AI benchmark. The same frozen indexes defined the required file sets and supplied the dependency answers, so the experiment shows that the execution path preserves and selects its own recorded structure. It does not show that the index captured every real dependency, that a model made a correct edit, or that a complete project assembled with fewer defects.
Available in the current releases
Agentlas Core v1.1.67 provides the canonical local map commands, Code Map v2, functional Sitemap projection, task slices, impact traversal, and completion verification.
Agentlas Terminal v0.9.10 calls that Core surface directly and refreshes the map from the current project before task-time selection. Agentlas Desktop v0.9.22 verifies the map before use and supplies the resulting project context to normal runs and coordinated workers.
The public release, npm registry, and Desktop update feed remain the authority for whether each version is actually available. Source notes alone are not treated as release proof.
What we reproduced from the public artifacts
We downloaded the public Core archive, installed Terminal from the npm registry into an empty prefix, and downloaded the signed Desktop arm64 ZIP from the public release. Their hashes matched the release records, the Desktop update API reported 0.9.22 ready and notarized, and macOS Gatekeeper accepted the extracted application as a notarized Developer ID build.
On a small integration project, the public Core and the registry-installed Terminal both located the definition of resolveCustomerTier and its three backlinks across an API file, a UI file, and a test file. The generated Code Map contained three code files and five reference edges. Its Sitemap projection produced eight functional nodes and the two expected module dependencies from UI and tests into the API.
We then loaded the code shipped inside the public Desktop app.asar under the release's matching Electron ABI and ran it with the Core and Python bundled in that same public application. It refreshed Code Map v2, selected the API, UI, and test files into the task slice, read the functional Sitemap, assembled all three sources into runner context, and recorded separate code_map, pm_soul, and sitemap source receipts.
What remains unproven
The shipped system proves an engineering path, not an efficacy result. It does not yet establish that an LLM makes better edits, that natural-language planning improves, or that Context Map beats a tuned retriever, full-context prompting, or a central coordinator on end-to-end project quality.
Static references are also incomplete. Dynamic dispatch, generated code, runtime configuration, undocumented business rules, and cross-repository contracts can remain outside the map. Human-authored requirements and interfaces can be wrong or stale.
The research standard is therefore whole-project assembly: fewer global constraint violations, fewer interface conflicts, accurate change propagation, less stale-decision use, and less integration rework. Until those outcomes are independently measured, the strongest defensible claim is that Agentlas now has a working, inspectable mechanism for preserving project structure across decomposed AI work.
