shippers ecosystem · field note 01
you stop prompting the agent by hand. you build the system that prompts it for you. the leverage moved off the keyboard and into the harness.
build it. ship it. move on.
the shift
write the right words for one turn.
control what the model sees each turn.
design the system that decides the turns and keeps it running.
each wraps the last. you already live in the outer ring. named june 2026 — osmani, cherny, steinberger.
the mechanic
a real loop checks against a done-when, reads its own result, and knows when to quit. strip the stop rule and it stops being a loop. it becomes a runaway.
anatomy
six parts. miss the last two and you have a token furnace nobody is watching.
/ done-when
a hard finish line it can test against. no target, no loop.
/ observe
it reads test output, the diff, the logs. fire-and-forget is not a loop.
/ triage
recoverable — bad import, retry. hard blocker — missing creds, hand off.
/ stop
max iterations, a cost cap, or done. the difference between a loop and a runaway.
/ state
it remembers what it already tried, so it does not circle the same wall.
/ heartbeat
it emits a pulse so you can see it is alive. if it can go quiet, it is not finished.
in your bag already
nemoclaw
write, test, fail, fix, green. does its one job, nothing more. kept for what it taught you. the logic-gap-harness is what replaced it.
write → test → fix → green · superseded
strydeoutreach
the four legs are each their own stack-complete agent now, own memory, gate and verify, coordinated rather than chained. more machine than pipeline.
researcher · closer · concierge · long-game
sentinel
watches the stream, matches the rule, fires the alert to telegram. bespoke, cache-bound, about to be rebuilt as the coordinator.
watch → match → alert · promoting
you had the loops running. you were just out of the loop on the word for them. orchestration over model selection was loop engineering before june gave it a name.
the easy version
↩ fail loops back to fix, not back to you
one-shot codegen cannot see its own failure. the loop can. that is the whole point. roots in react — reason, act, observe, repeat.
non-code version, same shape: pull from a few sources, summarise, flag what's off, format, ping telegram, check for replies, loop. six steps, zero re-prompting between them.
the floor
ralph is the dumbest loop that works. geoffrey huntley ran a coding agent in a plain while-loop against a written spec. pick one task, do it, loop. no orchestration, no subagents, no cleverness. that is the floor, and you cleared it months ago. nemoclaw, strydeoutreach and sentinel all sit above it. the question was never how to start a loop. it is how good the loop is.
while not done(): task = pick_next(spec) # one task per pass implement(task) if validate(): # read the result commit(task) else: fix() # recoverable if blocked() or passes > 10: # stop rule handoff()
caution / branch-safety
a loop running unsupervised on a live client repo is an agent guessing past a gate. branch off, cap iterations, keep it off trademind main.
caution / cost
every pass is a full model call plus context. cap iterations and cost. keep fable for the hard legs, drop to opus or sonnet for routine passes.
the real lever · benchmarking
performance = model × harness
the model is rented and fixed. you run the same weights as everyone else. the harness is the part you own, and on identical weights it swings the result up to 2x on its own. that swing is five dimensions. here is where yours actually sits. strydeoutreach is the high-water mark to measure against.
verdict: model-rich, orchestration-literate, verification gone live. the leak that's left is memory and a coordinator. that's the last stretch to a jarvis.
shippers · the fuel line
your build engine is loud. the billing and distribution behind it is quiet, and quiet on those dials is the failure mode. the highest-value shippers loop is not another build. it is the watchdog. extend sentinel into a 7am brief that patrols the fuel line while you sleep.
sentinel · 7am brief
this is ship one of shippers jarvis. it guards the money before it touches the code.
stryde · ava
ava's brain is a confidence-gate loop, and you wrote it last night. the trademind intake-classifier is the same shape: perceive the call, classify the job, gate on confidence, act or escalate, verify the read-back. dependency-injected the whole way, so it drops into spires without touching a line.
↩ below 0.7 it loops to clarify, then escalates to a human
the gap claude code flagged on the build is the same gap here. there is no stopping rule. when the clarify loop fails three times it has to bail to a person, not circle the drain. add the max-turns bailout and ava is loop-complete.
driiva · counsel + misc
driiva · counsel
counsel runs on cloudflare workers and supabase. legal cannot skip the gate, so the human sign-off is load-bearing, not optional.
ingest → extract → classify → draft → human gate
misc · the spine
obsidian-cli reads the vault, agentdb holds what you have already done, the loop surfaces the next dropped thread. this is the memory dimension you are thin on, made real.
read vault → recall → surface → act
proof · live on strydeos
while this note was still telling you to add a verify gate, you'd wired one. your end-stage gate caught the agent using "done" language with no verification command run, and refused the claim. that is the stopping rule, live. then you built the logic-gap-harness on top of it.
logic-gap-harness · adversarial review
first run surfaced two live liabilities on a clinical app and held 147 of 147 tests green. that is not the apex ahead of you. it is the apex behind you.
the twist · you're ahead of this note
this whole note has been teaching you to engineer the loop. you codified it months ago. agent-stack: eight layers, the enforcement triad, the per-pass loop and the pre-deploy double gate, a paste-ready harness, a canonical config with agentdb and agentmail wired, and a verify_stack.py that returns stack-complete or blocks the ship. it's on agensi. the five dimensions this note scores you on are a section in your own skill.
the note is late to its own subject. verify_stack blocks a hollow pass, the double gate refuses a bare "complete", and the harness question is closed.
what to build next · four buckets
the tier above the harness is the three things agent-stack scopes out: a coordinator over the fleet, memory that compounds, and an eval harness that picks your model with data. you build one of them, in software, not all three at once. the other buckets do not need new builds. they need you to ship, distribute and protect what is already there.
the shiny tier, reasoningbank memory and multi-node agentdb and fancy topologies, is the real technical frontier. you run a fleet now, so it is a parallel bet you dispatch alongside the paid work, not instead of it. the one rule that still holds: the fuel line stays watched while you build.
the frontier · a parallel bet
since you asked for the deep end: the one technical step past everything you run is compounding memory. right now your agents persist state, they don't learn from it. reasoningbank closes that. the agent records the outcome of every pass and pulls a strategy recommendation before the next one, so it stops repeating what failed and doubles down on what worked. two wire points in the loop you already have.
def perceive(): strategy = rb.recommend(task.type, task.context) # pull what worked before def after_verify(outcome): rb.record(task, strategy, outcome, context) # the agent compounds
the honest caveat here is technical, not a scarcity one: this pays off past 100 experiences per task type, so it compounds slowly. it is what eventually makes the jarvis builder build the way you would. dispatch it on top of a coordinator that already earns, in parallel with the paid work, not in the scraps left over.
the tier beyond it, when you get there: a sandboxed runner so the builder executes safely off your mac, real fleet orchestration, and run tracing so every agent's cost and path is on record. spine first. this after.
the north star is a loop that builds the app the way you would, minus the erroneous bits. a full-stack and devops operator that reads the spec, plans, builds one step, verifies it hard, then takes the next. the verify gate is what strips the errors. this is not a fantasy and it is not new architecture. it is agent-stack aimed at a whole build instead of one module.
spec = load("build-plan.md") # source of truth while spec.open_tasks(): task = spec.next() # one task per pass branch = checkout(task.id) # never main subagents.fan_out(task.parallel) # parallel where independent implement(task) if not verify(typecheck, tests, lint, e2e): reflect_retry(max=3) # recoverable if still_failing: handoff() # stopping rule continue commit(task); push(branch) # breadcrumb every pass if cost.exceeded(): handoff() # cost cap
one next action
the move is not the whole jarvis, and it is not the harness. you shipped that. it is the coordinator. rebuild sentinel as a stack-complete agent off agent.config.json: on a cron it runs the gap-harness, the identity reconciler and the fuel-line watch, dedups, sends red only to telegram. one build closes three holes. the coordinator dial goes live. the cache-lies stop. and the reconciler catches the drift sitting under your password bug.
build it. ship it. move on.
shippers · loop engineering field note · the production stack · leverage · shippers-tt · sources: kilo · lushbinary · cobusgreyling/loop-engineering