M Maple 灵枢
← 返回原始报告
2026-05 2026.05.13 14 KB

Vyane Agentic Team Frameworks Review (MER-358)

原始 research campaign 输出，来自 MER-358 agentic team frameworks。这页保留报告结构和运行痕迹，正式文章会在写作区重写。

Vyane Agentic Team Frameworks Review

Version: 0.1.0 Status: Draft Created: 2026-05-12 Updated: 2026-05-12 Created by: Codex App / GPT-5.5 Updated by: Codex App / GPT-5.5

Purpose

This note records the framework review behind MER-358, “Vyane: 多团队并行派发与阶段协作”.

Question: can existing agent frameworks already provide the Product/Planner, Architecture, Design/UX, Development, QA/Test, Review, Release/Operator, and Writer team system that Maple wants?

Short answer: no single framework covers Meridian/Vyane end to end. The best plan is to reuse mature pieces:

  • BMAD and MetaGPT for team roles, phases, and work artifacts.
  • Superpowers and Open SWE for coding execution, review loops, PR/Linear habits, and model assignment.
  • CrewAI, LangGraph, and DeerFlow for orchestration patterns, state, subagent isolation, long-running work, skills, and sandbox ideas.
  • Vyane remains the runtime that owns Linear state, model routing, execution logs, cross-repo coordination, review policy, and Argus/agentrun-board visibility.

Research date: 2026-05-12.

Source Notes

  • BMAD getting-started docs describe PM, UX Designer, Architect, Developer, code review, PRD, Architecture, epics/stories, sprint planning, and fresh-chat build cycles.
  • BMAD modules docs describe official add-on modules with specialized agents, workflows, and tasks beyond the built-in agile suite.
  • Superpowers subagent-driven-development describes implementer, spec reviewer, code quality reviewer, final code reviewer, worktree, TDD, and model selection guidance.
  • MetaGPT states that it models a software company with product managers, architects, project managers, engineers, SOPs, and outputs such as user stories, requirements, APIs, and docs.
  • CrewAI docs separate Flows and Crews: Flows manage state/control flow; Crews are teams of role-playing agents assigned tasks.
  • OpenHands docs show a productized coding-agent platform with CLI, local GUI, enterprise deployment, BYO LLM, source control, ticketing, Slack, sandbox, RBAC, and auditability.
  • Open SWE material describes an asynchronous coding agent with Manager, Planner, Programmer, Reviewer, GitHub/Linear/Slack triggers, PR handling, and LangGraph state management.
  • DeerFlow 2.0 describes a super-agent harness with filesystem, memory, skills, sandbox-aware execution, subagents, and context summarization.

Coverage Matrix

Framework Product / Planner Architecture Design / UX Development QA / Test Review Release / Operator Writer / Reporter Runtime / State
BMAD Strong Strong Medium-Strong Medium Medium Medium Weak Medium Weak
MetaGPT Strong Strong Weak-Medium Strong Medium Medium Weak Medium Medium
Superpowers Medium Medium Weak Strong Strong Strong Medium Weak Weak
Open SWE Medium Medium Weak Strong Medium Strong Strong Medium Strong
OpenHands Medium Medium Weak Strong Medium Medium Strong Medium Strong
CrewAI Configurable Configurable Configurable Configurable Configurable Configurable Medium Configurable Strong
LangGraph Configurable Configurable Configurable Configurable Configurable Configurable Medium Configurable Strong
DeerFlow Medium Medium Medium Medium-Strong Medium Medium Medium Strong Strong

Interpretation:

  • “Strong” means the framework has explicit first-class concepts, docs, and workflows for that role.
  • “Configurable” means the framework can express that role, but the role semantics are not provided as a ready software-development team.
  • “Weak” means we would need custom Vyane/Meridian behavior.

Framework Findings

BMAD

BMAD is the strongest source for a software-team workflow template. It already has PM, UX Designer, Architect, Developer, PRD, Architecture, epics/stories, sprint planning, story implementation, and code review.

What Vyane should borrow:

  • Team role taxonomy for MER-358.
  • Phase names: planning, solutioning, story creation, implementation, review, retrospective.
  • Work artifacts: PRD, Architecture, UX design, epics/stories, implementation readiness check.
  • Fresh-chat/session boundary discipline.

