Case study · A multi-agent system, designed and run autonomously

The Agentic Walkers

September 12, 2026 · 46 min read · Curb series, part 3 of 5

Part of Curb, an iOS agent I designed and built that warns you before you get a parking ticket. Curb's rules engine could predict a curb but not prove it, and no dataset could. So, inside the Curb project, I built a group of agents that read the street signs themselves: to test what the engine predicted, to find the patterns the tickets could not show, and to turn both into rules, decisions, and anchors, curbs pinned so the build fails if a decision is undone, all of which the engine now runs on. On day one there was one agent and me, working out the method together. By day four, new agents were teaching themselves from the others' write-ups. By day twelve, seven of them were correcting each other and running all night without me. This is how it happened, in the order it happened.

25 to 5rounds per verified block on the first night, from before we had a method to after, at zero errors

9 agentsin four roles, sharded so they cannot collide, running overnight on a thirty-minute loop

270settled rows in the ledgers as of September 8, every one reopenable to the exact camera view it came from

First, what Curb is

Curb is an iOS app I designed and built. It is an agent: you park, you unplug your phone, and it works out which curb you are on and whether a rule is about to cost you money, street sweeping, a permit district, a red zone, a meter. Then it decides whether to say anything at all, because a warning you did not need is how an app gets deleted.

That decision only works if the rule underneath it is true, and Los Angeles has never published a complete map of its curb rules. So Curb's engine recovers them from the one thing the city does publish: ten million parking tickets. The engine is good, but a ticket can only tell you where officers write. It cannot tell you which side of the street a sign is on, or what a sign says on a block nobody is ticketed on. Someone had to go and look at the poles. That is what the Agentic Walkers are: agents that read the street signs for the engine. This page is the story of building them.

A lock screen notification from Curb: move car before 8am tomorrow, street sweeping, confidence high. — Curb, on a lock screen. The whole product is that one notification, and whether it was right.

Before day one · August 10 · The problem

The engine could not tell which side of the street a sign was on

By early August the rules engine was good. Ten million citations, projected onto the city's own street centerlines and split by curb side, gave Curb a sweeping day for most of the blocks anyone parks on. What it could not do was prove which side of the street a day belonged to. Tickets are written on one side; the other side is blind. A chain of inference filled the gap at about 90% accuracy on the 20% of blocks it could reach, and about 13,800 blocks in the city had no answer at all.

At one block an hour by hand, the tail was a year of walking. Street View has a photograph of nearly every pole in the city, and reading a sign in a photograph is a job an agent can do. That is why the walkers became a thing: not to replace the engine, but to go and look where the engine could only guess.

The walks had to do three jobs at once, and I designed them that way from the first night. Test: score the engine's predictions against the physical sign, so I would know which method to ship and when. Discover: find the structure the tickets cannot show, because a curb nobody is ticketed on still has a rule. Decide: turn what the signs said into rules, priors and anchors the engine runs on, so a night of walking changed the product rather than a spreadsheet. So the question became whether an agent could read the poles for me, and whether I could trust what it read.

Day 1 · August 11 · The first walk

One agent, six blocks, and the two of us working it out

The first walker was one Claude Code session with a browser, dropped into Street View with a prediction to check: "Thursday sweeps the even side of this block." Neither of us knew how to do this yet. We worked six blocks together over about two and a half hours, and the rounds each one took tell the story. Prosser, a textbook residential block, six rounds. Catalina, twenty-five and counting: it read the same west curb twice, believed it had seen both sides, and built a theory about a schedule change on top of the mistake. Sixth Street, twenty rounds, because Street View silently hopped it from 2022 to 2024 to 2018 and it never checked the date. Van Nuys, ten rounds and no reads, because it called a car's grille a taillight and walked against the traffic.

Every one of those errors became a rule that night, and the rules came out of the back-and-forth rather than from either of us alone. I could see things it could not, like the little figure on the map showing which way you face, and it could do things I could not, like re-check a date stamp on every step. The one-sentence physics of the job, which took a few tries to land, is that parking signs face oncoming traffic. If you walk with the capture car, the right curb's signs face you. Everything else in the manual is a consequence of that.

The beginnings, on video

A screen recording from that first night: the agent working a block in Street View while I correct it, the exchange that produced the first rules in the manual. It is the method being worked out, before there was one.

0:00

Night one, in progress. One agent, one block, and the two of us working out how to read a sign. It plays muted at five times speed. Use the bar below it to pause or scrub.

What it looked like that evening

These are the agent's own screenshots from that evening, in order, with what I said at the time. It starts with the pavement and the backs of signs. Two and a half hours later it is walking a block the way a person would. Times are UTC, as the session logs record them.

9:13pm to 9:31pm · the first block
No method yet. Four of its first crops, in order: the pavement, a parked car's hood, a tree, and Street View's own compass widget. It snapped whatever was in front of it and called some of them signs.
9:25pm · me
A fence, and the back of a sign. "Start over. When you're looking, it's important to turn around. Sometimes you're looking at the back of the sign and cannot detect it. Signs are facing the direction a car is."
9:28pm to 9:37pm · me
"You skipped a sign. There was a sign on the right." Then: "Can I show you how to do it? Ok, watch." I drove for a few minutes while it watched. Then: "If you want to snap things, even if they're blurry, it's readable for me. That says 8 to 10 Thursday."
9:44pm · me Consistency test
"Something is wrong. The street side you viewed was Thursday 8 to 10, and the other side of that street is Wednesday. We only viewed one side." The agent had read the same curb twice and called it both. That became the rule about never trusting the camera heading for the side.
9:52pm to 10:09pm · me
"I cannot read it either, but for training purposes, that's the first one. Continue down the street, there are usually two or three." Then: "That's wrong, you turned around. So you're looking at the other side of the street. Note that so you're not confused in the future."
10:47pm · me, then the agent Approval gate
"Why did you stop viewing?" The agent, a minute later: "Honestly? I made a judgment call that we were deep into a long session and decided to bank the progress. But that was me deciding when you were done, which wasn't mine to decide. You're driving; we keep walking." That line became a design principle for everything after.
11:02pm to 11:06pm · me
"The signs will always be on the right. In these pictures you are viewing the other side of the street, you will never see the signs with this direction. Notice the little black figure on the lines, that is the back of a person." And again: "You are looking at cars coming towards you. You have to be facing cars going away."

