Auto-code is the workflow harness inside Morion. Put a ticket on the board, give each stage the model or CLI agent you want, and let the graph run: implementation, review, Mo routing, optional approval, and a closing comment on the card.
One agent can write code. Two agents — one writing, one reviewing — produce better code. The missing piece is the operating system around them: the board, the context packet, the decision point, the audit trail, and the next ticket.
Auto-code makes that loop explicit. A fast model can draft the diff, a stronger model can review it, Mo can route the outcome, and Morion moves the card with a comment explaining what happened.
No opaque cloud dev box. No single vendor model stack. It runs against your linked git repo and the same local Morion workspace that holds the tickets, notes, risks, and decisions.
The default template looks like this. Each node has its own model, prompt, and job. You can keep the safe pattern — build, review, decide, complete — or add your own steps when the workflow needs more control.
Workflows are immutable snapshots at run-start. The graph that started running won't be edited mid-flight, even if you tweak the template.
Auto-code uses the same vocabulary in the editor, in the JSON, and in the runtime logs. What you see is what runs.
Hands off to one of claude / codex / pi (OpenRouter-backed) with a templated prompt. Per-stage overrides for provider, model, and thinking budget. Use the fast agent where speed matters and the expensive one where judgment matters.
Free-text instructions to Mo plus a list of branching outcomes (e.g. accept · reject · review · ask_human). Mo reads the workspace state, picks one, and the graph follows that edge.
Ticket moves to done, Mo posts a closing comment. Every workflow has exactly one — can't be deleted.
Ticket moves to backlog, Mo posts a comment explaining why. Reachable from any mo_stage.
Workflow stops. Mo opens a chat ("here's what I'd like to do — go / no-go?"). Your reply unblocks the next stage. Lands in the executor next.
Pick the next node based on workflow state — file changed, test passed, label set. Reserved for the DAG runner; the current executor runs linear graphs.
Call a specific MCP tool inline, without spawning a CLI agent — append a comment, move a ticket, attach a file. Lands with the DAG runner. For now, those moves happen via the mo_tools stage.
Auto-code runs a separate workflow per ticket inside the app, and multiple cards can be active with different agents at the same time. The next-level meta-loop — picking which tickets to promote next, helping stuck agents, resolving merge conflicts across the batch — can happen in any MCP-aware terminal agent.
That is the product pattern: Morion is the board and memory; Auto-code runs deterministic per-ticket graphs; the outside supervisor uses MCP to inspect progress, help where needed, and promote the next safe set of cards.
Two loops, both visible: the inner loop is the workflow graph for a single ticket; the outer loop is the batch-planning supervisor. Both run on your own keys, both can be killed at any time, both leave an audit trail in your notebook.
Plenty of tools do one piece of this well. None ship all four pieces — graph composition, per-node model swap, local kanban as input, and Mo work packets — in a single product. Honest read on the field:
Cursor does multi-file agentic edits with per-task model selection. What it doesn't do: a deterministic graph of stages where each node has its own model and edges define accept / reject / review / human-gate transitions, plus a local kanban that acts as the work queue. Cursor's loop is "user prompts agent in IDE." Auto-code's loop is "ticket on board → defined pipeline runs."
Cline Kanban (Nov 2025) runs CLI agents in parallel, one git-worktree per card, with dependency chaining. It's the single closest product to the "kanban → agents" pillar. The gap: it's a board, not a graph. No branch / human-gate / sink nodes. No notebook on the same disk. No Mo-style work packet between agents and the board.
These are developer frameworks with graph builders for production multi-agent systems. They're powerful and infinitely flexible — and they're not personal-workflow products. No local notebook. No personal kanban. Building "draft → review → file the ticket" in LangGraph means writing Python and standing up infra. Auto-code is the consumer-grade version of that for one developer with the board already wired in.
Closed cloud SaaS. Opaque model stack — no per-stage swap. No BYO key. Code execution stays on Cognition's GPUs. If you want maximum autonomy on greenfield work and don't need to see how it's wired, Devin is the right shape. If you want a graph you composed running on models you chose against a notebook you own, that's the opposite product.
Aider has architect+editor pairing. Continue.dev assigns models to roles (chat / autocomplete / edit / apply). Roo Code (now in flux post-May 2026 shutdown) had mode-per-model with an orchestrator mode delegating to others. Pattern works — but the roles are hard-coded primitives, not user-composed pipeline stages with edges. Auto-code generalises the idea into a graph.
We didn't pull this list to dunk on anyone. We pulled it so you know what to expect when you compare. See full compares →
Or $16/mo billed monthly. The paid tier unlocks Auto-code today (closed beta), plus Mo, unlimited boards, per-folder MCP permissions, and every future feature as it ships.
Upgrade nowWhen Auto-code opens to the free tier, you'll be among the first to know. No spam, one email.
Closed beta is opt-in inside the app once you're on the paid tier. Free open beta opens after the approval-checkpoint runtime is ready.
Real, gated. The default build-review-decide template runs today in the paid closed beta. Approval checkpoints come next, then richer branching. The editor marks what is live versus what is roadmap, so you do not have to guess.
Per-stage: claude, codex, and pi for OpenRouter-backed models. All BYO key. The point is not one blessed model; the point is picking the right model for the stage.
On your machine, against a linked git repo of your choosing. CLI agents spawn as subprocesses; Mo decisions run wherever your LLM provider runs (OpenRouter / your Anthropic key / local Ollama). No code leaves your laptop unless your LLM provider sees it.
Yes. Auto-code uses Mo for context, decisions, and ticket moves. Mo runs on your LLM key — same key Auto-code uses for the mo_stage nodes.
The ticket pauses on the failing stage with the error in a tooltip. Nothing gets force-merged. You can resume after fixing the upstream issue or move the ticket back to backlog manually.
Workflows are stored per-folder. Built-in templates (Mo-driven default, Pi-fix, bug-fix, feature-planning, spike, docs-only, Claude-solo) are available everywhere. Your custom workflows stay with the folder, just like the rest of your data.
After approval checkpoints are ready for the wider free tier. No firm date — drop your email above and we'll tell you when it opens.