Core Advantages
1. Orchestration Flexibility: Code-as-Orchestrator
We pioneered the Code-as-Orchestrator pattern. The LLM dynamically generates a Python orchestration script based on the task and executes it in the PTC (Programmatic Tool Calling) secure sandbox. The LLM can freely usefor loops, if conditional branches, and concurrent thread pools, offering flexibility far beyond static DAG (Directed Acyclic Graph) workflows.
2. Fault Tolerance & Persistence: 4-Layer Durable Execution
When executing large tasks that take hours, traditional workflows crash if the network disconnects or the computer sleeps. MyRM Agent provides 4-layer persistence that competitors cannot match: (1)WorkflowEventStore — SQLite durable execution cache that replays completed sub-agent results instead of re-executing them; (2) SubagentCheckpointStorage — full execution state snapshots (messages, tool outputs, variables, progress) with file-level locking, enabling true breakpoint resume after force-stop or crash; (3) Chat DB progressSteps — every tool execution step persisted as message metadata for post-hoc review; (4) event_log/ — structured JSONL audit trail for compliance and debugging. Even if the network disconnects or the server restarts, the workflow can instantly recover from the breakpoint, automatically skipping completed sub-tasks and resuming interrupted sub-agents exactly where they left off.
3. Cost Control & Visibility: No More Hidden Bills
Dozens of sub-agents concurrently burning tokens in the background can easily generate “hidden bills.” We provide 5 layers of hard budget constraints (Token/USD/Time/Descendants/Concurrency), and offer a Subagent Dashboard real-time topology tree and Live Token odometer on the frontend. You can clearly see the progress, time spent, and cost of every concurrent sub-task. An event-driven Staleness Probe automatically detects when a sub-agent stops making progress — a red alert appears in the Dashboard, IM notification is pushed, and the desktop notification fires, all with zero overhead (piggybacks on existing token usage events, with a 4x tolerance multiplier during active tool calls to avoid false positives on slow but working tools). Every sub-agent streams Real-time Proof of Work through four parallel channels:SUBAGENT_LOG (live tool execution stream), FILE_DIFF (full diff content with one-click revert), SUBAGENT_PROGRESS (token/cost/ETA counters), and ARTIFACT_CONTENT (generated artifacts pushed instantly) — so you always know exactly what each sub-agent is doing, what it changed, and how much it costs, as it happens. The Dashboard also features Advanced Visualization: a Header Summary showing total agents, active count, failures, cumulative cost, and model distribution at a glance; Sort & Filter controls (sort by spawn order, cost, duration, or status; filter to running, failed, or leaf nodes); Subtree Aggregate Badges on every branch node showing descendant count, accumulated cost, and token usage; and a collapsible Mini Gantt Timeline rendering each sub-agent’s execution span as a color-coded CSS bar — all GUI-native with zero backend changes and zero prompt token impact.
4. Heterogeneous Model Ensemble: Intelligent Routing
Within the same workflow, the system automatically dispatches simple “data collection” sub-tasks to cheap and extremely fast models (like DeepSeek V3), while assigning core “logical summarization” tasks to the strongest reasoning models (like Opus/GPT-4o). While ensuring output quality, it helps you reduce running costs by 10x to 60x.5. Closed-Loop Verification: Physical Sandbox Evidence
When a sub-agent says “code modification complete,” the system forces a “read-only verifier” to be spawned, truly runningnpm test or compilation commands in the sandbox. Only when real physical execution success evidence is obtained is the task considered truly complete. We reject LLM hallucinations and deliver absolutely reliable results.
6. Background Task Auto-Wake: “Done? Report Back!”
When you dispatch a long-running background sub-agent (e.g., a full-repo refactoring task), the main Agent doesn’t just sit idle — it automatically wakes up and continues when the background task completes. The AsyncWakeupHandler protocol bridges the Harness framework and the Server layer: upon sub-agent completion, the result is injected into chat history, and a headless Agent run is automatically triggered with 3 retries, exponential backoff, and daily budget protection. Combined with the Kanban Dispatcher (heartbeat monitoring, zombie detection, scheduled wakeup) and 6 idle maintenance tasks (memory consolidation, cognitive derivation, context compaction, etc.), MyRM Agent achieves true “fire-and-forget” autonomous operation. If the server restarts, OfflineDurableTask automatically resumes interrupted tasks from the database checkpoint. When a background task finishes while you’re away, the Offline Guardian precisely distinguishes success from failure — dual-insurance detection (SSE error chunk matching + semantic error flag) ensures you see “Task Completed” or “Task Failed” with a click-to-chat link, never a misleading generic notification.7. Optional Path Guard: Graceful Degradation for Non-Critical Steps
In complex DAG plans, not every step is equally important. MyRM Agent supportsallow_failure declarative fault tolerance at the individual step level — mark any step as non-critical, and if it fails (even after 3 automatic retries), it gracefully degrades to skipped status instead of failed. Downstream steps that depend on it continue executing normally, and the overall task can still succeed.
Real-world example: In a multi-source research task, one search engine API is rate-limited and fails. Instead of aborting the entire research, MyRM skips that source, continues with the remaining sources, and delivers a complete report. Competing frameworks would abort the entire DAG on any single step failure.
This capability is unique to MyRM — no competing framework (Claude Code, CrewAI, Dify, OpenHands, Hermes) supports DAG node-level allow_failure declarations. The result: 30%+ higher task success rates in multi-step workflows compared to all-or-nothing competitors.
8. One-Click Workflow Toggle: Smarter Than Ultra Mode
OpenAI’s GPT-5.6 Sol introduced “Ultra Mode” — a one-click toggle that runs 4 agents in parallel, trading higher token costs for faster results. MyRM’s WorkflowModeToggle provides equivalent one-click activation, but with significant advantages:
The toggle automatically resets after sending to prevent accidental high-cost follow-up messages — a safety mechanism OpenAI Ultra lacks.
9. Plan Confirmation: Review Before You Spend
Before executing a Dynamic Workflow that spawns multiple sub-agents, the system pauses and presents the execution plan for your review. You see exactly how many sub-agents will be spawned, what each one will do, and the estimated cost — then choose Confirm, Edit, or Skip. This is powered by thePhaseWaiter suspend/resume gate: the server emits an SSE phase=plan_confirm event with the full plan preview (sub-agent count, task descriptions, batch cost estimate), then suspends execution until you respond via the /agents/plan-confirm-response endpoint. No tokens are burned on sub-agent execution until you explicitly approve.
Why this matters: Competing workflow systems (Claude Code, CrewAI, Dify) execute immediately — by the time you realize the plan is wrong, dozens of sub-agents have already consumed tokens. MyRM’s plan confirmation is the difference between “I approved this 50?”
Combined with the WorkflowRunGuard (max 50 spawns, concurrency semaphore of 5), plan confirmation forms a two-layer safety net: structural limits prevent runaway execution, and human review prevents misguided execution.
10. Planning Guardrails: Focused Execution, Not Runaway Planning
When LLMs plan multi-step tasks, two failure modes are common: over-planning (generating 50+ trivial plan items, wasting tokens) and multi-focus drift (marking 3-5 tasks as “in progress” simultaneously, completing none). MyRM’stodo_write tool enforces hard guardrails at the code level:
- MAX_TODOS = 20: Prevents planning explosion. When exceeded, a clear error guides the LLM to merge or simplify.
- Single in_progress enforcement: Only one task may be actively worked on at a time. If the LLM violates this, the system intelligently corrects (reverts older in_progress items to pending, keeps the latest) and provides a feedback note explaining the correction.
- Correction over rejection: Unlike hard rejections that disrupt flow, intelligent correction keeps the workflow moving while teaching the LLM to self-correct in subsequent turns.
11. Single Agent Gatekeeping: Simple by Default, Powerful on Demand
MyRM defaults to a focused single-agent experience —suggestWorkflowMode is off by default. The system silently handles most tasks with one agent, delivering fast, predictable responses with zero orchestration overhead. Users never see workflow suggestions unless they explicitly opt in.
For power users who want proactive multi-agent suggestions, a single toggle in Settings → Preferences → Advanced enables the detection engine:
- Zero LLM cost: Detection uses pure regex-based scoring on the query structure (numbered lists, parallel keywords, multi-goal markers).
- Non-blocking: The suggestion appears as an inline card in the chat stream; the current response is never interrupted.
- User control: Accept (enables workflow for next message), dismiss (hides card), or turn the toggle back off.
- Conservative by design: Only triggers when the ComplexityRouter classifies the task as
reasoningtier AND the decomposability score meets a strict threshold (≥4/7). - Backward compatible: Existing users who previously had
suggestWorkflowMode: truesaved in their settings keep their preference — no silent behavior change on upgrade.
12. Why we skip a drag-and-drop workflow canvas — and what you get instead
The GUI AI-assistant category (OpenClaw, Hermes, LobsterAI, CoPaw, JiuwenClaw) does not ship workflow visual editors — this is not a MyRM gap. Low-code platforms like Deer-Flow have visual orchestration, but they target a different product class. MyRM uses Code-as-Orchestrator so Python plans keep full expressiveness (for/if/thread pools). A static node-link DAG editor would cut that advantage. What you actually need:- Runtime topology:
AgentWorkMap(ReactFlow + dagre) — see the live sub-agent tree, not a stale template diagram - Plan confirmation HITL: review the LLM-generated orchestration plan before spending tokens
- Template library Export/Import: share orchestration scripts across the team without a drawing board
- Natural-language edits: change requirements in one sentence — faster than dragging nodes
13. Cross-Session & Cross-Fork Semantic Replay: Identity-Hash Journal Resume
In complex multi-agent workflows, users frequently fork sessions or tweak earlier prompts in the WebUI to explore alternative solutions. In traditional architectures, changing the session ID invalidates all historical sub-task results, forcing expensive research tasks (such as full-repo semantic scanning) to re-run from scratch, wasting tokens and time. MyRM introduces persistent execution resumption backed byidentity_hash semantic indexing:
- Instant Readonly Replay (0 Token Waste): For all sub-tasks declared as
readonly=True, a deterministic SHA-256 fingerprint is computed from spawn parameters (agent_type,prompt,verification_mode, etc.). Across forks and sessions, identical queries resolve in milliseconds directly fromWorkflowEventStorewith 0 token overhead, accelerating execution by up to 100x. - Strict Side-Effect Isolation: Sub-tasks with side effects (
readonly=False) are physically barred from cross-fork fallback, strictly protecting environment integrity. - Workspace Sidecar Journaling: Workflow execution traces are automatically mirrored to
.myrm/.workflow-journal.jsonlin the workspace, ensuring full auditability and portability.
14. Adversarial Audit & Multi-Skeptic Verification Library
In complex multi-agent workflows and code refactoring tasks, worker sub-agents often produce subjective “self-praising” narratives, easily leading traditional verifiers into confirmation bias. Furthermore, temporary test scripts generated during verification often pollute the workspace, and traditional systems lack fail-closed mechanisms on sandbox crashes. MyRM delivers an industrial-grade adversarial verification library:- Physical Auditor Blind Mode: Strips worker subjective narrative at the engine level, forcing the verifier to inspect strictly against real workspace Git diffs and objective test assertions.
- Snapshot Diff & Automatic Mutation Restore: Captures lightweight workspace stat snapshots before audit and automatically unlinks all verifier-created temporary files in a guaranteed
finallyblock. - Multi-Skeptic Parallel Majority Voting: Concurrently spawns 3 independent skeptic agents and requires a 2/3 majority vote to pass, eliminating single-model hallucinations and false positives.
- Fail-Closed Protection on Sandbox Crash: Strictly transitions the sub-agent status to
SubAgentStatus.BLOCKEDupon crash, preventing any unverified code from sneaking into production. - Native PTC Exposure: Easily callable in Python dynamic workflow scripts via
spawn_subagent(..., verification_mode="auditor_blind" | "multi_skeptic").
15. Structured Handoff Schema SSOT & End-to-End Evidence Lineage
In complex multi-agent handoffs, sub-agents often dump massive, multi-thousand-token raw conversation transcripts onto parent and downstream agents. This quickly triggers prompt context explosion and obscures critical facts. MyRM establishes an immutable, frozen data contract (AgentHandoverState SSOT):
- 85%+ Reduction in Parent Notification Tokens: Freezes handover states into compact summaries, completed checklists, and pending items, replacing raw chat dumps.
- Atomic Findings with Normalized Evidence: Every finding must include concrete proof (e.g.
test_proof.py:42) and normalized confidence levels (HIGH/MEDIUM/LOW), eliminating AI hallucinations. - Parallel Aggregation with Full Evidence Lineage: Automatically collects and deduplicates all external citations (
all_citations) while injectingsource_task_idandagent_typeinto every single finding across parallel batch summaries, preserving end-to-end provenance. - Leaf-Node Privilege Hard Guardrails & Full UI Disclosure: Blocks leaf sub-agents from executing privileged meta-tools (like cron scheduling); fully visualized in the Subagent Detail Drawer with dedicated badges, citation copy buttons, and code evidence previews.
16. Unified Composer Inline Context Chip Strip & Overload Governance
In sophisticated agent workflows, users frequently stage multiple pre-flight context items simultaneously — workflow templates, explicit slash skills, turn-level MCP/skill scopes, and file or conversation references. Traditional interfaces render scattered badges or rely on long natural language prefixes, leading to UI clutter and unbounded context token waste. MyRM introduces the unified Composer Inline Context Chip Strip (ComposerInlineContextChipStrip):
- Single Source of Truth for Pre-Flight Context: Elegantly aggregates 4 core context categories — workflow templates, explicit slash-activated skills, turn capability overrides, and
@mention citations — cleanly separating logical context chips from rich media attachments handled by dedicated thumbnails. - Responsive Adaptive Truncation & Popover Overflow: Automatically limits display to 4 chips on desktop and 2 on mobile, collapsing excess items into an interactive
+NPopover drawer with individual removal and action dispatch. - Amber Overload Nudge & 1-Click Capability Pruning: Continuously calculates total active tools and context weight; surfaces an amber alert button when overloaded, opening the turn capability editor for immediate tool pruning.
- Intuitive & Safe Keyboard Navigation: Supports rapid Backspace deletion of the trailing chip when the input textarea is empty, strictly guarded against accidental deletion when drafting text.