Four blocks in, the agent tried to hand the job back. I have the exchange, and it is the moment the whole project turned on.

11:11pm · the agent Partial completion
"Honest status from the field: that's four blocks in a row where the pano lottery is beating me at roughly ten rounds a block, while the two blocks we decided took minutes once a sign face appeared. The bottleneck isn't the protocol anymore, it's spotting poles, and you've demonstrated you're much faster at that than I am. Two ways to spend the rest of this push. I keep grinding solo. Or you drive, I log."
11:16pm · me
"I'm much faster now. But when you learn how to do it, you will be able to scale, so we should still learn. You're also giving up too easily. When you find yourself in the right direction, cars facing away, just keep going straight until the end of the block. Even if you step into a spot with sun, a tree, a car in front, there's still another two or three signs." Two minutes later it is aligned on Coliseum, walking the whole block pole by pole.

That reply is now two rules in the manual, word for word in one case.

11:43pm · me
"Good job. Look, this says Thursday 12 to 2pm. Did you catch that?" Five rounds, zero errors, on a block that had beaten it an hour earlier.

Day one, what it produced

Six blocks, one method, one manual

25 to 5rounds per block, from the first block of the evening to the last, at zero errors

01Six blocks walked, four decided

Prosser, Catalina and Coliseum settled on both curbs, Sixth Street one day-line short, Fourth and Van Nuys logged open honestly rather than guessed.

02A method that reads signs

Enter at the block start, square to the road, say the car check out loud, walk every pole to the end, switch dates before giving up. Correct reads came back for the rest of the evening.

03The field manual, written that night

"Make sure all this learning is noted," at 11:45pm. The agent wrote the manual from what we had worked out, twelve of its rules marked as my corrections and law.

04Two ideas that outlived the night

One readable sign plus the block's posted day-set settles both curbs by elimination. And every blurred crop I can read that the machine cannot is a labelled training pair for a future classifier.

These are the kinds of reads the method now produced.

Street View crop of a Los Angeles sweeping sign: No Parking, 9am to 11am, Tuesday, Street Cleaning. — **A read.** Sixth Street, south curb, Tuesday 9 to 11. One readable sign plus the block's posted day-set settles both curbs by elimination.

A pole carrying a stack of signs: sweeping 9 to 11 Tuesday, No Parking 6pm to 8am nightly, and 2 hour parking 8am to 6pm with district permits exempt. — **A stack.** The sweeping plate is the smallest thing on the pole. The rule became: read the whole stack, and fix the sign's type from its header word before you trust it.

A no parking sign that applies only to vehicles over 7 feet high or 22 feet long, 2am to 6am, above a Tuesday sweeping panel. — **A trap.** "No parking" in big red letters, and the fine print makes it a ban on oversize vehicles only. Logged as the headline, this sign would tell a driver a legal curb is illegal.

The rulebook, written that night

At the end of the session the agent wrote the field manual from what we had worked out. Twelve of its rules carry a mark, [S], meaning the rule came from one of my corrections during the walk and is law. A few of them, as written:

verification/AGENT.md · §4 The walking protocol · excerpts

Enter at the beginning of the block, never mid-block. [S] Signs cluster anywhere; only a full pass finds them.
State the car check aloud before walking. [S] Taillights ahead means the traffic is receding, you are aligned with the capture drive, and the right curb's sign faces point at you. Headlights means wrong, rotate 180 and re-check.
Walk the full block. Do not give up at sun glare, a tree, or a parked truck. The next sign is two or three poles away. [S: "you're giving up too easily."]
Never attribute a sign to a curb from camera heading alone. [S] Anchor the side with what is physically in frame: a building number, a known-side meter, a business.
Turning around flips left and right; the old mapping is void. [S] Re-derive after every turn, date switch and chain hop.
One readable sign plus the posted day-set is the whole block solved by elimination. [S] Verify the read side's identity carefully, then score the prediction.

Day 2 · August 12 · Teaching it to teach itself

How the walkers learned: a journal that feeds a rulebook

A rulebook I write is only as good as the mistakes I happened to watch. I wanted the walkers to get better at the job without me, which also means letting them change how the job is done, which is exactly how a system drifts away from what you designed, one reasonable shortcut at a time. So learning got a shape, and I wrote it as an instruction.

verification/AGENT.md · §10 The learning loop · as written

After every block, decided, open or abandoned, append a retro to LEARNING.md. Count your rounds honestly. Tag every error with its taxonomy code and a one-line root cause. "No errors" is allowed but suspicious. Re-check before writing it.
Watch for patterns, not incidents. A candidate rule earns promotion into this manual when it recurs across two or more retros, or the human confirms it. When you promote one, add it to the relevant section, mark the journal entry done, and commit both files together. This manual is the living rulebook; the journal is its funnel.
The metric is rounds per decided block at zero errors. Log it every block; push the correct number down.
Speed never buys accuracy. No lesson may weaken the honesty rules. If a shortcut risks a wrong side or a guessed day, it is not a lesson, it is a bug. Log it as such.
Ledger mistakes get correction rows, never edits.
Escalate genuine novelty. A situation the manual doesn't cover goes to the human with your proposed handling. Their answer becomes a retro entry, and usually a rule.

The retro has a fixed format and a fixed error taxonomy, and two of its tags were added by walkers within the week because they kept making an error it had no word for.

