Engineering,on autopilot.
Moa runs your whole GitHub workflow — from triage to merge — and gets sharper every run. You keep the merge button.
- 6
- workflows, one engine
- 0
- API keys to set up
- 1
- merge button — yours
One issue, all the way to merge.
Moa picks up the issue, writes the fix, reviews the PR, gets CI green, and merges. The agent does the thinking; everything around it just works — so the work keeps moving from open to merged without you babysitting it.
The agent only reasons. The machine does the rest.
It writes code and reviews diffs — that's all it can do. It never pushes, never merges, never touches your repo directly. Everything that changes GitHub is plain, predictable code. That line is what makes Moa safe to leave running.
- gitbranches, commits & pushes
- githubissues, PRs, reviews, labels, checks
- verifyruns the build — node, rust, go, python
- readsissues, PR text, review threads
- writescode, or a review of a diff — nothing else
- runs asread-only or autonomous — you choose
The agent never pushes. It can't reach the network either — so a malicious issue or comment can't trick it into leaking or fetching anything.
One engine. Six kinds of work.
Triage, solve, review, fix CI, address feedback, merge. Same engine every time — start one from the dashboard, the moa CLI, a GitHub label, or let an event kick it off automatically.
$ moa wf triageread-onlyTriage
Reads a new issue, sorts it, adds the right labels, and leaves a comment. Never touches code.
read-only reviews · writes code on a branch · triggered by button, label, or webhook.
It remembers every move — and learns from it.
Every run leaves a trail Moa can follow later — issues, PRs, reviews, fixes, and the files behind them, all connected. Nothing's forgotten between runs, so it stops repeating mistakes and you can ask your codebase what actually happened.
See something off? Just say it.
Describe a bug or paste a whole spec. Moa investigates it in the real code, then files one clean issue — or several — depending on what it actually finds.
Every issue it files is remembered — so the next audit already knows what was flagged.
Give the agent a domain expert on call.
Working in React, Postgres, or Terraform? Give Moa a knowledge base for that domain and the agent checks it before writing a line — so it follows your stack's real patterns instead of guessing. Two ship today, and you can add as many as you like.
domains you can plug in — each is just a folder of docs you drop in.
- Read-only & sandboxedanswers only from its knowledge base — nothing else.
- Consulted, not guesseda real step before the agent writes — its answer shapes the plan.
- Just a folderdrop in a folder of docs to add a new domain.
/INDEX.mdts-engineer/INDEX.mdUnderstand first. Write last.
Every run reads, checks what it needs, and plans before it changes a single line. Writing is the last thing it does — never the first.
Reads the task and the relevant project sources to understand what it is being asked. Changes nothing.
Checks the right knowledge base when it needs to, so the plan is grounded in your stack — not guessed.
Forms a concrete plan from what it read and learned. Still no edits.
Carries out the plan — writes the code or produces the review. The only state that can change anything.
Review and triage stay read-only the whole way through — they look, report, and never change a line of your code.
Isolated. Cancellable. Timed out if it hangs.
Every run is sandboxed and tracked step by step. Cancel it whenever you want; if it stalls, it stops itself. Nothing leaks between runs.