loop
engineering

the mechanic

one cycle, repeated

a real loop checks against a done-when, reads its own result, and knows when to quit. if the only verifier is the model grading its own output, you don't have a loop. you have a model complimenting itself with extra steps. the check needs to be external: a test suite, a linter, a human. strip that and it stops being a loop. it becomes a runaway.

why six weeks. hype used to die at the speed of deployment: falsifying big data meant buying a hadoop cluster and burning quarters before you learned it didn't help. falsifying loop engineering cost a weekend. the tooling was on every laptop, the model was an api call, a serious attempt cost tens of dollars. thousands of builders ran the same experiment in the same fortnight, hit the same walls, and the reports synced. testing cheap plus a claim crisp enough to kill compresses a decade into six weeks.

the corollary is the useful bit: rag never got a funeral because "retrieval helps" is too vague to falsify. the vaguer the claim, the longer the zombie walks. so read the renames as a map of what the industry keeps admitting it hadn't modelled, and never mistake a rename for a capability. nothing shipped in july that couldn't be built last year.

operating rule: chase the durable layer, let the vocabulary churn. the next rename is due before the invoice clears.

so here's the honest score. you shipped one of these in may and called it a fleet: four specialised nodes, own memory each, coordinated rather than chained. the fan-out half of the bundle has been doctrine for months. the half you're missing is the readable routing: coordination between the legs still lives in model judgment and your head. that's not a rebrand problem. that's a debugging problem, the day an edge fires wrong and nothing can tell you which one.

and the identity column pays twice: an inbox with persistent threads is a memory the agent already owns. recall before act. search your own history before composing. the memory dial moves without waiting for agentdb.

the easy version

the coding loop

↩ 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.

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.

this is ship one of shippers jarvis. it guards the money before it touches the code.

↩ 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.

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 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.

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.

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. run tracing has been promoted out of this paragraph and into the spine. see the durable layer above.

real shippers jarvis mode

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, with the routing drawn as edges and every pass on the record.

spec = load("build-plan.md")        # source of truth
while spec.open_tasks():
    task   = graph.route(spec)      # edges in code, not vibes
    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
    trace.record(task, cost, path)  # readable afterward
    if cost.exceeded(): handoff()    # cost cap