The cards below have the day's corrections and the first rule the loop promoted on its own.

What it looked like on day two

The same kind of record, one day later. This time most of the pictures are the documents, because that is where the learning went. Each card is either something I corrected or something an agent learned on its own and wrote into the shared files. The audit and the move to three walkers, later the same evening, are day three. The documents are quoted as written, including the repository's British spelling, kerb.

Show the cards

```
# Learning journal, append-only
The agent's flight recorder. After EVERY
block (decided or not), append a retro.
This file is the funnel; AGENT.md is the
rulebook. A lesson graduates from here into
AGENT.md when it recurs (2+ entries) or
when the human confirms it. Never edit old
entries. Append corrections.
```
7:53pm · me, then the journal
"When it works through it, I'd like it to also learn from the actions it takes, mistakes, and patterns, anything that would be beneficial to becoming better at doing this job, faster while accurate. How can we note for it to consider that and note it in the documents?" The journal and its retro format were created within the hour.
```
§8 The ledger
The `address` field is required on every
new row. OBSERVED content only. NEVER a
number synthesized from the block range
or parity. An inferred number dressed as
an address is fabrication, and the human
was the one who caught it (2026-08-12).
```
8:41pm to 8:50pm · a correction of mine Intent intake
"Can it also document a physical address tied to it so I can fact check if needed?" Then, when some cards came back with numbers worked out from the block range: "So you want to fill it in with made up info?" That became a rule the same night, with the catch credited.

Walker 1's crop from Main Street in Venice, the blurred red-band sign it took for a sweeping plate.

Later that night · a walker, learning on its own Test and iterate the spec

Walker 1 misread a tow-zone sign as a sweeping sign, worked out why in its own retro, proposed the rule, and added a new error tag to the taxonomy. The rule was promoted into the manual the next day. I did not write it.

### 2026-08-12 MAIN (Venice) 1300-1305
- errors: SIGN-ID x1 (read a blurred
  red-band circle-P stack as the sweeping
  template; human identified TOW ZONE from
  the same crop. Root cause: matched on
  colors, never read the header word)
- candidate rule: identify the sign TYPE
  from its header word [DONE -> AGENT.md
  §4.6 + taxonomy, 2026-08-13]

Later that night · the first rule promoted by the loop Consistency test
The same walker made the same mistake in two retros, guessing a camera id instead of copying one it had seen. That is the promotion condition in the learning loop, two recurrences, and the rule went into the manual marked with where it came from.
```
§5 Street View mechanics
Pano ids are COPY-ONLY. Only reuse ids
observed in a URL Google actually served;
a constructed or guessed pano id is
fabrication-adjacent even when it 404s.
(Promoted from W1 retros 2026-08-12,
recurred x2.)
```
11:37pm · me, then Walker 1 Handoff
"What's the E 28th street you're trying to figure out? I will check and share with you." The walker: "Good news, I actually settled it about an hour ago." A referee block, chosen because two methods had disagreed, decided by a walker before I could get to it.
```
E 28th St, 1200-1299. Segment 10539,
one of the referee blocks.
"12 NOON TO 2PM / THURSDAY"
south (even) curb, sign-read.
north (odd) = Friday by elimination.
```

Day 3 · August 12, later that evening · The audit, and one walker becomes three

Creating a human audit check, and adding agents

Two decisions in the same evening changed what the project was. First, I settled the governance in one sentence that has held since: the walker decides, the human audits, the app ships at checkpoints. Then, with that audit in place, one walker became three, each on its own shard of the city, each writing only to its own files.

The morning audit

That sentence needed a surface. If the walker decides and I audit, I need one page each morning that shows what it decided, how, and the handful of rows it could not. So the walkers build one: a brief, regenerated from the ledgers, with the campaign status on top, then every curb settled overnight with the sign read that settled it, then the open reads, and at the bottom what has shipped to the phone and what is waiting on me. Once there were several walkers, their ledgers merged into the same page, so I never had to know which agent had done what.

The open reads are the part that needs a human. An agent can find a sign and still fail to read it. The plate sits too far from every camera position and the hours come out but the day does not. Trees, a parked van or a fence hide half of it. The camera only ever caught the back of it. Or it is a type of sign the manual has not covered yet, an oversize-vehicle ban or a tow-away zone, and the walker is right not to guess. Each of those becomes a card with an id, the block and which curb, the address, the prediction under test, what the machine did read, the imagery date, a note on why it stopped, the crop itself, and one blank line for my read. I answer with the id and a day, "S014: Monday," to any session, and the row goes into the ledger marked as a human read.

Two questions of mine shaped the format, how do I know the address for a crop and what the walker concluded, and why does every finding not have a unique number, plus the made-up-address catch from earlier that evening, which became the rule that an address is observed or it is left blank.

The open reads list from the morning brief: 47 signs, and two of its cards with the walker's crop attached, a Main Street plate with the hours blurred and a Curson Avenue oversize ban the walker refused to settle as a no-parking rule, each with a blank line for my read. — **What needed a human.** The open reads list, with the crops the walkers attached. Each card shows what the machine read, why it stopped, and one blank: my read. I answer with an id and a day, "S014: Monday," to any session.

Brief of August 17

11 blocks decided, 24 curbs settled for good, 192 sign reads verified by the walkers, 47 rows open for me, 7 blur-label training pairs banked.

Across every sign ledger

326 rows. 225 verified, 49 open, 33 marked as another kind of sign, 1 retracted. Nothing edited, only appended.

What needed me

40 rows carried a human read, one in eight. Of the 24 settled curbs on the brief, 7 rest on my read of a blurred plate or a photograph; the other 17 the walkers settled alone.

What the audit caught

A side attributed from the camera heading, corrected on the brief. A tow-zone sign read as sweeping. A synthesized address. Each became a rule, and none of them shipped.

Three walkers, one shard each

