Backfill
Stele is most useful on a project that already has history. Backfill seeds the record from what you already know: code, history, documents, or past conversations you provide. Your agent reads the sources it can access and saves sourced findings to Stele.
Who does the reading
This is the part to be precise about: Stele doesn't crawl your repo on a server. The local backfill command runs inside your coding agent. 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 is uploaded to Stele except the findings you approve. Your agent provider handles source material according to its own settings.
Bulk Backfill validates an import file and inserts it through the CLI. A hosted chat has no bulk import tool today. You can still bring selected context into Stele from chat using ordinary knowledge and document writes.
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 local backfill 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 local 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 local backfill
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.
Bulk import writes draw from a finite, one-time allowance before using your monthly write allowance. Once the import allowance is exhausted, remaining writes count toward the applicable monthly limit. A large first run can exceed the allowance; check your account's current usage before starting.
Bring existing context from a hosted chat
The Backfill workflow assembles and validates an import file, then uses stele project import to insert the batch. That bulk import is not exposed through hosted MCP today. For a full Backfill, use the local workflow above. The steps below are for saving selected source material through the agent's existing tools.
In ChatGPT, Claude, or another connected agent, choose your Stele project first. Then provide the material you want it to learn from: pasted notes, uploaded documents, conversation exports, or sources available through the host's other connected tools. A repository connection can help only if it lets that agent read the needed files and history.
- Identify the project and the sources to cover. Ask the agent to state which it can actually read.
- Have it read the existing Stele record before extracting facts, so it can update earlier entries instead of duplicating them.
- Review the proposed decisions, lessons, risks, and commitments with their source references. Keep uncertain inferences separate from confirmed facts.
- Ask it to save the agreed findings, link related records, and report which sources remain unread.
- Retrieve a saved finding from a fresh conversation to check that the context is available.
Save useful context to Stele project <project-slug> from the material I provide. First tell me which sources you can read and check the existing record for related facts. Extract durable decisions, lessons, risks, and commitments with their sources. Show me the proposed additions and updates before saving. Afterward, give me the saved record links and list anything you could not read or verify. If the volume calls for bulk Backfill, explain the local import requirement before proceeding.
Connecting Stele does not give the agent access to your computer, private repositories, or every past chat. Supply the material or connect a source the host supports. These ordinary Stele writes use the applicable plan limits; do not assume the bulk import allowance applies. For a large collection, use local Backfill rather than assuming that hundreds of individual writes are the same import path.
For a larger source review in ChatGPT, switch to Work and ask it to divide independent reading among subagents, then combine and verify their findings. Availability depends on your account and environment. Switching modes does not add Stele's bulk import tool: use the local import workflow for the final batch. See OpenAI's guide to Chat and Work and its subagent guidance.