Reaching the Summit

Two sentences of context first. Fiddle is an app I build on nights and weekends, a system of record for a car build: the mods, the service history, and the parts, all in one place. It needed a parts catalog, and no usable one existed to license, so I wrote my own crawler, Orb-Weaver, which visits a few hundred brand sites and assembles the catalog itself: 245,471 parts so far, each with a real photo and a fitment answer.

A crawler you run against other people's websites should be a polite guest, and a polite crawler is a slow one on purpose. When I kick off a full sweep it commits to a long run: days of paced requests, because the pace floor is a policy and policies don't bend to my impatience. Somewhere around day three of an early run I noticed something uncomfortable. I had complete visibility into what the crawler was doing, and almost no ability to change its mind.

I could stop the run. I could edit the code and start over, forfeiting three days of good work. What I couldn't do was reach into a crawl that was six days deep, adjust one instruction at one level, and let everything below it re-run while everything above it stayed exactly as written. And that gap only widens as the runs get longer.

So I built Summit.

First, the ideas this stands on

Three borrowed ideas do most of the work here, so a quick pass through them. Kahneman's two systems: System 1 is fast recognition, System 2 is slow, effortful reasoning, and most System 2 moments in a product are unintentional, information the interface had and didn't show. Memory symbols: people hold their place in a long process by anchoring to a compact, recognizable token. A wizard step, a saved draft, a step indicator: the symbol is where you stand. And altitude, from the last post: the level of abstraction a system is operating at, which steers everything and shows up nowhere.

None of them are mine. Kahneman's book has been out for fifteen years and wizard steps are older than the web. What was new for me was needing all three at once for something that wasn't a person.

Observability was never the hard part

Every agent framework will happily show you a log, and mine was no exception. The stream told me everything: every fetch, every parse, every deferral with its cause attached. And at two thousand lines an hour, the only questions it could answer were about the past. Nothing in it gave me a handle on what the crawler was about to do next.

Why? Because a raw log line is System 2 material. Every line demands parsing, and nothing about line four hundred is more recognizable than line four. Meanwhile the things I actually wanted to do were not log-shaped at all: loosen the pacing for one brand that had invited the crawl, change what counts as photographic evidence, swap the fallback strategy for brands that don't publish a sitemap. Some of those changes belong to a single run. Some belong to policy and should outlive every run. The code had flattened all of them into one pile, and the log couldn't tell the difference either.

Naming the instructions

The move that made Summit work was embarrassingly simple to state. Every instruction the crawler holds gets a name and becomes a memory symbol: “Target rule: crawled + Shopify feed.” “Pass rule: quality_check ok on 25 rows.” “Sandbox keeps this reversible.” Then the symbols get sorted by altitude on a vertical map. The mission sits at the top. Strategy, the rules of the approach, sits under it. The plan's ordered steps under that, the task in hand under that, and the details at the bottom, filling in as the run works.

After a day with the map you stop reading and start recognizing. A glance at a band, a name, and you know where the run stands, the same way you know where you are in a checkout flow without reading the step labels. Bands two or more levels from the marker collapse to a count, so the map never asks for more attention than the moment deserves. That's an amount of attention a person can actually sustain across a nine-day run.

What a selected symbol shows

Have you ever changed a configuration value and found out three systems later what it actually touched? That experience is why Summit draws its dashed lines.

Click a chip and it explains itself. The card carries the instruction's summary in the agent's own words, which is the why written down: the method rule exists because every brand gets probed before harvest, and the probe decides the method. Under the summary sit the linked symbols: the four plan steps that inherit the rule. The band answers who would have to approve a change. The links answer what would feel one. None of that information is new. It was always in the system. It had just never been shown at the moment you'd want it.

The louder version appears the moment you stage a change. Open a symbol for revision and, before anything commits, dashed lines run from it to every symbol that was derived from it, band by band, down the whole mountain. Editing the method rule draws twenty of them, through the plan steps it shaped, into the tasks and the evidence they produced. Staging a forget colors the same lines by consequence instead, red for symbols that would lose their only support, green for ones that stand on other evidence. Nothing has committed yet; the map is showing you what would happen.

The dashed line answers the auditor’s question before anybody asks it: not what happened, but why it was allowed to happen.

Steering mid-run

This is the part I built the whole thing for. The marker on the left rail is the agent's altitude, and it's yours to drag. Pull it up to Strategy while the run is working and the agent finishes nothing below it: it reads your move, holds its next step, and waits until you let it back down. Lock the gate at Task and it can plan all it wants, but it can't touch a site until you approve, with a note that goes on the record.

Forgetting is scoped the same way. Forget a symbol and everything under it is skipped: the step, its tasks, its details, while every symbol above holds untouched. This works on a crawl days deep and it works on a run that hasn't started, which is the same map with empty bottom bands. The mission and the strategy never re-enter discussion, because their bytes never moved.

I should admit the first version of this was nothing like it. My first pass was a prettier log viewer, and I spent a real weekend on it before conceding that it helped nobody, myself included. It answered questions about the past faster, and the past was never my problem. I scrapped it and started on the map.

Why this belongs in regulated rooms

My day job is agentic design for supply chains, where software that acts on a company's behalf answers to gates, auditors, and rules that permit no waiver. The property those rooms want is not observability, which they already demand and get. It's scoped change control. What was done, and why: the symbol and the summary it carries. What it affected: the symbols linked under it. And when something has to change mid-process, the change lands at a named altitude, only the layers below it feel it, and the approvals that blessed everything above remain standing, verifiably, because the record shows those layers never moved.

I've heard validation teams ask for that conversation repeatedly. Most systems can only answer with a diff.

I haven’t seen this anywhere, which is worth saying carefully

I've looked. Orchestration tools have DAGs of tasks. Observability platforms have traces. A few agent frameworks have replayable steps, and prompt tooling is starting to version instructions. I haven't found the combination: instructions as recognizable symbols, stacked by abstraction, with impact drawn as dashed lines at the moment of decision, steering by dragging a marker on the same map, and every intervention recorded beside what the agent did next. That either means the idea is genuinely new or it means I searched badly, and I can't fully rule out the second. I didn't arrive at it through research. I arrived at it because a crawl was six days deep and I needed to change its mind.

Either way, the concept costs nothing to adopt. There's no model in it and no product to buy. It's a way of organizing what your agent already holds.

So how do you build one?

• Name every instruction. If you can’t give it a short name, it’s two instructions. The name is what buys you recognition later.
• Sort by altitude. I sort an instruction by who would have to approve changing it. If the answer changes, it’s a different layer.
• Draw the lines. Every symbol records what authored it and what inherits it. Draw that at the moment of decision, not in a report afterward.
• Scope the re-run. A change at altitude N re-runs N and below. Never above. That single rule is what keeps the approvals standing.

Then put it in front of whoever answers for the agent's behavior and watch which questions disappear.

There's a second half to this I haven't covered: what a symbol has to carry so that somebody who wasn't in the room can replay a change years later and reach the same conclusion. That's a records problem more than an interface problem, and it deserves its own post. For now, the crawler is on day four of a run, and I've changed its mind twice without stopping it.