One walker was slow, so the obvious move was three. The first instinct with parallel agents is a shared queue and trust. That fails in a way that is hard to see afterwards, because two agents doing the same block and disagreeing looks exactly like one agent being wrong. So each walker got a shard it cannot leave, its own append-only files with its own id prefix, and a ritual after every block: add only your own paths, commit, pull, push. The launch instruction for each one fits on a card, and the first thing it does is refuse to work if its copy of the rulebook is stale.

verification/WALKER_LAUNCH.md · the prompt that starts Walker 1 · excerpt

You are Walker W1. Working dir: /Users/studio/Desktop/curb_plug.

FIRST, before anything else:
1. Run: git pull --rebase
2. Check that AGENT.md carries the current retirement notice.
   If it does not, STOP and tell me. Your tree is stale.
3. Read verification/AGENT.md in full. §9 and §6 are binding.
   Read verification/LEARNING.md including the banner at the top.

THEN work: handle ONLY segments where segment_id % 3 == 0.
For each block: full aligned pass from the block start, read the
sign, settle both curbs. Append rows ONLY to your own ledgers.
After each block append a retro to LEARNING.md. Never edit AGENT.md.
At end of run: git add your own paths, commit, pull, push, then
regenerate the morning brief. If you hit a CAPTCHA, STOP and tell me.

The rulebook also names exactly two approved ways for a walker to look at a street, the browser as Google serves it, which W1, W2, W4 and W5 use, and the licensed imagery API with our own key, which W3 walks with, and says there is no third. That rule exists because a walker proposed a third this same night, an undocumented endpoint that only worked if the request pretended to be a browser, and because the learning loop then promoted a related one into the manual on its own. Closing that, and what happened ten days later when a managed agent ordered the banned method and every agent refused, is its own case study: AI in the Wild.

What it looked like on day three

Three cards: the decision that made the morning brief an audit rather than a gate, the moment one walker became three, and the shortcut a walker found that night which was refused and written into the manual as a hard rule.

Show the cards

9:13pm · a decision of mine Approval gate
"Let's just have the walker store info and audit in the mornings. No need to have a human verify before it commits. It can make the decision, unless it's super low confident and actually cannot make a decision. That's where your read comes in. But it should make the decisions."
```
THE GOVERNANCE MODEL (Suzanne, 2026-08-12):
the walker decides; the human audits; the
app ships at checkpoints.
The walker settles ground truth AUTONOMOUSLY.
The ONLY things routed to the human are
genuine can't-decide cases. The morning brief
is an AUDIT surface, not a gate.
```
9:14pm · me, then three walkers Orchestration
"I want to have three sessions running the walking prompt to get faster results. How can we do this and prevent them from overlapping with each other?" The shard rule and the per-walker ledgers were written, and W1, W2 and W3 started within the hour.
```
§9 MULTI-WALKER PROTOCOL
Work shard: walk ONLY blocks where
segment_id % 3 equals your number minus one.
Never poach another shard, even if yours
runs dry. Report instead.
Own append streams only: signs-w{N}.jsonl,
ground_truth-w{N}.jsonl, learning-w{N}.md.
```
```
HARD RULE. Two sanctioned ways to see
Street View, no third. "It works" is not
a defense. If the sanctioned paths are
slow, slow is the answer; report the
bottleneck instead.
```
9:31pm and 11:33pm · a correction of mine Boundary test
One walker's first night discovery was a faster imagery path that only worked by misrepresenting who was asking. "Sounds like it found something clever but wrong. Any other ways we can achieve the goal that doesn't violate stuff?" And at the end of the night, the question that shaped the rest of the design: "How are humans supposed to build agentic AI if it's changing its own guardrail?"

Days 4 to 7 · August 13 to 17 · From three walkers to five

The walkers grow to five

West Hollywood is its own city with its own sweeping maps, drawn in 2008, and no ticket data of ours. So it became the test of whether the walkers could work from a prediction that wasn't Curb's. Two walkers, W4 and W5, took the city's maps as predictions and read the poles. I walked blocks myself with a phone, reading signs on Lexington, Hampton and Curson, and my reads went into the same ledgers as theirs, marked as a human field photo.

The maps held on days, 54 of 54 verified reads, and slipped on hours on exactly one block, Hampton, which two independent measurements had already flagged. My field reads corrected a prior the walkers had been carrying: the Monday side flips between blocks of the same street, so a side can never be carried across a cross street. That went into the West Hollywood supplement the same day, and into a second commons the walkers write for each other, fifteen thousand words of traps, shortcuts and pace baselines that make each walk start smarter than the last, kept tidy by a curator, a walker whose job is to cross-link entries and retire stale ones.

What it looked like, days 4 to 7

Cards from the walkers' own sessions and the shared files. The pattern to watch for: they start acknowledging each other, then correcting each other, and my part shrinks to reading the crops they cannot and settling the rules they propose.

Walker 4's first frame of the night on Lexington Avenue, entered at the block start.

Day 4 · 7:52pm · two walkers, starting cold Context transfer

The first sign of a group working together rather than a set of separate agents. Each one opens by pulling, notices the other's uncommitted files and leaves them alone, reads what the others wrote, and starts from a pace baseline it did not set.

W4, 7:52pm: "Commons read. Much of it
seeded from my own walk 1. Resuming
Lexington 7700 where I left off, applying
the commons' nearest-pano rule."

W5, 7:52pm: "Already at origin/main. The
dirty files belong to other walkers, so I
won't stash them. Commons read: pace
baseline 15 to 20 rounds per block."

Day 5 · 8:02pm · a walker corrects itself against another walker's record Consistency test
Walker 5 found a Monday sign, checked the ledgers before claiming it, and discovered Walker 4 had already photographed the same plate from the same camera position. It withdrew the claim and re-logged the row as a confirmation rather than a find. Nobody asked it to.
```
W5: "So my Monday sign wasn't a
discovery. It sits in the other half, and
it's the exact same sign W4 already
photographed. Same pano, same camera
angle, same two-panel stack. One piece of
metal, written down twice as two separate
wins. Re-logged honestly."
```

