Master Comparison · Agentic-Frameworks
DinoStack is a multi-agent orchestration methodology for 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
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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 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 |
| 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 |
| 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 |
| Infrastructure weight | None at runtime (stock Claude Code 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) |
| 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 |
| 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 |
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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 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 |
| 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) |
| 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 |
| 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 |
| Setup overhead | Low to install (one-line bootstrap.sh + presets); 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) |
| 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 |
| 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 |
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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 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) |
| Risk classification | Yes (Trivial/Low/Elevated, 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
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.
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.