How memory works in Astell
Inside Astell's memory architecture, why conversations never hit a context wall, and how agents share one memory.
The context wall
Every AI chat tool has the same physical constraint: a model can only read so much at once. Most products handle it by letting the conversation grow until it no longer fits, then squashing the transcript into a summary. If you have used tools that make you run a compact command, split work into separate projects to keep contexts small, or quietly forget the constraints you stated an hour ago, you have met this wall.
Astell is built so you never manage that constraint yourself. There is no compact step, no dividing work across folders to protect a context window, and no point where a long conversation forces a reset. It works this way out of the box.
A team of agents, not one model
When you chat with Astell, you are not talking to a single model with a single transcript. Behind every conversation is a small team:
- A router agent talks to you. It understands your question, decides what work is needed, and writes the final answer.
- Specialist agents do the heavy lifting. A search agent retrieves and reads from your indexed workspace; an action agent executes Astell Actions. The router can delegate to them multiple times in one turn, and delegated work runs in parallel rather than taking up room in the main conversation.
- A memory observer runs alongside the whole time. Its only job is to watch the conversation and maintain a curated record of what matters.
Every agent on the team reads and writes the same memory. Nothing needs to be handed off or re-explained between them.
Observational memory: curate continuously, never compact
The observer is the piece that removes the context wall. Instead of letting the transcript pile up until something must be thrown away, it continuously distills the conversation as it happens:
- It keeps your questions and intent, the entities that were found and their identifiers, the key facts behind each answer, what was ruled out and why, dead ends that returned nothing, and every correction you make.
- It drops the bulk: full document text, raw search payloads, and anything that can be re-fetched from the workspace index on demand.
The result is that the working context stays small and dense no matter how long the conversation runs. A three-hour session and a three-message session occupy roughly the same working space, because everything durable has been distilled and everything bulky is retrievable by reference. That is what we mean when we say context in Astell is effectively infinite: the conversation never has to stop, reset, or squash itself to continue.
This also protects accuracy. Compaction-based tools summarize under pressure, at the worst possible moment, with no principle about what to keep. The observer curates continuously, with explicit rules about what matters, so constraints you set early in a session still bind at the end of it.
One memory, shared everywhere
Memory in Astell is scoped to you and your workspace, not to a single thread or a single agent:
- Across agents: the router, search, and action agents share one working memory. What one learns, all of them know.
- Across threads: a new conversation does not start from zero. Astell recalls the most relevant context from your past conversations and carries it forward, so you can pick up Monday's plan on Thursday without restating it. See Memory and Ultra mode for how much history each plan carries forward.
You never partition your own context to make this work. There are no per-project memory silos to configure; relevance, not folder structure, decides what gets recalled.
Memory never invents citations
One rule keeps this honest: answers cite fresh sources, not memories. When Astell cites a document, message, or ticket, the citation comes from the search agent retrieving that artifact from the index in that turn. Remembered facts guide where to look, but a claim is only cited when the underlying source was actually re-fetched and checked. Distilled memory can never be laundered into a fake citation.
Why this design matters
- Accuracy: context is curated by rule, not truncated by accident, and citations are always backed by a live source.
- Efficiency: tokens go to distilled facts and fresh retrieval, not to re-reading an ever-growing transcript. Longer conversations do not get more expensive per question.
- Continuity: decisions, constraints, and corrections survive across hours, threads, and agents without you carrying them.
For what memory does not do (it never expands permissions, and it is not a substitute for ingesting your workspace), see Memory and Ultra mode.