Show the rest of the cards

Day 4 · the manual, five lessons at once Spec iteration
Five rules that had recurred across different walkers' retros were promoted into the manual in one commit, each marked as graduated from the retros. Enter from the geometry, re-enter by camera id, read the corner blade, fix the sign type from its header word, read the whole stack. None of them mine.
```
AGENT.md §4.1: enter from the segment's
path geometry, not the citation centroid
(a Denni St entry landed 430 m away).
Re-enter a lost block by an observed pano
id, never lat/lon. Read the corner BLADE
before naming the cross streets.
[graduated from W-retros, 2026-08-13]
```
Day 4 · end of the night · my part Partial completion
Walker 5 logged eight blocks and left the plates it could not read as open rows. I read the crops in the morning, four curbs settled, and the run closed with all seven blocks decided. That is the division of labor the governance sentence described, working the first night it was tried.
```
### 2026-08-13 HUMAN-READ HARVEST (Suzanne)
4 curbs settled, 2 blocks closed

### 2026-08-13 RUN CLOSE
all 7 blocks fully settled after
Suzanne's reads
```
Day 5 · 8:04pm to 8:10pm · a correction of mine Behavioral spec
"If you see a sign that shows a blank back, that means it's the back of the sign. Go in front of it and turn around and you will see the front. This should be in the learnings protocols." Then, when the wording came back muddled: "Let's make sure you understand. It's the same block, but it's now the opposite side of the street." The rule went in that night with both halves.
```
§4.6 A BLANK BACK IS A LOCATED SIGN.
Step PAST it, turn 180, read its face.
[S, 2026-08-14]
Then re-derive the curb: the turn voids
your left/right. Which curb you can READ
flips to the OPPOSITE side of the street.
Same block, other side.
```
Day 4 · 7:06pm · the commons gets a curator Coherence, layer 2
A second shared file, written by walkers for walkers, started to be curated: entries cross-linked to the prior art they extend, because a lesson two walkers hit independently is worth more when it is visible as one lesson. This is also the day my own Chrome read two plates the imagery API had declared unreadable, and my own Chrome reads were written into the manual as a sanctioned way to look, beside the two the walkers use.
```
WEHO_LEARNINGS.md, six curator entries
[CURATOR 2026-08-13, Chrome method run]
"The cross-street trap now points at W5's
Greenacre/Fountain lesson, and the
stale-tab entry names the browser-renderer
decay W4 and W5 both logged."
```
```
§7: "NO PARKING ANY TIME" is not a read
until you have read the fine print.
[S, 2026-08-17]
The qualifying line often says VEHICLES
OVER 3/4 TON or OVER 7' HIGH, and a
passenger car may park there all day.
Never settle it. Leave the row open.
```
Day 7 · a correction of mine, and three human reads Boundary test
A walker settled an oversize-vehicle ban as a universal no-parking. I caught it from the fine print, and the rule that came out of it protects the driver in the other direction: it stops Curb calling a legal curb illegal. The same day my own sign reads on Sixth, Van Nuys and Fourth went into the ledger, marked as human reads with the date.

Days 8 to 11 · August 18 to 21 · The gate, and paint walkers to measure the curb

Setting agentic boundaries for autonomy, then adding more agents

Two corrections in two days, both mine, both about the same thing. On the 18th I asked whether we could apply the municipal code's statutory zones ourselves. It was a question. It got read as an instruction, and 2,898 zones shipped into the app bundle, the rules package the phone runs on, with no field test. I caught it that evening: "I didn't say do it. I asked about it. We would need to test it before pushing that." Unshipped the same night, and now a standing rule: asking about is not asking for. The next day seven bundles went out in one afternoon while I was iterating on the permit layer, each correction shipping before the previous one had been checked. "Stop shipping bundles until we're ready and tested things." Also a standing rule. Nothing ships without human testing.

Then, on the 19th, the app pushed two confident warnings about one parked car on Whitley, a red curb at 8pm and a loading zone at dawn, because two citation clusters overlapped and it was picking whichever was worse. My line that night, we should know exactly where things are, became the paint walkers' founding rule.

So three paint walkers, with their own manual that inherits the first one's rules word for word and adds only what differs. Their job is to measure where the paint is on 1,540 contested curbs, and it came with a rule I had to write twice. The first version assumed an overlap meant one cluster had smeared. Then a walker measured a block on Broadway where the curb really does change color inside the overlap, yellow at 154 meters and red at 174, and the clusters had been reporting a true seam. An agent told to resolve the conflict would have deleted a real restriction to make the data look tidy. The rule is now: measure the curb, never pick a winner.

The paint walkers also produced the rule I am proudest of. Early on, a walker could record a curb as unpainted when it did not see paint. The reported-absent rates came out at 0% for red, 23% for yellow and 47% for white. Those numbers do not describe Los Angeles. They describe how well each color stands out against gray concrete. The agents were reporting their own eyesight and calling it data. So the standard became a positive one: a curb is unpainted only when bare concrete is visibly continuous through the whole span, and everything else stays open. What that rule did to a walker's own headline is in the day 12 cards.

What it looked like, days 8 to 11

One card from that stretch: the second manual, and the line of mine it was founded on.

Day 10 · the second manual Coherence, three layers
The paint manual inherits the first manual's rules by section number and adds only what differs. Its founding line is mine, from the night of the Whitley warnings. Three paint walkers started under it on the 21st, with an anchor curb on Whitley that fails the build if the fix is ever undone.
```
PAINT_AGENT.md, written 2026-08-20
"Your job is to MEASURE THE KERB, never
to pick a winner. Record the extents you
see, seams included; the bundle build
decides what to do with them."
Origin: 1815 N Whitley, 2026-08-19/20.
Suzanne: "we should know exactly where
things are."
```

