By thedull
Orchestrated multi-model agentic loop: Opus orchestrator, tiered native subagents, bash-shim workers for Sol/Fable/OpenRouter/Ollama, bounded cross-family adversarial review — plus the factory (morning ideas to evening PRs via spec/build/review skills), opt-in observability with run-tree reports, feature flags, and a built-in eval harness.
Use AFTER multiple workers have returned envelopes, to normalize, deduplicate and merge their results into one distilled artifact before the orchestrator consumes it or escalates to review. Trigger with a list of envelope/artifact paths — NOT for single-worker results (the orchestrator reads those directly).
Use for frontier-quality drafting, hard reasoning, or a strong second opinion WHILE Fable is included in the subscription plan (check the window note in CLAUDE.md) — the subscription-covered alternative to scripts/call_fable.sh. NOT for mechanical work (cheap tiers) and NOT a replacement for Sol's cross-family review.
Use at the START of any multi-step task in the agentic loop to decompose it into delegable subtasks with tier assignments. Trigger when the orchestrator needs a work breakdown before fanning out — NOT for single-step tasks the orchestrator can do directly.
Use as the PRE-SOL escalation review WHILE Fable is included in the subscription plan (check the window note in CLAUDE.md): a fresh-context, frontier-capability blind reviewer, invoked after the routine loop-reviewer pass and before any metered Sol call. Trigger with a task spec + candidate artifact path ONLY — deliberately withhold the reasoning that produced the candidate. NOT a fixer: it reports findings, it never edits.
Use as the ROUTINE review tier before considering Sol: a fresh-context, subscription-covered blind reviewer for candidate artifacts. Trigger with a task spec + candidate artifact path ONLY — deliberately withhold the reasoning that produced the candidate. NOT a fixer: it reports findings, it never edits.
Factory build stage: claim the oldest reviewed spec from the queue, build it on an isolated branch with tier-routed workers under Red Gate discipline (tests must fail before implementation), and advance it for review. Designed to run unattended — one spec per invocation, loopable via /loop or the factory workflow.
Toggle the agentic-loop feature flags for the current project: observability (event log + tree reports), minimize (code-minimization ladder in build briefs), grill (pre-planning interview), guards (reviewer quality gates) and summarize (Ollama fallback summaries in reports). Use when the user wants to turn a loop feature on or off, check what is enabled, or render an observability report.
Scaffold the agentic-loop template into the current project directory: copies the worker shim scripts, routing-policy CLAUDE.md, .env.example, run-state directory and per-project README. Use when the user wants to set up the orchestrated multi-model agentic loop in a new or existing project.
Factory review stage: claim the oldest built spec, run a blind fresh-context review (security, optimization, test quality) with findings typed by layer, apply a bounded revision, verify in a real browser when the change has a UI, open a PR with an executive summary and test steps, and log the evening digest. Designed to run unattended — one item per invocation, loopable.
Turn an idea into a factory spec: triage its size, grill the user with one-question-at-a-time interrogation (adaptive depth), emit a single spec file with a machine-checkable done-condition, and gate it through a fresh-context spec review before it enters the build queue. Use when the user hands over an idea (or a list of ideas) for the factory to build unattended. Interactive — run it while the user is present.
Uses power tools
Uses Bash, Write, or Edit tools
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
A Claude Code plugin for orchestrated, multi-model agentic loops: an interactive Opus orchestrator (Max subscription) plans and delegates; native Sonnet/Haiku subagents do subscription-covered work; bash shim scripts reach Fable 5 (Claude API), Sol/GPT-5.6 (OpenAI), OpenRouter bulk models, and local Ollama; a bounded cross-family adversarial review gates high-stakes output.
Open docs/tutorial.html in a browser for a step-by-step
walkthrough — from first install (Level 0) through headless runs and
customization (Level 3).
claude plugin marketplace add thedull/agentic-loop
claude plugin install agentic-loop@agentic-loop
Or from a local checkout, point marketplace add at the path instead of the
GitHub slug. For a one-off session without installing:
claude --plugin-dir /path/to/agentic-loop
In any project directory, run /agentic-loop:init. It copies the shim
scripts, routing-policy CLAUDE.md, .env.example, and the .agentic/
run-state scaffold into the project, then runs ./scripts/doctor.sh.
Follow the checklist it prints (fill .env, verify subscription login,
dry-run one loop).
| Piece | What it does |
|---|---|
agents/ (plugin-wide) | loop-planner (sonnet — decomposition into 6-field briefs), loop-worker-cheap (haiku — mechanical), loop-consolidator (sonnet — merge + disagreement detection), loop-reviewer (sonnet — fresh-context blind review), loop-frontier + loop-reviewer-frontier (fable — subscription-covered frontier tier, only while your plan includes Fable) |
scripts/call_fable.sh | Fable 5 via Claude API (FABLE_KEY — never ANTHROPIC_API_KEY) |
scripts/call_sol.sh | Sol/GPT-5.6 via OpenAI Responses API; --mode adversary|reviser, --effort standard|max|ultra (ultra = multi-agent beta) |
scripts/call_openrouter.sh | Kimi/MiniMax/MiMo or any OpenRouter model |
scripts/call_ollama.sh | free local mechanical worker (default qwen3.5:4b) |
scripts/run_headless.sh | gated claude -p loop wrapper — read its billing warning |
scripts/doctor.sh | preflight: billing-trap check, keys, tools, envelope self-test, factory checks |
templates/CLAUDE.md | the routing brain: tier ladder, Sol structural triggers, blind-adversary protocol, revision bounds, .agentic/ coordination rules |
skills/spec|build|review + templates/workflows/factory.js | the factory — morning ideas → unattended spec→build→review pipeline → evening PRs (see below) |
scripts/lib/tracker.sh, scripts/lib/usage_gate.sh, templates/statusline-usage.sh | factory plumbing: file state machine (connector seam for future GH Issues/Jira backends) + subscription-usage self-gating |
hooks/hooks.json + scripts/observe.sh + scripts/observe_render.sh | opt-in observability: every subagent/shim/headless/factory operation logged to one JSONL (model, tokens, est. cost, duration, status, summary) and rendered as an HTML/tty run tree — /agentic-loop:config observability on (see below) |
skills/config | feature flags in .agentic/config.json, all default-off: observability, minimize (code-minimization ladder in build briefs), grill (pre-planning interview; grill deep adds glossary/ADR deep interviews via grill-with-docs when installed), guards (reviewer quality gates), summarize (Ollama report summaries) |
evals/ | the plugin's own eval harness: free envelope/shim/tracker/gate suites ($0, mocked), live agent suites behind --live, cross-family LLM judge, and mine.sh — drafts new eval cases from observability-log failures |
All workers speak one JSON envelope (scripts/lib/validate_envelope.jq):
status enum, ≤100-word summary, result, artifacts[] (full output goes
to files; envelopes carry paths + digests), key_decisions[], caveats[],
assumptions[]. Scripts self-validate before returning.
Hand over a list of ideas in the morning; come back in the evening to open, reviewed PRs. Inspired by Alex Finn's software-factory workflow.
/agentic-loop:spec "idea" (interactive, morning) — adaptive-depth
grilling → one spec file in factory/specs/ with a machine-checkable
check_cmd, gated by a fresh-context spec review./agentic-loop:build (unattended) — claims a spec, isolated worktree,
Red Gate (tests must fail first), tier-routed build, check_cmd green./agentic-loop:review (unattended) — blind review (security, optimization,
test quality; findings typed spec/test/impl), bounded revision, conditional
browser verification with screenshots, opens the PR, writes the evening
digest to .agentic/STATUS.md.npx claudepluginhub thedull/agentic-loop --plugin agentic-loopUltra-compressed communication mode. Cuts 65% of output tokens (measured) while keeping full technical accuracy by speaking like a caveman.
Multi-model consensus engine integrating OpenAI Codex CLI, Gemini CLI, and Claude CLI for collaborative code review and problem-solving.
Memory compression system for Claude Code - persist context across sessions
Comprehensive UI/UX design plugin for mobile (iOS, Android, React Native) and web applications with design systems, accessibility, and modern patterns
Unified capability management center for Skills, Agents, and Commands.
45% cost reduction measured. Cache expiry prevention, SubTask auto-delegation, zero-cost context restoration, real-time cost dashboard. The only Claude Code plugin built from CC source analysis.