The expensive part is finding the project again
A coding agent can read a repository. That does not mean it understands the project. At the start of a new run, it still has to recover the decisions behind the code, identify the real entry points, distinguish current surfaces from abandoned ones, and work out what has already been tested.
That repeated orientation is where context gets lost. A useful fix from yesterday becomes an unexplained pattern today. The agent scans directories it inspected before, reopens settled questions, and follows the most visible file instead of the surface most likely to contain the bug.
Project Foundation is the shipped Agentlas architecture for that gap. It keeps durable project state inside the working folder, builds a compact map of the code, and maintains a separate map of product surfaces and evidence. The next agent starts with those coordinates instead of another cold read of the repository.
The working folder becomes the boundary
When Agentlas sees repeated work in the same folder, it activates a project-local .agentlas foundation. You can also activate it explicitly. One-off folders remain untouched, and existing foundation files are preserved rather than replaced.
The folder boundary matters. Project-scoped memory, code location, risk state, and evidence stay attached to the project they describe. They do not become an unscoped pile of context shared across unrelated repositories.
Before an agent or a team worker begins, Agentlas builds a compact project context from the available foundation. The architecture does not paste the entire repository or chat history into the prompt. It selects a bounded view that can orient the run without burying the task.
- Project PM Soul owns continuity and durable project state.
- Memory Curator controls what becomes reusable memory.
- Code Map provides modules, entry points, symbols, references, and documentation locations.
- Task Bias Curator maintains the AI Sitemap and its evidence state.
Memory keeps decisions, not transcripts
The project memory begins with a readable project-soul-memory.md. It has explicit places for purpose, current state, decisions, pending work, risks, preferences, and lessons learned. Curated events and curator decisions remain separate, so a stable project fact does not get mixed with every temporary observation made during a run.
This is deliberately different from replaying old chats. The always-on curator resolves scope, rejects secret-shaped content, deduplicates equivalent candidates, and preserves supplied evidence. For explicit deep curation, the Memory Curator contract also calls for conflict review and evidence-backed durable facts. Agents are instructed not to emit credentials, private logs, or unsupported guesses as durable memory; secret-shaped candidates are rejected deterministically.
Recall is also scoped to the executing agent. Shared project context can be reused, while agent-specific repository memory stays with the agent that owns it. The result is less repetition without turning unrelated work into hidden prompt baggage.
Code Map turns blind repository search into a guided lookup
Once the project is active, Agentlas generates a code map in the background under .agentlas/code-map/. The generator indexes supported source and documentation files, including modules, application entry points, symbol definitions, references, and document headings.
For Git repositories, the map follows the files visible through Git and respects ignored paths. Common build output, dependency folders, ignored files, configured legacy or copy patterns, and the .agentlas folder itself stay out of the index. A compact seed of the map is then included in project context so the agent can start from likely modules and symbols before searching the whole tree.
The map is an accelerator, not a second source of truth. Generation is best-effort and non-blocking. A missing or partially generated map never prevents a run, and the agent still verifies its conclusion against the source and tests.
The AI Sitemap records what the code map cannot
The AI Sitemap is not the public XML sitemap used by a website. It is a project work graph stored in .agentlas/sitemap.json. Its nodes can describe product surfaces, services, data paths, checks, or other units that need ownership and evidence.
Each node can carry status, completion, risk, dependencies, acceptance checks, test recency, and evidence. A new sitemap starts without pretending the project has already been understood. When invoked, the Task Bias Curator can add newly discovered surfaces as provisional nodes, then refine them as the team inspects and validates them.
This makes bug discovery less dependent on recency. The Task Bias Curator can prioritize a high-risk surface with stale evidence and blocking dependencies over the screen that happened to be edited last. It can also challenge a completion claim when the corresponding check or evidence is missing.
Architecture joins the maps before execution
The value is not any one file. Memory explains why the project is in its current state. Code Map points to where the relevant implementation lives. The AI Sitemap shows which surface is uncertain, what it depends on, and how it should be checked. Agentlas Architecture brings those three views into the run at the working-folder boundary.
Consider a checkout that returns success while the account remains unchanged. Project memory can recover the current payment decision and known constraints. Code Map can point to the callback, webhook, and account-state functions. If the payment surface is represented in the AI Sitemap, its dependencies and last evidence narrow the first inspection further. The agent begins with a bounded path through the system rather than a repository-wide search.
After the work, only durable outcomes should survive: a verified decision, a changed procedure, a new risk, or an open loop. The transcript itself does not need to become memory.
Project Foundation is already part of the Agentlas Desktop runtime. Its built-in architecture is versioned and resynchronized without overwriting user chats, installed agents, or existing project memory. Individual maps can be absent or incomplete without stopping execution. The foundation does not make an agent infallible; it makes the project legible across runs.
- Memory preserves why.
- Code Map locates where.
- AI Sitemap exposes uncertainty and evidence.
- Architecture applies the right context to the current project and agent.