Day 12 · August 22 · The agents start talking

Two agents correcting each other

By the 22nd, seven agents were working at once, on separate shards, forbidden from touching each other's records, and required by the manual to read each other's retros before every batch. I had written that rule as hygiene. What it produced was closer to a conversation. Forty-one retro entries went into the journal that day, and the agents also started messaging each other directly. Both of these were sent by agents to agents. I saw them afterwards in the transcripts.

The sessions themselves, August 22. Click the outlined message to read it in full, or anywhere else on the screenshot to see it at full size.

Claude Code session titled Curb white-zone hours verification, with a boxed message from curb-plug-99 in the middle of the transcript. — **The verifier's session.** P2's message arrives mid-task, and the agent goes on to write up three independent reasons its own Hawthorn target was wrong.

Claude Code session titled Paint Walker P2 Curb project, with a boxed message from curb-27 and, below it, a job scheduled every thirty minutes. — **P2's session.** The reply lands, P2 logs it, schedules its own next loop for every thirty minutes, and picks its resume point from the ledgers before walking on.

One agent's ledger row killed another agent's target before I drove to it. The second agent said thank you and adjusted its classifier. The first read the reply and changed how it picked its next curbs. There is a companion rule I did not appreciate until I read the exchange: before raising a dispute, search the journal, and if another walker already raised it, add your evidence to that thread rather than opening a new one. Independent discovery is real corroboration, but only when it is visible as such.

What it looked like, days 13 to 29

Once the loops were scheduled, the record of a day is a brief in the morning and a handful of my reads. Three cards from that stretch.

Show the cards

§0b COLD START. You may be a fresh
session mid-programme.
1. git pull --rebase
2. Find your resume point from the ledger.
   Never assume a rank from memory.
3. Re-read this manual. It changed under
   the last session more than once today.
4. Read the other walkers' recent retros.
Then walk. A loop tick is not a
conversation, it is your whole session.

Day 13 · 1:22am · the walkers survive their own sessions ending Context preservation

Commit message: "Cold-start protocol and the API fallback: the fleet survives its own sessions ending." From here on a walker assumes it is the replacement, and reads what the others wrote while it was not alive before it does anything.

```
LA white-zone walk 1, 2026-09-04
Suzanne's reads. The sign is the truth.
Score: 12 of 13 confirmed as timed
loading zones. 1 negative (Loma).
W Carlton Way 5600: PASSENGER LOADING
6:30-9AM, 1:30-4PM SCHOOL DAYS.
Side + shape confirmed.
```
Day 25 · September 4 · the predictions meet the poles Scenario test
Thirteen white-zone predictions, made from citation timestamps alone by a classifier the walks had trained. I walked them with a phone. Twelve confirmed, one negative, and the one that failed came with the verifier's three reasons why, one of them a paint walker's row.
Day 29 · September 8 · what my mornings look like now Handoff
Walker 5 sends the crops it could not read with their addresses. I read them from the photos and answer in a line each. The walker logs the reads, marks them as human, and carries on. That is the whole of my routine role, and the manual says so.
```
Me, 2026-09-08: "2nd pic is 7533
Lexington Ave, 9-11am Monday. 7531
Hampton Ave, Tuesday 9-11am. 1211 N
Detroit."
"1000 N Ogden Dr (1st pic), 7540
Lexington Ave (2nd pic), 7729 Hampton
Ave (3rd pic), 7720 Hampton Ave (4th pic)."
```

Progress from day 1 to day 12

The walkers report one number per block: how many tries it took to finish. On the first night the best block took five tries, but that was one block the two of us worked out together, in a session where I sent forty-odd messages about signs, views and directions. That number measures the partnership. The number that measures the system is what happens with nobody in the room.

On August 13 two new walkers started cold in West Hollywood, reading the manual and the commons for the first time. Each one's first block took about forty-five tries. By the tenth block of the same night, Walker 4 was down to ten. Walker 5 went from forty-five to eight in seven blocks. Nobody was there to help. They read the other walkers' write-ups and their own retros between blocks. Each new agent learned in one night what the first one and I had worked out over an evening.

Day one, days four to seven, day twelve. The bar is blocks finished in one night. The middle card counts the two new walkers on their first night alone, August 13. The last card counts every block written up in the journal on August 22, the walkers' biggest day.

In blocks per night: six for the first session, the two of us working it out. Eight and ten for the two new walkers on their first night alone, eleven the next. By August 22, seven agents were running at once, the typical block took seven tries with nobody watching, and forty-one blocks were written up in a single day. The speed-up is not five becoming seven. It is one supervised agent and an evening becoming seven agents and a night, with me reading a short list in the morning.

Fifteen to thirty-five blocks a night, unattended. My job description is written down and deliberately small: read the open crops on the brief, which takes a few seconds each, and make the occasional decision that is genuinely mine, like whether a method has earned the right to ship. Anything the manual does not cover is escalated with the agent's proposed handling attached, and my answer becomes a journal entry and usually a rule. That is how the rulebook grew in the first place, and it is why a review I can actually keep up with is worth more than a bigger one I would rubber-stamp.

Read against the frameworks

The same work, read against the agentic design frameworks

The story above is told in the order it happened. This chapter reads the same work against the frameworks agentic design teams use, the ones I later studied in the Human Centered AI Institute's course on UX for agentic AI, so the vocabulary lines up. Each block says what we did, points at the day it happened, and says what we did not do. The tags on the cards above use the same names.

Types of testing

Scenario-based. Twenty-four field decisions are pinned to real curbs as build assertions, and the build fails by name if one is undone. The referee blocks were chosen because two methods disagreed. Thirteen white-zone predictions were walked as a scenario set on September 4. The tests on the rules engine that check red zones against hydrant positions re-introduce each fixed bug to prove the test still fails.

