From context window
to software factory.
Working with AI agents isn't magic, and it isn't a product you buy. It's five layers, stacked in order — and each one only works because the one beneath it exists. Tonight we build the stack from the bottom.
Everything an LLM knows right now fits in one window.
A model has no memory between conversations. The context window is its entire working world: your instructions, the conversation so far, every file it read, every command result. It's measured in tokens, it's finite, and every turn fills it a little more. When it's full, the oldest details get summarized away — and the model gets measurably dumber about your specifics long before that.
The harness helps: CLAUDE.md is re-loaded into every fresh window (standing instructions that survive amnesia), and resume can carry a summary of an old session into a new one. But summaries are lossy. The real fix is the next layer.
You can't manage what you can't see. A custom statusline pins a live fuel gauge under every prompt — context used, session limits, what's running. Mine looks like this:
One glance answers: how full is my window, and how much runway do I have? That number — ctx 33% — drives everything that follows.
Give it a memory that lives outside the window.
A second brain: a folder of plain markdown files the model reads and writes. Mine is a local SilverBullet instance — a self-hosted markdown wiki — exposed to Claude Code over MCP (the open protocol for wiring tools to models). What you're working on, what you decided, what's next: it lives in files, not in the conversation.
The payoff is psychological as much as technical: the moment state lives outside the window, clear stops being scary. Statusline says 40%? Write the handoff note, clear, start clean. Two minutes later the new session has read the brain and picked up exactly where you left off — no pain, nothing lost.
Don't rely on the model remembering to use its memory. Hooks are shell commands the harness runs deterministically at lifecycle moments — so the brain is impossible to forget:
Opening hook makes every window brain-aware; closing hook makes every window pay its knowledge forward. The loop closes itself.
Host it once. Then talk to it from everywhere.
A brain on your laptop is a brain with office hours. Push the same SilverBullet instance to Railway and it becomes a URL that's always up. Then put a custom MCP server in front of it — a small program that exposes your brain as a handful of verbs — and every Claude you own can reach it: the CLI on your machine, the desktop app, the browser, your phone. One brain, every door.
Not a product you buy — a few hundred lines you write. You decide the verbs. The model never touches your files; it calls your API, and your code decides what's allowed:
Give it good verbs and the model uses the brain well by default. That's the real lesson: the write API is the governance layer — make the cheapest call the correct one, and you won't need to nag the model in a prompt.
The payoff is that context stops being tied to a device or an app. Ask "what did I decide about the digest feature?" from the grocery store. Capture an idea into the inbox from the couch. Start a session on the laptop that already knows what you told your phone this morning — same brain, same memory, whichever door you walk through.
Add a backlog, and every session knows what's next.
Inside the brain, keep one structured list: numbered items you want built — as broad or as narrow as is useful to you. Each item carries just enough context to be picked up cold. Now a fresh context window isn't just oriented; it has a queue. Session ends mid-item? The next one reads the note and continues the chain.
Pause here and notice what you have: durable memory plus structured intent. A stranger — human or machine — could sit down at this desk and be productive in ten minutes. That property is the whole ballgame, because the next layer is about inviting strangers in.
"Agentic" is a fancy word for something simple.
Strip the buzz away and an agent is just this: spawn an LLM with a specific set of preexisting context, a set of tools, and a goal — then let it work. That's it. That's the whole trick.
Here's why the ordering of this talk matters: an agent spawned into a vacuum flails — it hallucinates state, repeats work, loses the thread. An agent spawned into layers one through three wakes up oriented, with a queue. You haven't just built yourself a memory system. You've built the environment in which agents can be productive. The brain is the onboarding packet; the backlog is the job description.
Put your first agents to work on the brain itself.
Lowest stakes, highest compounding value: while you sleep, agents make one pass over the brain. Every morning it's fresh, deduplicated, and token-efficient for the next session to load — memory that maintains itself.
merge sprawling notes, tighten the prose, keep the facts
the same decision written down three ways becomes one page
stale items flagged, done items closed, next items sharpened
the index page rebuilt so a cold session orients in one read
Slash commands are skills you can invoke — or write yourself as a markdown file. These four carry the night shift and the day shift:
run a prompt or skill on a recurring interval — or let the model pace itself. This is how "overnight passes" exist at all.
pin a standing objective on the session — every turn, it steers back toward the goal instead of drifting.
watch a live progress tree as a script fans work out across many agents — orchestration you can actually see.
toss an aside into the brain's inbox mid-session — captured without derailing whatever is currently running.
Then scale it: an agentic development factory.
Once agents tend the brain reliably, point them at real software. Add a supervisor that owns the backlog and dispatches work; dev agents that build in isolated branches; QA agents that review adversarially; and a human approval on everything that matters. This is the architecture running the NOLA estate today.
Same loop as layer two — read the brain, do the work, write it back — just running many times a day, in parallel, with a human holding the merge button. The case study has the real numbers, including the failures →
Durable context. Structured work. A team that burns it down.
That's the whole foundation. Nothing exotic: markdown files, git, a wiki, cron, and a CLI — each layer boring on its own, compounding when stacked. Start at layer one tonight; you can be at layer three by the weekend.
Want this stack under your business?
Everything in this talk runs in production today for a real Charlottesville company — brain, backlog, night shift, factory, and the safety engineering that makes it trustworthy.