What BMAD does not solve for Vyane:

  • Runtime worker pool.
  • Linear/GitHub automation as source-of-truth.
  • Multi-repo task conflict detection.
  • Device-specific memory and conversation archives.
  • Argus/agentrun-board visibility.
  • Model routing across Codex, Claude, local/Chinese models, and future providers.

Recommendation: BMAD-lite as the role/workflow template for MER-358, not the execution engine.

MetaGPT

MetaGPT is the cleanest reference for “AI software company” vocabulary. Its stated philosophy is SOP applied to LLM teams, with product managers, architects, project managers, engineers, and a software-company process.

What Vyane should borrow:

  • SOP-as-team-process thinking.
  • Product Manager / Architect / Project Manager / Engineer / QA flow.
  • Intermediate artifacts handed between roles.
  • The idea that each role validates prior artifacts before producing the next artifact.

What MetaGPT does not solve for Vyane:

  • Current Meridian task source is Linear, not MetaGPT’s internal project model.
  • Vyane needs long-running daemon state, multiple devices, approval events, and mobile UI.
  • MetaGPT is more template/pipeline oriented than personal AI OS oriented.

Recommendation: use MetaGPT as conceptual reference for “software department” structure, especially team handoffs.

Superpowers

Superpowers is not a full team framework. It is a coding discipline pack. Its subagent development workflow is very relevant: implementer subagent, spec reviewer, code quality reviewer, final reviewer, TDD, worktrees, and model selection by task complexity.

What Vyane should borrow:

  • Implementer -> spec reviewer -> code quality reviewer -> final reviewer.
  • TDD and verification expectations for worker tasks.
  • Model assignment rule: fast model for mechanical tasks, stronger model for architecture/design/review.
  • Warning against parallel implementation agents when conflicts are likely.

What Superpowers does not solve for Vyane:

  • Product/UX/Release/Writer roles.
  • Linear issue selection and phase planning.
  • Multi-device execution logs and Argus dashboard.

Recommendation: use Superpowers as the default engineering discipline for Development, QA/Test, and Review teams.

Open SWE

Open SWE is very close to the async coding-agent product Vyane wants in one area: task intake from Linear/Slack/GitHub, planning, coding, review, PR, and comments. It is less of a broad product/UX/software-department framework and more of an internal coding-agent framework.

What Vyane should borrow:

  • Async task intake from Linear/GitHub/Slack-style sources.
  • Manager -> Planner -> Programmer -> Reviewer structure.
  • PR creation and review feedback handling.
  • Context hydration from issue/thread + repo rules.
  • Sandbox and state-management design ideas.

What Open SWE does not solve for Vyane:

  • Full Product/Design/Writer team model.
  • Personal cross-device memory and conversation archive.
  • Argus-specific approval, notification, and mobile visibility.

Recommendation: use Open SWE as the closest architecture reference for coding-agent operations.

OpenHands

OpenHands is a productized coding-agent platform. It is strong on execution environment, sandbox, CLI/GUI/cloud, enterprise deployment, source control, ticketing, Slack, RBAC, and auditability.

What Vyane should borrow:

  • Sandbox and execution-environment patterns.
  • Product surface ideas for local GUI / cloud / enterprise modes.
  • BYO LLM, source control, ticketing, and communication integration patterns.
  • Operator/Release concerns such as auditability, permissions, deployment, and data control.

What OpenHands does not solve for Vyane:

  • Maple-specific personal AI OS workflow.
  • Team role grammar for Product/UX/Writer.
  • Cross-device conversation archive and local memory policy.

Recommendation: architecture reference for Release/Operator and secure execution, not the primary team model.

CrewAI

CrewAI has strong generic multi-agent abstractions. Its key split is useful for Vyane: Flow manages state/control flow; Crew handles a delegated team task.

What Vyane should borrow:

  • “Flow controls state; Crew handles autonomous work” pattern.
  • State persistence and resume for long-running workflows.
  • Hierarchical/sequential/hybrid process options.
  • Human-in-the-loop and guardrails concepts.

What CrewAI does not solve for Vyane:

  • Ready-made software-development department roles tuned to Meridian.
  • Linear/GitHub/Argus/execution.jsonl as first-class facts.

