Engineering,on autopilot.
Writing code was never the hard part. The real work starts after: reading the issue, opening a PR, reviewing it, fixing CI, and merging. Moa does all of it. But the agent only reasons; deterministic code runs every git action, so it never pushes to your default branch. You keep the merge button.
- Never pushes to main
- You approve every merge
- Only the repos you allow
Sign in with GitHub · connect a repo in minutes · revoke anytime.
- 6
- workflows, one engine
- 0
- direct pushes to main
- 1
- merge button, yours
The agent only reasons. The machine does the rest.
The decision that mattered most: keep deterministic engineering separate from AI reasoning. The model reads, writes, and reviews code. That's all it can do. Every irreversible action, from committing and pushing to opening PRs and merging, is plain, predictable code outside the model. So a dangerous mistake simply isn't available to it. 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 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; the deterministic machine around it moves the work along, so an issue goes from open to merged without you babysitting it.
One engine. Six kinds of work.
Triage, solve, review, fix CI, address feedback, merge. One engine runs all six, the same way every time. Start a workflow from the dashboard or the moa CLI and watch its live step timeline.
$ 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 · started from the dashboard or the moa CLI.
The whole engine, from your terminal.
The dashboard is one way in; the moa CLI is the other. Same server, same workflows, no context switch. Install it, log in, and drive triage to merge without leaving your shell.
moa login, and it bootstraps a key for you--watch streams the live step timeline · runs are the same ones the dashboard showsIsolated. Cancellable. Timed out if it hangs.
A coding agent should never be able to run forever. Every run is sandboxed and tracked step by step, capped by concurrency limits, timeouts, and a spending budget. Cancel it whenever you want; if it stalls or overruns its budget, it stops on its own. Nothing leaks between runs.
Put the loop on autopilot. Keep the merge button.
Connect a repo and watch an issue become a reviewed PR. The agent reasons; it never pushes to your default branch.
Request early accessManaged early access or a dedicated server · we'll reach out.
Understand first. Write last.
Grounding beats reminding. Every run reads, checks the knowledge 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.
Give the agent a domain expert on call.
Instead of asking the agent to remember how a codebase works, give it a domain expert to consult. Each oracle is a read-only knowledge base, and the agent checks the right one before writing a line, so it follows your stack's real patterns and answers with citations instead of guessing. Twenty-six ship today, and you can add as many as you like.
expert domains ship today, and each is just a folder of docs, so you can add your own.
- 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.
oracles/.It remembers every move, and learns from it.
Every run leaves behind a structured trail Moa can follow later: issues, PRs, reviews, fixes, and the files behind them, all connected. Future runs retrieve what happened before they act, so the agent stops repeating mistakes and starts feeling like a teammate that knows the repo. Instead of starting from zero every time, the system gets better.
Request early access, or a dedicated server.
Managed early access, or a fully isolated deployment on your own compute so your data and secrets never leave your environment. Tell us which and we'll reach out.