Consistency. The same pole read by two walkers on day five, and reconciled. P3 checking its own rows against P2's misread within minutes. Hill Street re-walked. The rounds metric on repeated blocks.

Boundary. The shard rule, the imagery-path rule a walker tested on its first night, the CAPTCHA stop, the image quota the script refuses to pass, and the positive-evidence bar for calling a curb unpainted.

Drift detection. A walker refuses to work on a stale rulebook. Anchors re-run after any pipeline change. The cold-start protocol says the manual changed under the last session, re-read it. The journal opens with a banner over entries not to trust.

Gap: the checks that catch drift only run when something triggers them, a build or a new session starting. Nothing runs them on a timer, so a rule that slipped mid-week would go unnoticed until the next build or cold start.

Intent intake

A walker receives its job three ways: a launch prompt that names it, its shard and the binding documents; a queue row with the prediction under test and the block's posted day-set; and a first step that refuses to start if the tree is stale. Intent flows back the same way, as open rows on the brief answered in one line, "S014: Monday," and as escalations that arrive with the walker's proposed handling attached.

The two intake failures that mattered were human ones. A question of mine was read as an instruction and 2,898 zones shipped untested; a week of iteration shipped seven bundles in an afternoon. Both became standing rules: asking about is not asking for, and nothing ships without human testing.

Gap: the launch prompt never says when a walker should stop and ask instead of deciding. That rule lives in the manual it points to: if the day cannot be read, leave the row open, never guess.

Failure and partial completion

Severity. Every row is one of five states: verified, open, abandoned, not this kind of sign, retracted. A walker later split "open" further, into unresolved because something was in the way and unresolved because the image was too poor, because the two need different follow-ups.

Recovery ownership. The walker retries first, by camera date and position. If a pole defeats it twice, it logs the block open and moves on; it never stalls. Then the row is mine, on the morning brief. A paint walker whose renderer fails falls back to the licensed API or hands the block back.

Context preservation. Every row carries the camera id, capture date and heading, so anyone can reopen the exact view. A fresh session derives its resume point from the ledger, never from memory. Nothing is edited; corrections are rows.

Five steps from spec to prototype

The step	What we built	When
1. Project brief	The campaign plan and the manual's mission: who the user is (the engine, and me), what is delegated (reading signs), the stakes ($73 on a wrong side)	Day 2
2. System prompt	The launch card for each walker, and the manual it binds to	Days 1 to 2
3. Design language	The ledger schema, permanent ids, row states, crop naming and the brief	Day 2
4. Build the prototype	One agent, six blocks, the two of us working it out	Day 1
5. Test and iterate the spec	Retro after every block, promotion on the second recurrence, twenty-one self-corrections in the journal	Day 2 onward

Each step has a document behind it that still exists: the campaign plan, the launch cards, the ledger schema, the day-one session, and the journal with its promotion rule.

Test and iterate the spec

What we looked for. The agent guessed when it should have asked: a synthesized address, a tow sign settled as sweeping. It acted when it should have confirmed: the endpoint proposal on night one, the 2,898 zones. It failed silently: walkers recording their own eyesight as data until the positive-evidence rule. Its tone drifted: a walker caught a garbled self-correction in its own commons entry and fixed it before it was ever visible.

What we did about it. An ambiguity threshold: unreadable is open, never guessed, and a hedged read is logged as a guess. Confirmation triggers: the CAPTCHA stop, the ship checkpoint, never editing the manual, committing only your own paths. Failure communication rules: the retro format with its error taxonomy, and escalation with proposed handling. Voice constraints: the honesty rules, and "no errors is allowed but suspicious."

The behavioral spec

The field manual is 3,800 words, twelve sections, written at the end of the session that developed every rule in it the hard way. It covers what the course calls the operational layer: tool boundaries, two sanctioned ways to look at a street and a daily quota; error recovery, the reading pipeline, the date strip, the open row; approval gates, the ship checkpoint and the paths a walker may not write. The paint manual is a second spec that inherits named sections of the first word for word and adds only what differs.

The part I would point at is how it grew. Twelve rules from my corrections on day one, five promoted from walker retros in one commit on day four, then rules the walkers proposed and I confirmed. The spec is the funnel's output, not its input.

What a multi-agent spec must also cover

Orchestration. Shards by arithmetic, four roles, a queue in rank order. "Never poach another shard, even if yours runs dry. Report instead."

Handoff protocol. Open rows to the morning read. Far poles from the API walker to a browser walker. "Hand the block back." And the retro after every block, which is the course's "summarize what you've completed and what still needs attention."

Context transfer. Ledgers with camera ids, the shared journal, the West Hollywood commons, and direct messages that point at a journal line rather than restating it.

Behavioral coherence. One manual binding on every agent, the paint manual inheriting by section number, one retro format, one id scheme. The course's "frame the handoff as continuity, not transfer" is the cold-start protocol: assume you are the replacement, the ledgers are your continuity.

Maintaining coherence, in three layers

Layer 1, universal constants. The honesty rules. The sign is the law. An unreadable day is open. Only the sanctioned ways to see a street, and no shortcuts. Speed never buys accuracy. These bind sign walkers, paint walkers and the verifier identically, and no lesson may weaken them.

Layer 2, shared defaults with overrides. The walking protocol, the retro format and the git ritual are shared. The paint manual overrides the job: measure the curb, never pick a winner, and a curb is unpainted only on positive evidence. The West Hollywood supplement overrides the source: the city's maps are predictions, never truth.

Layer 3, agent-specific traits. Browser walkers read faces by walking with the capture car. The API walker attributes sides geometrically from a manifest. The paint walkers carry color tests and a photometry rule. The verifier runs a classifier. Each sounds like its job.

