Backfill
Stele is most useful on a project that already has history. Backfill seeds the record from what you've already built: the code, the git history, the docs, the issues , so a fresh graph starts full instead of empty. Your own agent does the reading; Stele coordinates it and stores what it finds.
Who does the reading
This is the part to be precise about: Stele doesn't crawl your repo on a server. Backfill runs inside the agent you already use, on your machine. When you start it, your agent takes the role of orchestrator and spawns a wave of focused, cheap-model "missions". Each one reads a different source and reports back what it found. Nothing leaves your machine except the findings you approve.
Backfill is an agent-driven flow, not a magic importer. It reads what you point it at, fact-checks its own findings against the code, and asks for your approval before it writes. Facts it can't tie to a source are dropped rather than guessed.
What it reads
Each mission specializes in one source, so the findings come back sourced and specific rather than vague:
- The code. The structure of the system and the components it breaks into.
- Git history. The decisions and reversals written into commits over time.
- Issues & pull requests. The problems that came up and how they were resolved.
- Documentation. Design notes and READMEs already in the repo.
- Past agent sessions. The reasoning from earlier work with your agents. Supported local histories are discovered automatically, including Pi sessions; when a Pi session has branches, Backfill follows the branch you kept rather than importing abandoned detours.
How a run goes
You stay in control the whole way. Backfill checks in before it gathers, before it spends on a model tier, and before it writes , so the scope is yours to set.
Every node it writes carries its provenance , where the fact came from , so you can trace any backfilled decision back to the commit, issue, or file it was drawn from. From there the record behaves like any other: it's served back on prompts, and it ages and gets verified like knowledge you write by hand.
Run it
Backfill is part of /stele:start. On a project with history, it offers to seed the record as the first step. You can also run it on its own with the /stele:backfill command, or just ask for it in plain words:
Backfill this project into Stele. Read the code, the git history, and the docs, fact-check what you find, and show me the findings before inserting anything.
You may not need to ask. When the record is still nearly empty, your agent is told about Backfill as it works, so it can offer it at the point you'd actually want it. The same happens if a directory isn't bound to a project yet, pointing at /stele:start instead. Both are offers, not interruptions: each is raised once and then stays quiet for a while, and they stop for good once the record has enough in it to be worth recalling.
On a large repository you can scope the first run to the part you're actively working in, then widen it later. Backfill adds to the record; it never overwrites what's already there.