Skip to content

For developers · the machine behind “vibe the project”

How Motir works

Every Motir project runs through the same instrument. The modules are Motir and its agents. The knobs and switches are yours: nothing moves forward until a person turns them.

Motir and agentsYou decide

The Motir workflow as a rack of modulesYour idea is patched into the planner, then into a knob where you approve the plan, then the board, then an agent run, then a knob where you review and merge, then Done. Manual tasks go from the board to Done. An agent run can log a bug it finds into the Bugs folder and keep going. A repair module loops failed runs back into the agent run. A learning loop runs from the agent run through a verdict, a re-plan and the lesson library back into the planner. A memory bank along the bottom holds designs, decisions, docs, lessons, run history, revisions and who decided what.

Scroll the drawing sideways →

Module by module

Each module in the drawing above, up close. Hover one to find it in the drawing.

[01] AI planning

From a prompt to a plan

Start with a sentence, a repository, or an import from Jira, Linear or Plane. The planner reads what exists, including a code graph of your repositories, and asks follow-up questions where the request is ambiguous.

It drafts epics, stories, tasks and subtasks, each with a type, an executor, a size and its blocked_by edges. validate_plan checks the tree before you see it.

[02] You · plan gate

You approve the plan

Nothing lands on the board until a person approves the plan. Ask for changes in plain words; each round is a new turn, and the plan's history keeps every version and why it changed.

[03] Work items

The board

The approved plan becomes work items with sprints, a backlog and a roadmap. Each work item's executor is agent or human.

Manual tasks (an account, a secret, a DNS record, a release sign-off) are walked through one step at a time by motir guide.

[04] Agent run

Agents build

An agent takes the next ready work item (motir next or motir run <KEY>), claims it, builds on its own branch and opens one pull request per repository, linked to the work item.

A bug it finds outside its own work item doesn't stop the run: the agent root-causes it, files it with motir log bug into the Bugs folder as a work item of its own, and keeps going.

Each run records the agent harness, the model, every step and the outcome. Agents connect over MCP, on your machine or Motir's hosted agents.

[05] You · merge gate

You review and merge

The work item moves to Implemented and the agent publishes How to test. Stories get an acceptance video recorded in CI. You review, approve and merge; the merge closes the work item. Nothing reaches Done without a person.

[06] Repair

When runs break

A red or conflicting pull request is repaired on its own branch with motir fix, up to five attempts. A run that died (a laptop closed, a sandbox lost) is resumed with motir continue on the branch it left.

Bugs logged along the way wait in the Bugs folder; motir fix bugs works through them, oldest first.

[07] Learning loop

The planner learns

An agent that can't build a work item first asks whether it is still what the approved plan approved (get_approved_shape_verdict), so a later edit isn't blamed on the planner. If the plan was wrong, it is re-planned and the change is recorded with its reason.

The mistake becomes a lesson, or reinforces one; with no rule to cover it, a planning bug is filed. The next plan reads the lessons first. Lessons that don't recur for 90 days retire.

[08] Memory

The project remembers

Designs, decision pages, docs, lessons, plan revisions and every run's history live next to the work items. You, a new teammate or the next agent can pick the project up months later without anyone explaining it again.

Open at the core

The project-management core is open source under GPL-3.0. Self-host it, or use it on motir.co.