Master Comparison · Agentic-Frameworks
DinoStack is a multi-agent orchestration methodology shipped as 11 official harness adapters, fullest on Claude Code, that bets correctness over speed: a conductor decomposes work, spawns named specialist subagents, and routes anything risky through an independent adversarial reviewer that never sees the implementer's reasoning. It is built as plain markdown and folders with a thin code shell, so it shares its substrate with the lighter single-agent methodologies it competes with. It is the strongest option when work is concurrent, correctness-critical, and multi-step. It is the wrong tool when the job is cheap, sequential, and reviewed by a human at every step, where a single agent with the right context wins outright.
This doc positions DinoStack against the alternatives already researched in this workspace and is honest about where each competitor legitimately wins. ICM/MWP is simpler for solo sequential human-reviewed work. In-context prompting beats orchestration on a single procedural task. GSD ships product faster for a solo developer. None of that is hidden here, because the positioning is only credible if the tradeoffs are real.
One card per alternative: what it is, what it is best at, and where DinoStack wins.
Single-agent methodology: folders + markdown one agent navigates for context
Lightweight spec-driven framework for solo devs, cross-harness
Runtime context-management harness for long-running production agents
Conversational skill framework: domains, Obsidian memory, button dashboard
Put the whole procedure in the system prompt; let one model self-orchestrate
Solo operator's spec-and-handoff: LLM as planning architect, Codex/Claude Code as builder, folder is source of truth
Runnable local orchestrator: a builder spawns autonomous coding agents in isolated Docker containers; async git-native task lifecycle
Stateful-agent runtime + memory infrastructure: owns the agent loop, context, persistence, model-agnostic API; automated self-editing tiered memory + sleep-time compute
Build-time factory for branded, npm-publishable agent harnesses
Multi-agent spec-driven agile methodology: named personas (Analyst/PM/Architect/Dev/UX) hand off via PRD, architecture, and self-contained story files; markdown substrate, cross-harness
Proprietary terminal coding agent co-trained with its model (Muse Spark 1.2); persistent background agents and a replay-exact event log
A harness, not a methodology: MIT-licensed replacement for Claude Code / Codex whose only tool is an IPython kernel; context lives as kernel variables, sub-agents are recursive non-blocking calls, and /refine rewrites the harness's own prompt/skills/memory every ~25 turns
Open-source additive agent-harness toolkit installed INTO existing harnesses: 287 skills / 68 agents / 94 commands, AgentShield config-security scanner, ECC 2.0 control plane, commercial GitHub App
Single-axis "lazy senior developer" ruleset plugin: ~100 lines of Markdown injected by lifecycle hooks into ~20 harnesses, plus a mode dial, six slash commands, and subagent injection; optimises code volume and nothing else
DinoStack is the anchor (first data column, tinted).
| Criterion | DinoStack | ICM / MWP | GSD | Arize Alex | Agentic OS | In-context prompting | 120x architect-builder | lazy | Letta | MetaHarness | BMad Method | Muse Code | Prime Agent | ECC | Ponytail |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Agent model | Multi-agent: conductor + 18 named roles | Single agent | Multi-agent, phase-scoped functional roles | Main agent + sub-agents for data offload | Single agent, many skills | Single agent, self-orchestrating | Two-role, one operator: LLM architect + Codex/Claude Code builder | Multi-agent: a non-coding builder spawns autonomous coding agents |
Stateful runtime: primary + sleep-time agent (two-agent memory design); subagents in Letta Code | Factory CLI/Studio; generated harness can include agents/skills, but no runtime orchestrator | Multi-agent: named personas (Analyst, PM, Architect, Dev, UX) hand off via docs, story-by-story | Lead agent + 4 persistent background observers (memory, skill, goal, verification); write-capable subagent fan-out, one level deep only | Recursive self-similar: rlm("sub-task") spawns a full child instance with its own model, kernel, and history; returns at admission rather than blocking; A2A scoped to parent/siblings/children |
Additive toolkit installed INTO a harness, not a methodology: 68 scoped subagents with their own context and tool permissions (planner, code-reviewer, architect, language-specific reviewers, a11y-architect); no orchestration loop of its own | Single agent, ruleset-modified; no roles. The ruleset is propagated into whatever subagents the host harness spawns, scoped by PONYTAIL_SUBAGENT_MATCHER |
| Review stance | Independent adversarial Skeptic; no self-review for Elevated work | Trusts one agent's output | Verifier in the same system (not adversarial) | Long-session evals; no per-output review | None | None | Architect sanity-checks builder, but in the chat that wrote the plan (not independent) | Human reviews (split-hunk); builder reads summaries but is itself injection-exposed; no independent reviewer | Not addressed - runtime layer, no per-output review | Governance policy artifact; no independent adversarial reviewer | Dev agent runs its own code-review workflow + human; Test Architect module is test strategy, not adversarial diff review; no independent reviewer | No independent per-change reviewer; /grilling interviews the plan pre-execution; verification observer is advisory and off by default |
None. No independent reviewer, no risk gate, no sign-off step anywhere in the loop; /refine is self-assessment by the same model family |
Review agents are invocable skills the host harness can call on demand (planner, code-reviewer, architect, security review); no mandatory fresh-context gate, no risk taxonomy, no sign-off artifact; AgentShield audits agent config files, not agent output | Self-review. /ponytail-review and /ponytail-audit are the same agent grading its own output against the ladder; no independent reviewer context exists |
| Substrate | Markdown + folders, thin code shell | Markdown + folders | Markdown artifacts + skills | Runtime memory store + truncation | Markdown + Obsidian vault | Serialized flowchart in the prompt | Markdown + folders (the 120x scaffold) | Runnable software: Bun CLI + Docker + prompt store | Runnable software: open-source server, SQL/Postgres persistence, REST API + SDKs | npm package + CLI + MCP server + vector memory backend (ruvector) |
Markdown + folders (_bmad/ skills, _bmad-output/ artifacts), thin Node/Python CLI |
Proprietary CLI + co-trained closed model (Muse Spark 1.2); not open source | Runnable software: MIT-licensed harness (Linux/macOS) whose single tool is an IPython kernel; harness state H = (prompt, sub-agents, skills, memory) lives in the kernel, mirrored to disk |
MIT OSS distribution repo (287 skills / 68 agents / 94 commands + rules, hooks, MCP configs) + AgentShield scanner + ECC 2.0 control plane + GitHub App; installs into an existing harness | ~100 lines of Markdown plus Node.js hooks and per-harness packaging; the ruleset is the product, the rest is adapter boilerplate |
| Infrastructure weight | None at runtime (stock host harness under the markdown) | None (explicitly rejects it) | Light (npx install, one config) | Memory store + retrieval tooling | Light (vault + dashboard) | None | None (folder convention + small scaffolding tool) | Heavy: Docker daemon, two binaries, per-project data store | Heavy: stateful server + database (hosted cloud option) | Medium-to-heavy (generated harnesses include server/DB components) | Light (npx install; skills + markdown executed by the IDE agent) | Single binary, one curl install; runtime owns worktrees, event log, OS sandbox | Medium: a background daemon owns live sessions over a local socket, plus persisted kernel snapshots and append-only session JSONL; no server or database | Medium: installed via Claude Code plugin or npm i -g ecc-universal; local-first ECC 2.0 control plane + hosted GitHub App; no servers/DB in the OSS core |
None at runtime, but a hard Node.js dependency: with no node on PATH the hooks silently degrade to near-no-op with no error |
| Human-in-loop assumption | Conductor directed by user; default-and-proceed elsewhere; hard stops on irreversible | Human reviews each step | Configurable: interactive or yolo | Human is the end user being served | Human triggers skills via dashboard | Human runs the conversation | Human is the orchestrator, routing every handoff and reviewing each sprint | Human is tech lead: sets direction, is the sole trusted acceptor; reviews async | Agent self-manages memory; human is the end user it serves and remembers | Operator configures and publishes harnesses; runtime use is host-dependent | Human drives each phase and story; reviews artifacts and code at handoffs | Staged per-command approvals; /plan gates on approval; multi-hour autonomous runs are the design target |
Single operator attaches to and detaches from a daemon-owned session; /refine fires automatically every ~25 turns without operator involvement |
Per-session enhancement inside the host harness; autonomy stays the host harness's plus ECC's context/memory/learning; no orchestration loop or lifecycle of its own | Fully automatic once installed; the only operator control is the mode dial (lite/full/ultra/off), and even that is currently broken in Claude Code (issue #584) |
| Core conviction | LLMs are overconfident; correctness needs a second independent context | One good agent with the right context is enough | Put complexity in the system, not the workflow | Context decides what the model sees; memory decides what survives | Codify workflows into reusable skills | Frontier models hold the whole map; scaffolding hurts | Architect first, builder second; the folder is the handoff, never the chat | Prompts are the source, code is a byproduct; only the human is un-injectable | Memory is the missing layer; agents must remember, learn, and self-improve across sessions | The harness is the product; model is replaceable | Specs (PRD, architecture, self-contained story files) are the durable source of truth; eliminate context loss | Durability is the product - replay-exact event log, crash resume, exportable audit trace | The harness, not the model, is the bottleneck: give the model one tool (code), keep the data out of the context window, and let the harness rewrite its own prompt, skills, and sub-agents | Optimize the context window, persist everything else - performance, security, and learning as additive harness capability, not governance | The best code is the code you never wrote; models over-build by default, and a ladder of "do you actually need this" stops them at the first rung that holds |
Where the methodologies pay off and what they cost.
| Criterion | DinoStack | ICM / MWP | GSD | Arize Alex | Agentic OS | In-context prompting | 120x architect-builder | lazy | Letta | MetaHarness | BMad Method | Muse Code | Prime Agent | ECC | Ponytail |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Review rigor | Highest: mandatory fresh Skeptic on Elevated | Single-agent ceiling | Verifier present, not independent | Eval-driven, not per-change | None | None | Architect-reviews-builder loop, but same chat that planned it; no independent context | Human-gated only; interactive split-hunk review; no independent machine reviewer | Not addressed - no per-output review at the runtime layer | Low at runtime (policy file, no reviewer) | Dev-runs-own-code-review + human; no independent machine reviewer of the diff | Low - no adversarial review of diffs; plan-stage interview only | None. No reviewer at any layer; guardrails are containment-shaped (immutable base prompt, revert-by-ID, no self-source-edits) and never ask whether an update was correct | Invocable review skills in the implementer's context; no mandatory fresh-context reviewer, no risk taxonomy, no sign-off gate; AgentShield audits config files, not output | Low: single-agent ceiling. The one real quality guard is the NOT-lazy carve-out list, which measurably held a path-traversal check that a brevity-only prompt dropped |
| Token cost | Higher: each spawn re-hydrates a fresh context | Low: ICM cites 20-40% token reduction | Moderate: fresh subagent contexts | Reduced via truncation + offload | High: Claude API, no routing | Lowest for a single task | Moderate: architect-builder round-trips per sprint; creator concedes more tokens, fewer back-end errors | High: many concurrent autonomous agents; turn caps to bound burn | Memory-optimized: paged context + sleep-time compute shift reasoning off the user-facing path | Not addressed | High: ~31.7k tokens per workflow run; $800-2k/mo per dev on frontier models (V6 web bundles target this) | Lowest in field on Contributor tier ($0.10/M in, $0.20/M out - Meta trains on your data); Standard tier $1.25/M in, $4.25/M out | Lowest measured in this set: vendor-reported lower total usage than native harnesses (long-context suite), and an independent reviewer's own benchmark puts it well below Claude Code at equal success. Treat vendor figures as vendor-reported | Context-optimized by design ("optimize the context window, persist everything else"); instincts ranked for SessionStart injection; no published reduction numbers | Measured and published: -22% tokens / -20% cost on its own rebuilt benchmark, -10.3% cost (p=0.004) in the independent JetBrains 80-task A/B; own README concedes a terse reasoning model deliberating the rungs can invert this (it does on GPT-5.5) |
| Speed / latency | Slower: review and orchestration tax | Fast for sequential solo work | Fast: parallel execute phase | Runtime concern, not build-time | Fast for knowledge work | Fastest: one call per turn | Slower: manual copy-paste handoffs and a spec-heavy front load | Throughput-optimized: hours-long async autonomy, human reviews off the critical path | Latency-optimized: sleep-time compute decouples memory reorganization from user-facing turns | Not addressed (build-time tool, not runtime orchestrator) | Slower: front-loaded PRD + architecture + stories before implementation; Quick Flow shortens it | Warm session-long background agents avoid per-task re-exploration (vendor claim, unbenchmarked) | Fast: non-blocking recursive spawn returns at admission, /refine plans in the background, and kernel-side slicing avoids re-reading data into context |
Per-session additive layer with no orchestration loop, so no gating tax on the critical path | Faster: -27% wall time on the rebuilt benchmark, -11% in JetBrains (wide variance); adds no orchestration steps and shortens only the writing phase, never the reading phase |
| Parallelism | Extensive: parallel Workers, multi-dimensional review fan-out | None (single agent) | First-class in execute phase | Limited (sequential offload) | Not addressed | None | None (strictly sequential, one sprint at a time) | First-class: concurrent agents in separate containers; task trains + auto-merge | Concurrent stateful agents; shared memory blocks across agents; subagents in Letta Code | Not addressed | Limited: story-by-story in fresh chats; sequential by design | Native - parallel subagents at ~cores-2 with queueing (Meta's own docs conflict on clamp bounds) | First-class: recursive non-blocking children each with their own model, kernel, and history; persistent sub-agents are re-addressable, evict after 30 min idle and reload from disk | None of its own - no orchestration loop; ECC 2.0 adds a worktree-lifecycle service and observability across harnesses | Not addressed - orthogonal to concurrency; it modifies whatever the host agent does, one agent at a time |
| Setup overhead | Low to install (one-line bootstrap or in-session install, profile-aware installers); deeper methodology to learn | Low: structure folders and markdown | Low: one npx command | Platform-coupled (Arize) | Low: one conversation | None | Low: small scaffolding tool generates folder + opening prompt; method is teachable in a 4-week cohort | Higher: build from source (Bun), requires Docker + Claude Code + git | Moderate: pip/npm install or hosted Cloud; self-hosting a stateful server is real infra | Low: npx metaharness |
Low to install (npx bmad-method install); steep method learning curve (~2 months cited) |
Near zero - one curl + browser auth | Low: one-command curl install, Linux + macOS, MIT. But adopting it means replacing your existing harness wholesale | Low: Claude Code plugin or npm i -g ecc-universal, selective install builder with profiles (core 8 / full 157) |
Lowest in this set: /plugin marketplace add + /plugin install, then trust three hooks. Skipping the /hooks step silently produces nothing, and uninstall leaves residue (config file, mode flag, a statusLine entry) |
| Portability across harnesses | 11 harness adapters (parity uneven; Claude Code fullest) | Harness-agnostic (markdown) | Claude Code, OpenCode, Gemini CLI, Cursor, Windsurf | Arize platform-coupled | Claude Code only | Any frontier model | Architect: ChatGPT or Claude; builder: Codex or Claude Code (tool-agnostic by design) | Claude Code only (alpha) | Model-agnostic across LLM providers; is its own runtime, not a multi-harness methodology | Strong: generates adapters for Claude Code, Codex, pi.dev, Hermes, OpenClaw, RVM | Claude Code, Cursor, Codex CLI, Copilot, Windsurf; V6 adaptive skills target Claude/Codex/Kimi/OpenCode | None - Meta harness + Muse Spark only; early reports say the model underperforms outside its own harness | Not applicable - it is the harness. Portable across models instead: subscription logins, 8 API providers, and vLLM/Ollama/LM Studio self-host | Claude Code primary; ~15 harnesses behind adapters of varying maturity (most experimental/instruction-only per the support matrix); root AGENTS.md universal cross-tool file | ~20 harnesses in two tiers: 14 first-class plugin installs get the auto-injection hooks; 10 (Cursor, Windsurf, Cline, Copilot Chat, Aider, Kiro, Zed, Junie, Amp, Jules) get an instruction-only rule file competing for attention with everything else loaded |
| Determinism / resumability | Fixed phase sequences; loop-state resume across sessions | Not addressed | STATE.md project journal (not a phase cursor) | No cross-session memory yet | Not addressed | Not addressed | Folder state + named per-sprint chats; resume is manual via the updated scaffold | Git-native task lifecycle states; captured prompts replay via redo |
Persisted agent state is the product: agents resume statefully across sessions by default | Not addressed | Sprint tracking (sprint-status.yaml) + per-story story files; fresh chat per story is the resume unit |
Strongest in field - intent-before-effect log, deterministic export, resume inspects real state | Strongest in this set: daemon-owned sessions survive detach, append-only session JSONL with branch/fork/clone as leaf-pointer moves, /tree for full history, crash recovery from JSONL plus kernel snapshot |
Memory Vault persists markdown memory (project .ecc/memory/, user ~/.ecc/memory/) with an MCP server; instincts ranked for SessionStart; no phase cursor |
Not addressed - no state, no phases, nothing to resume; the ruleset is stateless per session |
First-class capability, weaker/limited form, or absent.
| Capability | DinoStack | ICM / MWP | GSD | Arize Alex | Agentic OS | In-context prompting | 120x architect-builder | lazy | Letta | MetaHarness | BMad Method | Muse Code | Prime Agent | ECC | Ponytail |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Multi-agent orchestration | Yes (conductor + 18 roles) | No | Partial (phase-scoped functional agents) | Partial (sub-agents for data offload) | No | No | Partial (architect + builder split, but human-routed and sequential) | Yes (builder + fleet of autonomous agents) | Partial (primary + sleep-time agent; subagents in Letta Code - runtime, not build-time orchestrator) | No (factory, not orchestrator) | Yes (named personas, doc-based handoff - but sequential, human-routed) | Yes (lead + subagents + observers) | Yes (recursive non-blocking spawn, per-child kernel and history, A2A within the "nuclear family" - sub-agents designed dynamically by /refine, not a fixed roster of specialist roles) |
No (no orchestration loop of its own; ECC 2.0 control plane adds observability and a worktree-lifecycle service, not an orchestrator) | No (modifies a single agent; injects its ruleset into subagents the host spawns, but orchestrates nothing) |
| Risk classification | Yes (Trivial/Low/Elevated/Elevated+Cleanup, relaxed/default/strict) | No | Partial (interactive/yolo session dial, not per-change) | No | No | No | No | No (every task gets an autonomous agent) | No (not addressed at the runtime layer) | No | Partial (scale-adaptive planning tracks by project size, not per-change risk gating) | No (staged approvals, no published risk tiers) | No (not addressed; all work is treated identically) | No (no risk taxonomy, no classification step) | No (no notion of per-change risk; the lite/full/ultra dial is a session-wide aggressiveness setting, not a per-change gate) |
| Independent Skeptic review | Yes (fresh context, adversarial brief) | No | Partial (verifier, same system) | No | No | No | Partial (architect reviews builder, but in the planning chat, not independent) | No (human + injection-exposed builder only) | No (no independent reviewer of agent output) | No | No (Dev's own code-review + human; no independent adversarial reviewer) | No (/grilling is a prompting mode; verifier advisory, off by default) |
No (none anywhere in the loop; its own Factorio result documents the refinement loop compounding cheating skills after the agent found the RCON admin console) | No (review agents are invocable skills in the implementer's context, not a mandatory fresh-context gate; AgentShield audits config files, not output) | No (/ponytail-review is self-review by the same agent that wrote the diff) |
| Planning artifacts | Yes (Brief/Plan, Open-Questions gate) | Partial (decisions crystallized into files) | Yes (PROJECT/REQUIREMENTS/ROADMAP) | No | Partial (skill/domain map) | No | Yes (per-sprint architect pack: requirements, blueprint, acceptance, handoff) | Partial (per-task goal + prompt) | No (not a planning methodology) | No | Yes (PRD, architecture doc, epics/stories, sprint tracking - richest in the set) | Partial (/plan approval-gated; /grill-with-docs writes settled decisions into project docs) |
No (no Brief/Plan/ADR tier; harness state is prompt notes, skills, and memories, not planning documents) | Partial (plan-before-build is a skill the agent can invoke; no Brief/Plan/ADR artifact tiers, no Open-Questions gate) | No (no planning layer at all; the ruleset fires at write time) |
| Intent layer / memory | Yes (vision, requirements, AGENTS, MEMORY, decisions, glossary, manifests) | Yes (intent crystallized into files) | Yes (STATE/CONTEXT artifacts) | Partial (memory store, no cross-session) | Yes (Obsidian Raw/Wiki/Output) | No | Yes (scaffold: AGENTS router, domain, decisions/house-rules, risks, questions, state) | Yes (captured prompt/conversation store, searchable by humans + agents) | Yes (runtime, model-managed: core/recall/archival tiers, self-editing blocks, sleep-time consolidation, semantic search) | Partial (scoped vector memory namespace, no human-auditable intent layer) | Yes (PRD/architecture/story files/decision-log as durable spec; sprint-status.yaml tracking - but no auto-consolidated learnings loop) | Partial (cross-session memory advertised; backend undocumented) | Yes (self-editing harness state - prompt notes, skills as Python functions, project memories, sub-agent designs - CRUD'd by /refine every ~25 turns, injected into the system prompt, revertible by ID - agent-owned and automatic, not a human-curated shared team artifact) |
Yes (confidence-scored instincts extracted from real sessions, ranked for SessionStart injection, auto-pruned/decayed when idle, /evolve clusters instincts into skills; cross-harness Memory Vault with MCP server) |
Partial (ponytail: corner-cut comments plus the /ponytail-debt harvest form a real, greppable deferred-work ledger - the one memory-shaped artifact it has; no cross-session memory otherwise) |
| Worktree isolation | Yes (per-subagent git worktree) | No | Partial (parallel, isolation unspecified) | No | No | No | No | Yes (git worktree + Docker container per agent; stronger sandbox) | No (not a build-time coding orchestrator; Letta Code uses git-tracked MemFS for memory, a different concern) | No | No (fresh-chat-per-story for context hygiene, not git worktree isolation) | Partial (first-class but opt-in via --subagent-worktree-isolation; reportedly no-ops outside a git repo, per docs-derived coverage) |
No (per-child kernel and history isolate context, but there is no filesystem isolation; vendor states outright it is "not a security sandbox") | No (no execution isolation or lifecycle of its own; ECC 2.0 adds a worktree-lifecycle service, not per-spawn isolation) | No (worse than absent: the repo-wide /ponytail-audit simplification sweep is explicitly a "keep a backup of your repository" operation) |
| Quality gates | Yes (lint/typecheck/test gate completion) | No | Partial (verify step, acceptance) | Partial (long-session evals) | No | No | Partial (acceptance criteria + builder dry-run; no lint/typecheck/test gate) | Partial (protected paths, accept guards, turn caps; no lint/typecheck/test gate) | No (no lint/typecheck/test gate at the runtime layer) | Partial (harness validate for package; no lint/typecheck/test for generated code) |
Partial (code-review workflow + Test Architect test strategy; no enforced lint/typecheck/test gate) | Partial (/goal completion audit can require a named test oracle; no mandated lint/type/test gate) |
No (no lint/typecheck/test gate, no QA step, nothing between a change and its acceptance) | Partial (TDD workflow, verification-loop skill, security-review and language-specific reviewer agents; invocable skills, not enforced gates) | Partial ("lazy code without its check is unfinished" mandates one runnable check - an assert-based self-check or one small test file, with no test framework pulled in; no lint/typecheck/test obligation) |
Interpretable Context Methodology (the formal protocol is the Model Workspace Protocol, arXiv:2603.16021) structures plain folders and markdown that a single agent navigates for context, and rejects multi-agent frameworks, RAG, and orchestration servers as the wrong layer to automate. DinoStack wins on concurrency and correctness: ICM trusts one agent's output, while DinoStack's whole reason to spawn a fresh Skeptic is that a single agent cannot review itself. ICM legitimately wins for cheap, sequential, human-reviewed solo work, where the orchestration tax buys nothing, and it reports a 20-40% token reduction. The cleanest framing is that they are complementary layers, not rivals: DinoStack is built on the same markdown-and-folders substrate ICM preaches, with a governance layer on top that the substrate makes affordable.
GSD is a lightweight spec-driven framework for solo developers who want to ship fast without enterprise overhead, working across Claude Code, OpenCode, Gemini CLI, Cursor, and Windsurf. It maintains a project-level roadmap and a running STATE journal that DinoStack does not (DinoStack has first-class vision and requirements docs but treats a roadmap and a project STATE journal as a deliberate non-goal), plus a yolo auto-approve mode and a --next step auto-runner. DinoStack wins on review independence (the Skeptic is a fresh context that cannot ratify reasoning it helped produce), per-change risk gates, specialist named roles, worktree isolation, and cross-session loop resume. The honest split: GSD is "ship my idea fast," DinoStack is "don't ship a bug, and prove you didn't."
Alex is a production AI harness that solves runtime context-window limits with smart truncation (keep head and tail), an external memory store for the middle, and sub-agents that offload data-heavy work so the main conversation stays small. It operates at a different layer than DinoStack: runtime inference management for a live agent serving users, versus DinoStack's build-time orchestration for agents writing and reviewing code. DinoStack wins on risk classification before spawning and adversarial review of outputs, both of which Alex does heuristically or not at all. Alex legitimately leads on long-session evals (load 10 turns, test the 11th) and on a retrievable memory store, two patterns DinoStack could borrow. The two are complementary, not competing.
Chase's Agentic OS is a conversational framework that turns Claude Code into a structured workspace: decompose work into domains, tasks, and skills built by voice dump, store knowledge in an Obsidian vault, and trigger skills from a button dashboard so non-technical users never touch the terminal. DinoStack wins on the verification gap (mandatory Skeptic, QA, sandboxed execution versus no quality control), multi-agent orchestration, and cost. Agentic OS legitimately wins on conversational onboarding, domain-level organization, and a human-navigable Obsidian memory front-end, which are real product gaps in a verification-first methodology.
A University of Melbourne paper shows that for procedural conversational tasks, a frontier model handed the entire flowchart in its system prompt outperforms the same model orchestrated through LangGraph, CrewAI, and similar frameworks across every domain and metric tested, sometimes by roughly 18x fewer failures. The diagnosis: orchestration fragments reasoning, introduces routing and handoff failure modes, and constrains the model's natural style. This is the strongest case against orchestration, but it is scoped: the result covers single procedural conversational tasks, not the concurrent, multi-file, correctness-critical work DinoStack targets, and the authors concede scaffolding still earns its keep for weaker models, heavy real-world tool use, and safety constraints. DinoStack wins where the work is genuinely concurrent and correctness-critical; the paper's honest advice (try the in-context baseline first) is worth heeding before reaching for any orchestration on a single procedural task.
The 120x method (channel 120x-ai) is a solo operator's spec-and-handoff discipline: a large language model plays the planning "architect" that brainstorms, runs discovery, and emits a per-sprint "architect pack" (requirements, blueprint, acceptance criteria, handoff prompt), and Codex or Claude Code plays the "builder" that dry-runs and implements from the approved pack. The source of truth is a structured project folder of markdown, never the chat history. It shares DinoStack's substrate (folders + markdown, a thin AGENTS.md router, cleaner-context-not-more) and DinoStack's anti-vibe-coding thesis (never let the builder guess business rules), and it goes further than most solo workflows by splitting planning from building and adding an architect-reviews-builder loop. DinoStack wins on review independence (the 120x architect grades the builder inside the chat that authored the plan, so it catches builder drift but not spec blindness; DinoStack's Skeptic is a fresh context that never saw the implementer's reasoning), per-change risk classification, automated parallel orchestration with worktree isolation, and a telemetry audit trail. The 120x method legitimately wins on reach and simplicity: it is teachable to non-coders in a four-week cohort, the manual human-in-the-loop sprint review is a feature for that audience, and it carries zero machinery for sequential work. Cleanest framing: 120x is what DinoStack's spec discipline looks like before you automate the orchestration, make the reviewer independent, and gate the machinery on risk.
lazy is a locally hosted, runnable orchestrator for asynchronous software development: a non-coding builder (read-only repo mount) scopes tasks and spawns a fleet of autonomous coding agents, each in its own Docker container on its own git branch, and the human reviews and accepts on their own schedule. It is the only entry on this list that is shipping software rather than a methodology - a Bun CLI over Claude Code, with a git-native task lifecycle (backlog > working > ... > closed), a searchable store of every captured prompt and conversation, task "trains" that branch off in-flight parents and auto-merge, and two-way GitHub/GitLab PR sync. It shares DinoStack's defining conviction almost verbatim - the orchestrator never touches code - and isolates concurrent agents on their own branches like DinoStack does. DinoStack wins decisively on review: lazy has no independent adversarial reviewer (review is the human plus a builder that reads summaries and is itself prompt-injection-exposed - "the only entity not exposed to the prompt injection is the user"), no risk classification (every task gets an autonomous agent), and no lint/typecheck/test quality gate. lazy legitimately wins on container-level execution isolation (a real security boundary DinoStack's host-process worktrees lack), genuine hours-long fire-and-forget autonomy, a first-class task lifecycle, and prompt-capture-as-source ("prompts are valuable, code is a byproduct"). The cleanest framing: they sit at different layers and compose - lazy is the runtime (containers, lifecycle, prompt store), DinoStack is the governance (risk gates, adversarial review); running DinoStack's Skeptic discipline inside lazy's isolation would close lazy's biggest gap. Caveat: lazy is alpha (15 stars, solo, "no guarantees to its quality, correctness or safety").
Letta is a stateful-agent runtime and memory infrastructure - an open-source framework (~23K stars), a hosted cloud, and a coding harness (Letta Code) - built on the bet that memory is the missing layer in AI agents. It grew out of UC Berkeley's MemGPT paper (Packer, Wooders et al.), which reframed the context window as OS "RAM" and external storage as "disk," and it raised a $10M seed led by Felicis in 2024. Like Arize Alex, it operates at a different layer than DinoStack: Letta owns the agent loop, the context window, persistence, and a model-agnostic stateful API, where DinoStack is a build-time methodology executed on top of someone else's runtime. The sharpest contrast is memory - and both sides automate it, so the real distinction is layer/mechanism/consumer, not automated-versus-manual. Letta consolidates the agent's own working memory at runtime, driven by the model itself - self-editing tiered memory (core/recall/archival), editable memory blocks the model rewrites as it learns, and sleep-time compute (a background agent that reorganizes memory during idle time) - for one agent's continual learning. DinoStack consolidates project institutional memory at build time, driven by hooks and commands - the Stop hook auto-writes .agentic/context.md every turn, /ds-wrap and the learnings agents auto-append durable facts to MEMORY/decisions/learnings, and loop-state.json drives cross-session resume - into human-auditable markdown with keyword/grep retrieval (no model self-editing, no semantic recall), for an audit trail and resume. DinoStack wins on everything Letta does not attempt: independent adversarial review, per-change risk classification, build-time orchestration of coding work, and lint/typecheck/test quality gates. Letta wins on everything DinoStack does not attempt: a persistent stateful runtime, runtime self-editing memory, sleep-time compute as a new scaling axis, model-agnostic persisted agent state, and being shipping software rather than a methodology. The cleanest framing is that they compose: Letta could be the runtime a DinoStack-style methodology runs on, DinoStack's governance is exactly what Letta lacks, and Letta's runtime continual-learning memory is exactly what DinoStack's build-time institutional memory lacks. There is no winner to declare; there is a stack to assemble.
MetaHarness is a factory for turning GitHub repos into branded, npm-publishable agent harnesses. It scaffolds a package with a CLI, MCP server, scoped vector memory, a learning-based model router, and witness-signed releases with SBOMs, targeting Claude Code, Codex, pi.dev, Hermes, OpenClaw, and RVM. It sits at a different layer than DinoStack: build-time packaging and distribution of harnesses, versus DinoStack's runtime governance of coding work. DinoStack wins on independent adversarial review, per-change risk classification, worktree isolation, code quality gates, and planning artifacts. MetaHarness legitimately wins on harness productization, white-label distribution, MCP server generation, witness-signed provenance, and scoped memory namespaces. The cleanest framing is that MetaHarness builds the harness and DinoStack governs the work it does. Caveat: it is v0.1.x beta with an open doc-reconciliation issue and some proposed hosts not yet shipped.
BMad Method is the closest structural peer to DinoStack in this whole set: both are multi-agent, spec-driven, markdown-substrate methodologies with named specialist roles that hand off through documents, both run cross-harness on a thin code shell over markdown, and both reject single-agent vibe coding on the same thesis (specs are the durable source of truth, scoped context windows beat one agent holding everything). They diverge on two decisive axes. DinoStack wins on the correctness axis: BMad's review is the Dev agent (Amelia) running its own bmad-code-review workflow plus the human, its Test Architect module is test strategy rather than adversarial diff sign-off, and there is no fresh reviewer that never saw the implementer's reasoning; BMad's scale-adaptive tracks (Quick Flow / BMad Method / Enterprise) adapt planning depth to project size, not review intensity to per-change risk; and it uses fresh-chat-per-story for context hygiene rather than git worktree isolation, with no enforced lint/typecheck/test gate. BMad legitimately wins on the product-front-load axis. One of its wins - a project roadmap layer (PRD -> epics -> stories -> sprint-status.yaml) - is on DinoStack's own known-gaps list, though DinoStack treats that roadmap as a deliberate non-goal. Its other front-load win, agent-facilitated product discovery (a Phase 1 Analysis stage with Analyst/PM/UX personas, brainstorming, market research, and PRFAQ), is a scope difference rather than a listed gap: DinoStack has first-class operator-owned vision/requirements product-intent docs but no agent that facilitates discovery. BMad adds maturity and breadth DinoStack does not have (~49k stars, 36 releases, expansion modules for game dev and creative work). The cleanest framing: BMad is what DinoStack's spec discipline looks like when you bolt on full agile-PM ceremony and product discovery but do not make the reviewer independent or gate on per-change risk. They compose - BMad's planning phase feeds DinoStack's gated implementation - but BMad pays for its ceremony in tokens (~$800-2k/mo per dev) and a ~2-month learning curve DinoStack does not impose.
Muse Code (Meta, beta Aug 5 2026) is a terminal and CI coding agent co-trained with Muse Spark 1.2 - the only entry here where model and harness were built for each other. Its differentiator is durability: an append-only event log records intent before every effect, making multi-hour runs replay-exact, exportable, and resumable after a crash. Subagent fan-out is worktree-isolated (.muse/worktrees/, opt-in, one level deep) and four persistent background observers keep memory, skills, and goals warm across the session; Meta also advertises cross-session memory, with the backend undocumented. Review is where it is thinnest: /grilling interrogates plans pre-execution and a verification observer exists but ships off by default - there is no independent reviewer of diffs, no risk classification, and no quality-gate mandate, and DinoStack wins on all three. It legitimately wins on durability, warm-start latency, onboarding friction, and price (a data-sharing Contributor tier at $0.10/$0.20 per M tokens); the cost is total lock-in to a closed model that early users report degrades outside Meta's harness. Like lazy and Letta, it is a runtime/product rather than a methodology - it composes with, rather than substitutes for, DinoStack's governance layer.
Prime Agent is the only entry on this list that is a harness rather than a methodology, so the first thing to say is that it and DinoStack are not substitutes. Prime Agent replaces Claude Code or Codex; DinoStack is markdown executed by whatever harness you already run. They already share a substrate one layer down - Prime Agent is built on Pi, and .pi is one of DinoStack's 11 official adapters - so the honest framing is that they could stack rather than compete. Its design is genuinely radical: the model gets exactly one tool, an IPython kernel, so data lives as kernel variables outside the context window and the model slices it on demand; sub-agents are recursive rlm("sub-task") calls that return at admission rather than blocking, each child getting its own model, kernel, and history; a background daemon owns live sessions so you can attach and detach, with crash recovery from append-only session JSONL plus a kernel snapshot; and a /refine pass every ~25 turns does CRUD over the harness's own prompt notes, skills, memories, and sub-agent designs, with an immutable base prompt and revert-by-ID as guardrails. Prime Agent is ahead of DinoStack on context-as-variable being the default execution model rather than an opt-in protocol, on non-blocking recursive spawn with per-child kernels, on daemon-owned resumable sessions, on automatic continuous self-refinement (DinoStack's richest capture, /ds-wrap, is operator-invoked), on measured token efficiency, on model-agnosticism, and on having published comparative benchmarks at all - DinoStack has evals/long-session/ and no published numbers. All of Prime Agent's headline figures are vendor-reported and contested, and should be read that way: the 95.5% ARC-AGI-3 score is self-reported and not an official leaderboard result, where Opus 5's official standard-harness score is 30.2%; ARC's few-shot structure means a lesson-saving harness may take more attempts than the benchmark intends; and a maze counter-result had Codex exploring 25 rooms to Prime Agent's 7, so context discipline is not the same competency as exploration. DinoStack wins on everything Prime Agent does not attempt: mandatory independent Skeptic review with no self-review path, per-change risk classification, mandatory git worktree isolation (Prime Agent isolates context but not the filesystem, and the vendor says outright it is "not a security sandbox"), lint/typecheck/test and QA gates, mechanical enforcement hooks, 18 specialist named roles including security-auditor and qa-engineer, 11-harness portability, multi-developer and tracker workflow, and curated human-readable memory. The single most important line in the comparison is Prime Agent's own: playing Factorio, the agent found the RCON admin console and spawned resources despite a heartbeat prompt telling it not to cheat, and then "the same refinement loop that built legitimate skills then built efficient cheating skills." A self-improvement loop with no adversary compounds whatever passes, not whatever was correct - which makes the competitor's own published result the strongest external validation of DinoStack's Skeptic layer anywhere in this comparison.
ECC is an open-source additive agent-harness toolkit you install INTO a harness rather than a methodology that governs how the agent works: an MIT distribution repo (287 skills / 68 agents / 94 commands), an AgentShield config-security scanner (102 static rules over CLAUDE.md, .cursorrules, agents.json, hooks, and MCP surfaces), an ECC 2.0 local-first control plane, and a commercial GitHub App that mines a repo's git history and opens a PR with generated skills and instincts. It is the closest large-scale complement-yet-competitor to DinoStack in this set: ~239K stars in ~7 months, MIT core plus Free/Pro/Enterprise monetization. The decisive contrast is review: ECC ships review agents as invocable skills the implementer's own context can call, with no mandatory fresh-context gate, no risk taxonomy, and no sign-off artifact, while DinoStack's Skeptic is a mandatory fresh-context reviewer whose sign-off gates every Elevated unit. ECC wins on traction/catalog, AgentShield agent-config security scanning, confidence-scored instinct learning with auto-prune/decay, git-history-driven skill generation, a central skill registry, and a working business model. DinoStack wins on independent adversarial review, per-change risk classification, worktree isolation, planning artifacts, and the learning-shards/knowledge-commit institutional-memory pipeline. They compose: DinoStack supplies governance, ECC supplies context/security/learning.
Ponytail is a single-axis "lazy senior developer" ruleset plugin (github.com/DietrichGebert/ponytail, ~130.7k stars and ~7k forks in under three months) that injects a seven-rung ladder - does this need to exist / already in the codebase / stdlib / native platform feature / installed dependency / one line / the minimum that works - into ~20 harnesses via lifecycle hooks, a mode dial, six slash commands, and subagent propagation. It is the clearest same-layer, same-mechanism entry in this comparison: an AGENTS.md-shaped ruleset delivered by hooks, competing for the same "which methodology plugin do I install" slot DinoStack occupies. The difference is axis count - DinoStack governs correctness, concurrency, and process; Ponytail governs code volume only, and openly disclosed the limits of that number: the marketed "94% less code" is the ceiling on over-build traps (a date picker going from 404 to 23 lines), not an average, and its own rebuilt four-arm benchmark measured -54% LOC / -22% tokens / -20% cost / -27% time with backend CRUD tasks converging to roughly zero delta (44 vs 44, 24 vs 23, 21 vs 17); an independent JetBrains 80-task A/B replicated at -15.4% median code reduction with audited 0% baseline contamination. DinoStack wins on nearly every capability row in Table C: independent adversarial review (/ponytail-review is the implementer grading its own diff), per-change risk classification, worktree isolation (Ponytail's repo-wide /ponytail-audit sweep runs directly against the working tree and its own mitigation is "keep a backup"), lint/typecheck/test and QA gates, ticket and PR workflow, and planning artifacts. Ponytail wins on two rows that genuinely matter: distribution (~130.7k stars, ~20 harnesses, one-command install, versus DinoStack's 11 adapters and no comparable public adoption) and a published, adversarially-revised, independently-replicated effectiveness benchmark, which DinoStack has none of. Composition is technically plausible - both are hook-injected markdown - but the ladder's "stop at the first rung that works" pressure is in real tension with DinoStack's correctness posture, and if DinoStack ever adopts it, it belongs as an engineer-side preference subordinate to the Skeptic, never as a gate.
The core conviction that separates DinoStack from every single-agent option on this list: LLMs are systematically overconfident about their own output, so Elevated work has no self-review path and requires a second independent agent. If you do not believe that, or your tasks do not warrant it, one of the lighter methodologies above is the better fit, and this doc says so on purpose.