Recommendation: use as orchestration design reference. Avoid replacing Vyane’s existing runtime with CrewAI wholesale.

LangGraph

LangGraph is a strong low-level graph/state runtime. It can express supervisor, handoff, swarm, pipelines, and persistent state, but it does not provide a full software department out of the box.

What Vyane should borrow:

  • Graph/DAG state model.
  • Supervisor and handoff patterns.
  • Explicit state, retry, checkpoint, and observability ideas.
  • Parallel branches with controlled joins.

What LangGraph does not solve for Vyane:

  • Role semantics.
  • Linear/GitHub/Argus product model.
  • Personal memory policy.

Recommendation: use LangGraph as a conceptual runtime reference for Vyane Scheduler/DAG, not as a required dependency now.

DeerFlow

DeerFlow 2.0 is interesting for long-running super-agent work: subagents, memory, skills, filesystem, sandbox-aware execution, and context summarization. It is broader than coding-only frameworks and has strong ideas for report generation and multi-step work.

What Vyane should borrow:

  • Isolated subagent context.
  • Skills as structured workflow modules.
  • Long-running context summarization and filesystem offloading.
  • Sandbox-aware execution.
  • Writer/Reporter inspiration, especially for research/report artifacts.

What DeerFlow does not solve for Vyane:

  • Software-development department role coverage is not as explicit as BMAD/MetaGPT.
  • Meridian-specific Linear + execution log + Argus state model still needs custom Vyane work.

Recommendation: study for long-running agent harness behavior and reporting, not as the main software-team template.

Recommended MER-358 Team Model

Vyane should define its own team vocabulary, with external frameworks mapped into each team:

Vyane Team Primary External References Responsibility
Product / Planner BMAD, MetaGPT, Open SWE Manager Phase goal, issue selection, acceptance criteria, priority, human decision points
Architecture BMAD Architect, MetaGPT Architect, LangGraph API contracts, data model, repo boundary, risk review
Design / UX BMAD UX Designer, DeerFlow report/prototype skills Argus, dashboard, agentrun-board, interaction design
Development Superpowers, Open SWE Programmer, OpenHands Scoped implementation, tests, commits, PRs
QA / Test Superpowers TDD, BMAD QA/Test Architect Regression tests, independent verification, CI evidence
Review Superpowers reviewers, Open SWE Reviewer Spec compliance, code quality, architecture/security review
Release / Operator OpenHands, Open SWE GitHub checks, PR merge readiness, deployment/runbook, Linear status
Writer / Reporter DeerFlow, BMAD Doc artifacts Chinese stage report, Maple-readable dashboard copy, handoff notes

MER-358 Implementation Shape

Initial version should be a dry-run planner, not a full autonomous swarm.

Inputs:

  • Linear issue list.
  • Repo status.
  • File ownership/conflict map.
  • Current phase goal.
  • Memory and project docs.

Outputs:

  • Team assignment plan.
  • Conflict matrix.
  • Task cards per team.
  • Suggested runtime/model per team.
  • Required tests and review gates.
  • Lines to append to logs/agents/events/execution.jsonl.
  • Optional summary for agentrun-board / Argus.

Initial commands could look like:

vyane teams plan --phase "Argus/Vyane usable MVP" --linear MER-347,MER-352,MER-356 --dry-run
vyane teams dispatch --plan .vyane/plans/phase-2026-05-12.json --max-dev-teams 3
vyane teams review --phase phase-2026-05-12

Product Judgment

The external frameworks are mature enough to prevent us from inventing team structure from scratch, but not mature enough to replace Vyane.

MER-358 should therefore treat them as references:

  • BMAD gives the strongest role and artifact vocabulary.
  • MetaGPT gives the cleanest “software company” mental model.
  • Superpowers gives engineering discipline.
  • Open SWE gives the closest async coding-agent operating model.
  • CrewAI/LangGraph give orchestration patterns.
  • DeerFlow gives long-running harness, skills, memory, sandbox, and reporting patterns.

Vyane’s unique value remains coordination across Maple’s real work: Linear, GitHub, multiple devices, model routing, execution logs, memory, Argus, and Meridian.

Sources