What this rung really is
Level 8 is where the whole loop closes — and the system starts to remember. An agentic run goes end to end on its own: it works overnight across your projects and hands you a finished report in the morning, no babysitting. The leap at this rung isn’t doing more at once — it’s that each run leaves a trail the next run can use.
The trick is memory that compounds. Every run writes down what it learned — what worked, what to avoid, the patterns worth keeping — and the next run reads that first, so it starts smarter than the last. Clear this and you stop re-explaining yourself: the system carries its lessons forward, and good runs make the next ones better instead of starting from zero.
Close the loop — and make it remember
The move at this rung is memory that compounds: run a job end to end unattended, have it write down what it learned, and make the next run read that first — so every run starts smarter than the last.
This rung sits on everything you wired in rungs 1–7. You add memory across runs on top — you don't start over.
Do this rung, for real
Everything you need is here — no tabs to chase. First, the jargon this rung throws at you, in plain words. Then the steps, with the exact things to paste or say.
You run technical SEO for a dozen clients. Friday night you point the system at all twelve sites and say “audit each one, flag what regressed since last week, draft the fixes.” It works while you sleep and leaves a single morning report — twelve audits, ranked. The compounding part: this run remembers last week’s. It doesn’t re-flag the things you already told it to ignore, and it opens with “here’s what changed since Friday.” Each weekly run is sharper than the one before because it stands on the last.
End-to-end, unattended
A run that goes the whole way on its own — plan, do the work, check itself, write the report — without you driving each step. You set it off and read the result.
Why it matters here — This is the difference between a tool you operate and a system that runs. Your time moves from doing the work to setting the intent and reading the outcome.
Memory that compounds
The system saving what it learned from each run — the patterns, the corrections, the “don’t do that again” — and reading it back at the start of the next run.
Why it matters here — Without it, every run starts from zero and you re-explain the same things forever. With it, good runs make future runs better — the system gets sharper the more it works for you. The trick is a lifecycle: each correction starts as a hunch, earns confidence as later runs confirm it, and only then becomes a rule the system trusts everywhere — that’s how a good run makes the next one better instead of the system blindly repeating a one-off.
Capacity headroom (don’t die at 3am)
Running an end-to-end unattended job across enough model capacity that it doesn’t hit a hidden limit and stop halfway through the night.
Why it matters here — The most common way an overnight run fails isn’t a bug — it’s quietly running out of quota at 3am and leaving you a half-finished report. One caution: pooling personal subscription logins behind a shared proxy is against Anthropic’s terms — use the budgeted API-key path with fallbacks instead.
Run one job end-to-end, unattended
Take a recurring job you already do — a weekly audit, a content refresh — and set it to run on its own across your projects, start to finish, into one report you read later. Don’t watch it; the point is that it finishes without you.
Make it write down what it learned
At the end of the run, have the system capture the lessons — what worked, what to avoid, the patterns worth keeping — into a memory it keeps, not a chat you’ll lose.
Prove it carried forward
Run the same job again next week. Check that it opened with last run’s lessons — skipped what you already corrected, started from where the last run left off. That’s the rung: the second run is visibly smarter than the first.
Make it survive itself
Give it a finish line so it runs to done without you nudging it, save its progress to disk so a crash or a quota wall doesn’t cost the work, and put a quality check between the run and “done” so the unattended result is as good as the one you’d babysit. Now “it runs end-to-end” also means “it finishes even when something goes wrong at 3am.”
How you know it's working
Before L8: every run starts from scratch. You re-explain the same preferences, re-flag the same things to ignore, and babysit the work because nothing it learned last time survives.
- A real job ran end-to-end, unattended, into a report you read after — not step-by-step with you driving.
- The run wrote down what it learned into a memory the system keeps, not a chat thread.
- The next run opened with those lessons — it didn’t repeat corrections you’d already made.
- Each run is measurably sharper than the last, because memory carries forward instead of resetting.
- The run finished on its own — you set the finish line and walked away, instead of nudging it forward step by step.
- When it hit a wall — a crash, a quota limit — it saved its place and either resumed or told you, instead of silently dying with the work half-done.
Make it stick. Pick one weekly job and run it this way two weeks running. When the second run is obviously smarter than the first — fewer corrections, picks up where it left off — the system is remembering, and the rung is a habit.
Our skills for this rung
Linked items are founding-circle skills — clone the repo and run ./install.sh from the skills folder. Unlinked items are practices you build by doing.
Spec-driven run with QA loop + memory across runs. Share spec + audited output.
Clear this and you've genuinely cleared the rung — not read about it. Keep the proof; it's how you place yourself on the ladder.