How It Works
Two halves working as one: Parcle builds your memory from everything you do, then injects exactly the right context into each agent conversation — saving tokens and improving accuracy.
The Personal Brain works in two directions. Memory Build turns your scattered sources into structured memory. Memory Injection feeds that memory back into your agents at the moment they need it. Together they make every agent understand you and finish the work that needs your context.
From many sources, Parcle constructs three memory systems: a timeline, a graph, and a curated wiki.
A hook or memory provider detects which agent turns need memory and injects just what they need.
Memory Build#
Memory Build is the construction side. Your Connectors pull in everything you already do, and Parcle sorts it, indexes it, and builds your memory systems on top — a pipeline that runs in the background, so ingestion never blocks your agent.
Every source is sorted into one of three kinds: chats, files, or agent sessions.
All of it gets embedding and lexical indexing, so anything can be found fast — by meaning or by exact term.
On top of the index, Parcle uses LLM analysis to distill two things separately: your Memory Events timeline and your LLM Wiki.
An agentic, explorable process then builds an Ontology Graph over your events and wiki nodes — for example, the relationship graph between the entities and events in your memory.
The result is your three memory systems — Memory Events, Ontology Graph, and LLM Wiki — kept current as new sources arrive and private to you. Together they are your Personal Memory Design.
Memory Injection#
Building memory is only half the job. The point is to get the right memory into your agents at the moment they act. Parcle does this with a hook or a memory provider that sits in your agent's loop, so you never have to fetch and paste context by hand.
The hook watches the conversation and detects when a turn actually needs memory — and what kind. Turns that don't need it are left untouched.
It queries your three memory systems for just the relevant pieces: the preference, the past decision, the project fact — grounded and scoped to you.
It adds that memory to the agent's prompt right before the model runs. Only what the turn needs goes in — not your whole history.
The agent answers with your context already in hand, and what it learns flows back into Memory Build for next time.
Inside a retrieval#
When a turn needs memory, retrieval runs a short pipeline of its own, so the agent gets the few right facts instead of a dump of your history.
Before anything is fetched, an intent gate decides whether the turn needs memory at all, and what kind. Turns that don't just pass straight through.
A router narrows the search to the sources most likely to help, instead of scanning everything.
Three search agents run in parallel, one over each memory system. Each searches two ways — by meaning (embedding) and by exact term (lexical) — and each is handed rich filters (time, tag, source, type) so it decides autonomously what to pull.
The results are merged into one grounded answer with citations and a confidence signal, ready to inject.
Because only the memory a turn needs is injected — not your entire history — prompts stay small, so you spend fewer tokens, and the model stays focused on what matters, so answers are more accurate. You get the benefit of full memory without the cost of stuffing it all into every prompt.
The hook plugs into agent frameworks; the memory provider is a drop-in for platforms that support one. Either way, injection is automatic once your agents are connected. See Agent Sync.
A worked example#
You tell a fresh coding agent: "Set up the database for the new service the way I usually do."
- Detect. The hook sees the turn depends on your past decisions and preferences, and flags it for memory.
- Retrieve. From your LLM Wiki it pulls your stated preference (Postgres for anything relational); from your Memory Events it pulls the schema choices you made on the last service.
- Inject. Just those few facts are added to the prompt — not your whole history — so the agent starts already knowing how you work.
- Complete. The agent scaffolds the database your way on the first try, and the new decisions it makes flow back into your memory.
You never pasted a preference or re-explained last week's design. Parcle detected the need, supplied the context, and the agent finished the task.
The sources Memory Build draws on.