Kyle Jeong opens Devin Fusion-style orchestrator for sidekick coding agents

• Kyle Jeong made a Devin Fusion clone usable outside Devin: kylejeong's launch describes a lead model delegating bounded subtasks to sidekicks, and his repo post makes the WIP TypeScript code public.
• OpenClaw QA is already running as a swarm: steipete's prompt asked Codex to use 12 subagents, dev gateways, worktrees, autonomous PRs, and a live markdown test report.
• Claude Code is turning the pattern into product surface: ClaudeCodeLog's changelog lists an agent-launching tool, while the detailed release notes add workflow sizing and nested subagents up to depth 3.
• The routing debate moved from per-request model choice to task-boundary delegation: kunchenguid's critique argued task complexity appears during execution, and his FirstMate reply described routing by model, harness, reasoning level, and quota.
• Tool surfaces are getting squeezed too: kylejeong's Browserbase post says agents perform better when they can write code against guarded browser capabilities instead of walking long bespoke tool catalogs.

Kyle's Fusion repo is explicitly a TypeScript implementation of Cognition's Devin Fusion, not another bare agent loop. Browserbase's code-mode writeup says schemas alone can consume about 12,000 tokens with 40 always-loaded tools. Anthropic's Claude Code v2.1.219 release widened nested subagents to depth 3, while HumanLayer's software-factory essay put the counterweight in one phrase: harness engineering is not enough.

Fusion copies Cognition's two-lane shape: a smarter lead model owns the task and final answer, while cheaper sidekicks work in separate contexts and summarize back.

The Cognition post said Devin Fusion kept frontier and Fable 5-level performance at 35% lower cost on FrontierCode by combining a sidekick approach with dynamic mid-session routing. Kyle's implementation uses a shared TypeScript agent package, a TanStack Start web app, an OpenCode plugin, Vercel AI SDK plumbing, Browserbase browser/search tools, and Modal sandboxes, according to his stack note and the Fusion repository.

The useful bit is the explicit split of responsibility:

• Lead model: plan, ambiguity handling, final consolidation.
• Sidekick: bounded subtasks in a separate conversation history.
• Runtime: opt-in tools for files, shell, code execution, browser work, and computer use.
• Clients: web UI, importable npm package, and OpenCode plugin.

steipete ran Codex all day against OpenClaw and said the workflow used to fail at compaction boundaries or when the model started cheating. The prompt in his follow-up is the artifact worth saving:

1. Run full end-to-end QA with live API keys.
2. Use 12 subagents to split functionality.
3. Spin up dev gateways on different ports.
4. Stress test with some agents.
5. Orchestrate with worktrees.
6. Create PRs autonomously.
7. Find 200 bugs.
8. Fix root causes, not band-aids.
9. Avoid refactors that touch the plugin SDK boundary.
10. Keep a markdown test report on the desktop.

The screenshot attached to the QA run shows an 8-hour OpenClaw session with active bug-hunter subagents, 16 completed subagents, 75 bundled plugins tested, and 55 of 200 independently verified fixes.

His review boundary was blunt: one reply said he reviews the PRs that come out, not the subagents.

Claude Code 2.1.219 made the swarm pattern more first-party. The release added an agent-launching tool for complex multi-step tasks, a bash-output tool, and Opus 5 as the default Opus model, according to the official GitHub release.

The subagent-specific changes were small but concrete:

• workflowSizeGuideline can be set from any settings file.
• The default dynamic workflow size changed to medium, aiming for fewer than 15 agents.
• Nested subagents now spawn up to depth 3 by default.
• CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH=1 disables nesting.
• --forward-subagent-text can surface depth-2+ subagents in stream-json.

Ben Hylak also shipped "better sub-agent support" in a Friday update, and steipete's graph screenshot shows the same shape rendered as planner, worker, concurrent reviewers, synthesizer, pass/fail gate, and retry loop.

Paul Iusztin's Squid plugin turns the same instinct into a staged pipeline for Claude Code. In his build note, the system moved from one giant workflow into planning, implementation, and review.

The [Squid repo]Squid repository makes the stages scan cleanly:

1. Planning: grill a rough feature idea for missing requirements, weak assumptions, architectural gaps, and edge cases. Output a polished spec, ADRs, glossary, and task list.
2. Implementation: run a Software Engineer and Tester loop, where one writes code and the other tries to break it.
3. Review: review the PR diff, not the whole repository, then run CI, formatting, linting, integration tests, and regression checks.

