Skip to content

How Motir works · for developers

Vibe codingVibing the project.

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

Vibe coding: prompt in, code out

Vibe coding drawn as a toy with one knobA small plastic gadget with a single knob: type a prompt and out comes a heap of files, tangled in imports, with a circular import among them. Changing one line in one file breaks seven others. There is no plan, no board, no review and no memory; everything else is left to you. Scrolling replaces it with the full Motir instrument.Not part of MotirVibe codingToy · one knob> make me an app_PromptCodecircular importapp.tsxutils.tsapi.tsauth.ts1 line changeddb.tstypes.tsindex.tshelpers.tsstore.tsconfig.tsutils2.tsfinal_v3.ts???temp.jsapi_copy.tsfix.tstest_old.ts7 files brokePrompt in. Code out. The rest is up to you.

Vibe coding is one knob. Here are three.

Motir as one instrument with three controlsA closed synthesizer case. Its front panel has three controls joined by patch cables: the idea input where you type what you want, the Motir plan knob that turns it into a plan, and the Motir build knob that builds it. Scrolling opens the case to show the modules inside.MotirProject synthesizer · model 01Power[01] YouIdea input> an AI personal assistant that helps people reach their goals_Out[02] MotirMotir planAskPlanEpic › story › taskInOut[03] MotirMotir buildRunMerge1 PR per repositoryInDoneYour idea in · working software out

Code is one module. The project is all of them.

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. A switch on the rack flips between vibe coding, which keeps only your idea and the agent run, and vibing the project, which uses every module.

Under the modules: everything a prompt-to-code tool doesn't have

Motir's architecture as a circuit schematicThe services behind Motir drawn as components joined by signal lines. In the public zone: motir.co, the design system package, the agent shell relay, motir-core (web and REST API, the MCP server, sign-in, and the worker with its job queue) and motir-ai, the planner. In the private zone: motir-gateway, which meters every model call, and the code graph service. In the fleet: the agent host, the agent runner, the index runner and the CI runner, all booted on demand. In the data zone: Postgres and the file store. Outside: your browser, your own agent connected over MCP, the payments provider, the model providers and your code host.Inside the modulesSchematicSignal linesMCPHTTP · RESTStream · SSE / WebSocketDatabase · object storeBuild time · npmpublicprivateone wayboth waysOutsidePublic · internet, TLSPrivate · AWS VPCFleet · machines booted on demandDataJ1Browseryou, on any deviceJ2Your agentClaude Code · Codex · CLIJ3Paymentscheckout · subscriptionsJ4Model providersany model, meteredJ5Code hostrepositories · CI · appU1motir.codocs · explore · public pagesU2Design system@motir/design-systemU3Agent shell relaymotir-relayU4motir-corethe appWeb · REST APIMCP serverSign-in · OAuthWorker · job queueU5motir-aithe plannerConversationPlanningLessons · embeddingsCreditsU6motir-gatewaymeters every model callU7Code graphserviceU8Agent hostyour agent's machineU9Agent runnerone run, one cardU10CI runnerone jobU11Index runnerone repositoryU12Postgresthree databasesmotir-coremotir-ai · pgvectormotir-gatewayU13File storeobject storageAttachmentsDesign storeGraph snapshotssnapshotWSSSSEMCPwebhooksrun keybootsrun keyjobstarball

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 in Motir agent.

[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.