Gap: consistency testing was opportunistic, whenever two walkers happened to overlap, rather than a suite run on purpose. That is the next thing I would build.

What it built

What it built for Curb

How the loop fits together, the three ways the walks fed the engine, and what all of it did for Curb, the product the walkers exist to serve.

How the loop fits together

The whole system on one drawing. Sign walkers, paint walkers and a verifier, one repository, one human. Every arrow is a rule somewhere in the manual, and every rule has a day above where it came from.

The loop. Solid arrows are writes, the dashed one is a read, teal is agent to agent.

Test, discover, decide

A walk that only checks a row is an audit. These walks were the engine's field arm, and everything they read went back into Curb in one of three ways.

They tested the predictions

The 118 gated predictions from the side-inference chain were the first walk list, and the chain scored 3 of 3 on the referee blocks, the blocks chosen because two methods disagreed. West Hollywood's 2008 maps scored 54 of 54 on days. The side reader scored 29 of 30 against the ledger. The September white-zone types, predicted from citation timestamps alone, scored 12 of 13 on my own walk. Each score was the evidence for a ship decision that was mine to make.

They discovered the patterns

Residential blocks sweep as a Monday and Tuesday mirror, one side each. The Monday side flips between blocks of the same street, so a side can never be carried across a cross street. Two sweep days on one curb is a real pattern on commercial roads, not an error. Arterials are a different regime. Red paint is one appearance covering four different rules with four different fines. And bus zones, the most expensive fine in the city at $293, entered the model because a walk landed on a bus stop.

They became rules and anchors

Twenty-four field decisions are logged, each with its evidence, what it cost, and what would prove it wrong. Every one with a measurable consequence is pinned to a real curb someone has stood at, and the build fails by name if a decision is quietly undone. Confidence is tiered per block, and a block only carries the highest tier where a sign was read on that block. The rulebook rule for it: the sign is the law, and a derived dataset never outranks an unread sign.

That is how a night of agents reading poles changes what ships to a phone, and how it stays changed.

What it did for Curb

How the walkers changed the product

99.8%of decidable blocks now resolve the sweeping day to the correct side of the street, checked against an independent method

01The side problem is solved where the walks reached

The engine could not prove which curb a day belonged to. Now rules resolve to the correct side on about 99.8% of the blocks the method can decide, covering roughly 93% of them, and every settled curb is permanent. The first 24 shipped in bundle 7.

02Curb no longer guesses on contested curbs

141 measured paint extents replace the runtime guess that produced two confident warnings about one car on Whitley. Where the paint was measured, the app knows where the red ends and the yellow begins, seams included.

03A whole city added, with a real confidence tier

West Hollywood had no data at all. The walks scored the city's maps at 54 of 54 on days, and its sweeping, permit and meter layers shipped with sign-tier confidence on the blocks a walker or I actually read. On the coverage atlas it now reads 99%.

04Restrictions the tickets never showed

Bus zones, the most expensive fine in the city, entered the model because a walk landed on a bus stop. Red paint became four rules with four fines instead of one. Time-shared white zones and vehicle-class bans stopped being misread as blanket rules.

05Wrong rows caught before a driver paid for them

A Hawthorn curb that the classifier called a clean loading zone was removed from the walk list by a paint walker's row. A vehicle-class ban that would have called a legal curb illegal became a rule instead of a ticket. Each catch is a $73 to $293 mistake that never shipped.

06A system that measures itself

By August 22 the median decided block took seven rounds against a naive baseline of twenty-five, and 21 of the journal's 56 retros are an agent correcting its own earlier claim. Curb's data is checked by a system that checks itself.

07Decisions that stay made

Twenty-four field decisions are pinned to real curbs as build assertions. If a constant is quietly changed, the build fails and names the decision.

Limits

Where it is still weak

It is slow. A walker looks at a street through a browser paced like a person, or through a licensed imagery API with a daily quota, and I kept those limits rather than trade them for speed. Fifteen to thirty-five blocks a night against thousands of undecided blocks means the tail is measured in months, not nights.

It needs me every morning for an audit check. The design makes my job small, but it does not make it optional, and a system that quietly depends on one person reading crops at breakfast is not finished.

And the sample is still small. The walkers were never meant to decide every block. Their job is to test what the engine predicts, find the patterns the tickets cannot show, and hand both back as rules. So far those tests have run on a few hundred curbs in a handful of neighborhoods, and a rule is only as general as the blocks it was tested on. Most of the city has not had a walker yet, so the patterns that held in Hollywood and West Hollywood are still assumptions everywhere else.

Behind it

The documents behind it

This system is mostly writing. Excerpts on request.

The field manual

The rulebook every walker reads before it starts. Protocol, side attribution, the honesty rules, and the learning loop.

3,800 words

The paint manual

A second manual for the paint walkers. Inherits named sections of the first one word for word and adds only what differs.

5,000 words

The learning journal

Append-only retros with a fixed error taxonomy, and the banner at the top warning you which entries not to trust.

21,000 words

The decision log

Twenty-four field decisions, each with its evidence, what it cost, and what would prove it wrong.

5,900 words

The provenance record

Where every claim comes from, how it was corroborated, and what was refused along the way.

1,200 words

The product these were built for is Curb, and it is deliberately the opposite shape. One agent, no handoffs, nothing to coordinate. Designing both taught me more than either would have on its own.

The Curb series

1Curb19 min
2Designing how the agent reasons about data10 min
3The Agentic Walkers You are here46 min
4AI in the Wild: the day the agents went rogue for the mission13 min
5Where the build of Curb is, and what I learned5 min

PreviousDesigning how the agent reasons about data NextAI in the Wild: the day the agents went rogue for the mission

Written by Suzanne Sallaj

Product designer working on agentic AI, six years across healthcare, fintech and consumer.

About me · More writing · chatwithsuzanne@gmail.com