From Autocomplete Plugins to Autonomous Multi-Agent Fleets
A raw LLM predicts tokens. A harness turns those predictions into a safe, stateful action loop.
① Context → ② Model → ③ Policy → ④ Tools → ⑤ Results
The harness owns every step except the model’s proposal.
Ghost Text Inline
In-Editor Chat & Diff
Stateful Tool Loops
Distributed Swarms
From Ghost Text to Full Workspace Context
July 2020: a plain-English prompt produced live React/JSX.
The human still copied, ran, and debugged.
Single file. No tools or compiler loop. The developer verifies every suggestion.
Cmd+K)
Cmd+L)
@file, @symbolClick-to-accept creates fatigue; long jobs monopolize the editor.
Extensions are awkward homes for daemons, containers, and raw system tools.
Hard to run in CI, SSH sessions, hooks, or cron jobs.
Chat history mixes instruction, chatter, and noisy execution logs.
CLI Agents & The Native Execution Loop
git, npm, pytest, docker{
"id": "call_987xyz",
"name": "edit",
"arguments": "{ path: 'src/auth.ts', … }"
}{
"tool_call_id": "call_987xyz",
"status": "success",
"content": "1 line changed"
}The model sees enough evidence and replies with text—not another tool call.
terminate: true)A tool or hook returns terminate: true.
Enter steers; Ctrl+C stops the loop.
A turn, time, cost, or context budget is reached.
bwrap / containersConcurrency, Isolation, and Task Trees
// Single Thread (Saturated):
[Prompt] → [Grep 8k tokens] → [Test Log 25k]
→ [Edit 1] → [Stacktrace 15k] → 💥 Bloat
// Subagent Architecture (Isolated):
[Main Thread: Clean Prompt & Final Diff]
├─ 🔍 [Researcher Child: 35k tokens]
│ └─ Returns: "Bug: auth.ts:42"
├─ 🛠️ [Worker Child: 20k tokens]
│ └─ Returns: "Fixed & 14 tests passing"
└─ [Main Thread Context: < 3k tokens Total]fork_context = true (Branching)Child inherits a complete clone of the parent's message history.
fork_context = false (Clean Slate)Child starts with a fresh system prompt and only the explicit task payload.
Beyond Linear Loops: OpenClaw, Hermes, and Gas Town
DEPENDS_ON, IMPLEMENTS).| System | Core pattern | State lives in |
|---|---|---|
| OpenClaw Peter Steinberger |
Scripted tool DAGs | Typed graph pipeline |
| Nous Hermes NousResearch |
Sessions as infrastructure | SQLite lineage tree |
| Gas Town Steve Yegge |
Git-backed swarm | Worktrees + DoltHub |
A persistent swarm manager for large codebases.
A Transparent, Minimalist Coding Harness
"If I don't need it, it won't be built." — Mario Zechner (
badlogic)
agentLoop()Async generator: yields events without waiting. Fast for headless work.
Agent ClassAwaits listeners in order. A message barrier ensures consistent state before tools run.
agent.steer(message)agent.followUp(message)Drain "one-at-a-time" for a response each turn, or "all" as one prompt batch.
Extensions are ordinary TypeScript modules over one typed API:
export default function myExtension(pi: ExtensionAPI) {
pi.registerTool({ name: "query_db", execute });
pi.registerCommand("lint", runLint);
pi.agent.beforeToolCall = async (call) =>
blocks(call) ? { block: true } : undefined;
pi.agent.afterToolCall = async (call, result) =>
augment(call, result);
}Walkthrough: Real-Time Auto-Linting in Pi
After every TypeScript edit or write:
eslint / tsc.afterToolCall?Linting needs the saved file. This hook augments the result before the model sees it.
Create extensions/auto-linter.ts in your project repository:
export default function autoLinter(pi: ExtensionAPI) {
pi.agent.afterToolCall = async ({ toolCall, result, isError }) => {
if (isError || !["edit", "write"].includes(toolCall.name)) return;
const path = toolCall.args?.path as string;
if (!path?.match(/\.tsx?$/)) return;
return runLinterOnPath(path, result);
};
}Spawn the local linter process and augment the result text:
export async function runLinterOnPath(path, result) {
try {
await execFile("npx", ["eslint", path]);
return result;
} catch (error) {
const output = error.stdout || error.stderr;
return { ...result,
content: `${result.content}\n\n⚠️ Lint:\n${output}` };
}
}"Don't prompt what you can verify with a tool, and don't verify by hand what your harness can hook into the loop."
Ghost text → chat → CLI loops → fleets.
Context → call → policy → tool → feedback.
Subagents keep noisy exploration out of the main thread.
Hook compilers and linters into every edit.
Prefer transparent, testable, typed kernels.
Next: Lab 02 — Building Custom Lifecycle Hooks for CLI Agents