Coding agents + lbkit (logbook) + Herdr + chattaNot tested by us🇨🇳 CN

alswl's 1+N multi-agent practice: one captain agent dispatches the rest, rehearses the flow in a logbook, sets Delivery and Verify roles against each other, and deliberately breaks code to test the tests

On 2026-10-19 Chinese engineer alswl (@alswl) wrote up how he is moving "toward Stage 8": instead of watching each agent window, he hands a whole task to one coordinator (the Captain), which starts executor agents as needed. A logbook spells out goals, constraints and deliverables, and a Preflight rehearses the whole route before work starts; Delivery and Verify roles are set against each other; and after tests pass he deliberately breaks the tested feature to confirm the tests fail. His tools lbkit, chatta and skm are open source. He reports the captain's typical continuous run at about 30–50 minutes, up to nearly two hours. We haven't run the workflow yet.

Visit site Coding agents + lbkit (logbook) + Herdr + chatta ↗
Pricing
Free
Region
Global
Where it's from
Chinese community
Added
Oct 22, 2026
Version we used
Article dated 2026-10-19; alswl/lbkit main @ cd18eef (2026-10-22), chatta @ 3f5147a, skm @ b2dc838
Categories
CodingAutomation & Agents
Original author
alswl (Jingchao) @alswl ↗
Our test
Not tested by us
Cost / time
lbkit, chatta and skm are free and open source; the main cost is model subscriptions or tokens for several coding agents. He notes that passing context and communication both cost something, more agents don't automatically mean better results, and he's deliberately trading extra execution cost for his own attention.
Source
X @alswl(文章:AI Native 实践续篇:迈向 Stage 8) ↗X @alswl (English: Continuing AI Native Practice: Moving Toward Stage 8) ↗X @alswl(每月 1000+ PR) ↗X @alswl(AI 画不好增量架构图) ↗GitHub alswl/lbkit ↗GitHub alswl/chatta ↗

The task

Once you run many coding agents at once, constant confirmations and window switching start to eat your attention. The goal: let agents run longer and deliver more reliably, while concentrating human input on the checkpoints that need judgment.

Steps

  1. Front-load the key decisions: settle goals, boundaries and deliverables with one high-capability agent first. While the design is still open-ended, don't split it across many agents; multi-agent setups suit delivery work that already has a direction.
  2. Pick tasks by size: in the author's experience, work that would take half an hour or half a day the traditional way needs only one agent; only tasks around a week long that keep changing during execution justify this orchestration.
  3. Write a logbook (he uses his open-source lbkit): goals and non-goals, budget, where it runs, permissions, available context, required process and deliverables. The logbook constrains the plan but doesn't hold the design or code. Split work into stages with todos, artifact locations and verification evidence, and mark human checkpoints (merging, logging in) separately.
  4. Run a Preflight before starting: rehearse the whole route to surface needed resources, likely permission blocks and points needing human sign-off, and have a human skim it before setting off.
  5. Appoint a coordinator (the Captain) to organize, assign, resolve disagreements and summarize. For complex tasks, restrict it from implementing, sometimes even from reading code, to protect its context. Give it a more reliable model, persist its state to disk, and restart it if it gets lost. Don't predefine the team; it decides how many agents to start.
  6. Put Delivery (push to ship) and Verify (hunt for defects) on opposite sides. Agents talk through chatta, with a cap on rounds: they converge on their own, the captain steps in if they can't, then a human. Judge by evidence such as run output and screenshots, not by "we all agree".
  7. Test the tests: after development and testing, deliberately remove the target code of a tested feature and rerun the relevant tests; they should fail. If the feature is broken and tests still pass, check whether that test touches the behavior at all. (Similar in spirit to mutation testing, but one injected fault is not a full mutation-testing evaluation.) (He didn't publish a prompt for this; you can simply tell the agent: on a temporary branch, delete this feature's core code, rerun the related tests, and list which ones still pass.)
  8. Make agents explain their reasoning: options considered, which was chosen, why, and what evidence supports it. Log non-blocking questions and keep going, batching items for human review until there's a result to look at; a human still does the merge.
  9. End each complex session with a retro and write what was learned back into skills and docs. He uses Herdr to manage sessions, messages and attention, and skm to sync skills across agents.

What the author says

In the article he says that, as of mid-October, his personal observation is that the captain typically runs about 30–50 minutes continuously, up to nearly two hours, stressing that this is "not a statistical measurement or a capability promise" and that he still finds it tiring. In a 2026-10-12 post he said he's at roughly 1,000+ PRs a month (while calling that a poor metric); the article sets a personal challenge of "2,000 PRs a month, shipped to production", explicitly not yet achieved. As a live demo he had the captain turn the talk material into an intro video, noting that this only shows it produced something playable, not that quality was checked. His takeaway: adversarial roles may matter more than loops.

Our test

We have not run the 1+N multi-agent workflow; run times and PR counts are the author's own figures. We only tried installing lbkit (main @ cd18eef) on our test machine: uv sync --locked --no-dev failed because the Tsinghua PyPI mirror that uv.lock points to returned 403, and bin/lb reported missing dependencies, so we stopped there.

How to get in

The original is an X Article in Chinese (login required); the author also posted an English version (linked in sources). lbkit, chatta and skm are on GitHub with English READMEs. lbkit's uv.lock pins the Tsinghua (China) PyPI mirror, which refused our test machine with 403, so installs from outside China may fail until the lock points to a reachable index.

Who it suits

Engineers and tech leads already running several coding agents such as Claude Code or Codex and getting interrupted by constant confirmations; anyone trying to hand a team's dev process (requirements → design → sign-off → build → verify → ship) to agents. The test-the-tests trick works on its own for anyone using AI to write tests.

Pitfalls

  • Rules like "the captain doesn't implement or read code" live in skills and the logbook as soft constraints, and agents can forget them. His fix: a more reliable model for the captain, fewer details in its view, state persisted to disk, and a restart if it gets lost.
  • If agents keep stopping to ask a human, the task stalls. Front-load decisions, rehearse with a Preflight, and log non-blocking issues while continuing.
  • If every agent's only goal is to finish fast, they'll skip problems together. Assign a role whose job is finding defects, and make the delivering side show evidence.
  • Multi-agent setups cost context transfer and communication, so they're a loss on small tasks; cap the rounds of agent-to-agent discussion or it drags on forever.
  • Don't hand off architecture: he still draws architecture diagrams, makes architecture decisions and spot-checks code himself, and has said AI is bad at incremental architecture diagrams.
  • Community stories (such as someone's "2,000 PRs a month") often come from client-side or open-source projects and don't transfer directly to every business system; check that permissions, deployment and acceptance fit your own system.
  • On our test machine, installing lbkit's dependencies with uv sync --locked as documented failed: every package URL in uv.lock points to the Tsinghua PyPI mirror, which returned 403 from our machine. lbkit also requires the author's mind-forge CLI, and Herdr is a separate install, so setup takes some work.

More in this category