Iusztin later isolated the highest-ROI planning step in his grilling note: fixing the plan with Fable is cheaper than fixing the code.

HumanLayer's software-factory essay is the cold shower alongside it. The essay argues review quality, incidents, and long-term codebase quality remain failure points even when implementation gets dramatically faster.

The live argument around routing is no longer just "which model answers this prompt." kunchenguid argued that request-level routing is flawed because task complexity reveals itself only after work begins.

His alternative looks like a tech-lead pattern:

• A smarter model plans and understands the task.
• It hands implementation to another agent with the right model and reasoning effort.
• It monitors execution and examines outputs.
• Routing happens between agents and subagents, not on every LLM request.

Vtrivedy10's routing note made the same point from an evals angle: routing should be calibrated to tasks, sub-tasks, and workflows using trace data, not opaque blended API choices. kunchenguid's FirstMate setup added a practical constraint, the orchestrator also accounts for which subscription quota has the most room.

Omar Sar described dynamic workflows as a generalization of harnesses, automations, loops, routing, and graphs in his orchestrator post. The implementation details are still thin: after that post, he said in a follow-up that he would share more if there was interest, while another reply said coordination reliability still needed work.

Browserbase is pushing the tool surface in the opposite direction: fewer bespoke tools, more code execution. The Browserbase post says the model should write ordinary code against typed capabilities, with sandboxing, credential handling, policy, and egress control below the model.

The concrete claim: about 88% less context, with one code execution replacing long sequences of tool calls. kylejeong's earlier post framed the failure mode as agents carrying useless tool descriptions in context.

The browser example matters because it is not theoretical. The KYB screenshot shows a Browserbase agent using page.evaluate to inspect page state and return structured data from the browser.

steipete hit 66 rounds with OpenClaw's autoreview skill on a refactor. The linked [autoreview skill]autoreview docs describes it as a closeout gate over a scoped change bundle, with Codex review by default and optional Claude or Pi review.

The review debate split along project specificity:

• Generic review skills are hard because projects need curated standards, mattpocockuk argued.
• His /code-review delegates mostly to coding standards and spec compliance, per his follow-up.
• Off-the-shelf review bots are not high-signal enough for every PR, 0xblacklight said.
• Local rule-driven review tools are appearing too: 0xblacklight's Saguaro link points to [Saguaro]Saguaro, a local AI review system built around markdown rules, file globs, import-graph context, hooks, MCP, and CI exit codes.

Uncle Bob Martin took the constraint route. unclebobmartin's thread said he does not read most agent-written code, and instead surrounds agents with unit tests, Gherkin tests, QA procedures, quality metrics, mutation testing, and coverage gates. In one reply, he said agents write the deterministic tools that check those constraints.

Voice, tmux, worktrees, and dashboards are converging on one job: command and control for many running agents.

The current surfaces are messy but visible:

• Codex Voice can start tasks, check progress, and steer multiple agents through speech, according to aibuilderclub_'s rollout post.
• jxnlco described voice as the orchestrator, not the implementer, in his Codex Voice thread.
• Herdr's agent automation docs expose layouts, panes, agents, prompts, waits, and lifecycle states, and herdrdev's Apache 2.0 post said the runtime is moving under Apache 2.0.
• tmux is the primitive under one Claude-to-Codex/Grok delegation skill, as aibuilderclub_'s tmux reply put it.
• Cursor Multitask has users spinning up 150-plus subagents in one chat, according to davidgomes's Cursor report.
• Kilo compared its VS Code Agent Manager with Orca in its worktree-orchestrator post, with both isolating agents through git worktrees.

The experiments are model-agnostic. aibuilderclub_'s Kimi K3 test described a run on a 68K-line FastAPI project with 307 endpoints, while OpenBench's launch listed codex, claude, cursor, devin, grok build, and pi harnesses measured across correctness, token use, and latency.

The weirdest parallel-agent example in the evidence pool was not an app refactor. imjaredz said Devin solved two more open math problems by parallelizing Fable and Sol sessions.

The reported workflow was swarm-shaped:

1. A master Devin searched for candidate problems.
2. It chose about 15 candidates.
3. It kicked off five child Devins per candidate with different prompts and angles.
4. It formalized results in Lean without sorry.
5. It used adversarial verification and further research for prior solutions.

imjaredz's proof details claimed one graph-theory conjecture was proven in four lines from two 1993 lemmas, and three balanced ternary design cases left open by a 2025 computational campaign were proven nonexistent.