Changelog
What's new in each release. Running your own node? Read every release between yours and the new one before you upgrade. Questions about a release? Ask in Discord.
2026.11.9#
November 18, 2026 · This release on its own page
Changes now stay mergeable while they wait: Moru checks every open change against its target branch whenever that branch moves, shows the ones that no longer apply, and has an agent rebase them before you review them again. Requests become an issue tracker too: anyone who can read a repository can report a bug or ask for a feature, and a team triages, plans and orders its work in a backlog and on a board.
Conflicts show up when they happen. Each time a target branch moves, the node checks every open change on it, and a change whose latest revision no longer applies gets a Conflicts with
mainbadge on its page and in lists, with the files that conflict and the commit it was checked against. A change that’s behind the branch but still applies is fine and gets no badge. The Changes tab has a Conflicts filter. Merging still has the last word: a merge that hits a conflict the check missed marks the change Conflicted as before. See When a change no longer applies.Revise rounds count conflicts. In a loop, a revision passes only when CI passes, the pre-reviewer is satisfied and it still applies to its target. When it doesn’t, the next round tells the agent to rebase onto the branch first, keeping both its own change and what landed, and the agent can read what landed since its revision was made. See Revise rounds.
Passed changes are kept current. When a change that passed its loop starts to conflict while it waits for review, its attempt uses the rounds it has left: the agent rebases, CI and the pre-review run again, and the attempt ends again. Its timeline shows the rebase and Passed again. This happens for attempts that passed in the last seven days. Stop fixing conflicts on the attempt turns it off. See Keeping a passed change current.
Revise rounds don’t grade their own checks. The quickest way to turn red CI green is to edit the check, so a round that changes a CI workflow file (in
.moru/workflows/,.github/workflows/,.github/actions/or.moru/actions.lock) now ends the loop, even if CI then passes. The attempt reads Changed its CI workflows, names the files, and you’re notified. Rounds may still change tests, since sometimes the test is what’s wrong, but the attempt lists the test files each round changed ahead of its results. The agent is told to fix the code rather than the check, and the pre-reviewer to request changes for weakened tests. Only what a round changes counts: an agent’s first revision can add or fix CI and tests freely. See When a round edits the checks.Fix with an agent. A conflicting change made for a request has Fix with an agent, which starts a revise whose agent rebases first. Any revise you start on a conflicting change gets the same instructions.
Told once, when nothing is fixing it. If no agent is working on a conflict, because none was asked or the one that was gave up, the change’s owner gets one notification: “Your change conflicts with its target”. An attempt that rebased and still couldn’t make it pass says so in its own notification. The notification setting that used to be Couldn’t merge is now Conflicts and covers both.
A new revision clears Conflicted. A change marked Conflicted when a merge failed goes back to Open when a new revision arrives. It needs a fresh approval, since the rebase changed the code.
Runners don’t submit half-done rebases. If an agent exits in the middle of a rebase, merge, cherry-pick or revert, the runner submits nothing and the job says “left a rebase unfinished”, instead of committing conflict markers.
For scripts and agents. A change in the API carries
base, with its state, the commit it was checked against and the conflicting files, and the change list takes?base=conflicts. Webhooks can subscribe tochange.base, sent when an open change starts or stops conflicting. An agent’sget_taskreturnsrebase_onto,base_stateandlanded_since. See the API, webhooks and MCP docs.Requests from anyone who can read. Anyone signed in who can read a repository can file a request: on a public one, anyone with an account on the node. A request from someone without write access waits in triage, with a shorter form (a title, a kind and details) and Already asked? beside it, which lists requests with similar titles to vote on instead. People with write access accept it, accept and start work on it in one step, or decline it with a reason; a request declined as spam is hidden from everyone without write access. Those who can write to the repository and watch it hear when one comes in, and the person who filed it hears the answer. A repository admin can limit filing to people with write access under Settings → Requests. See Triage.
What agents read is marked. Text by someone without write access, a request’s details or a comment, goes into an agent’s instructions between markers, as a description of a problem rather than an instruction, and
get_taskmarks itoutside. Before, comments from anyone on a public repository reached revising agents as they were. Criteria are only ever set by people with write access. What an agent would be given, on a request’s page, shows the request’s part of an agent’s instructions.Planning. Requests get a kind, a priority, labels, a milestone and relations to other requests (part of, blocked by, duplicate of), in a Planning card on the request page. Labels and milestones are set up in the repository’s settings and, like everything else on a request, stored in the repository. See Plan requests.
Backlog and board. The request list gets Backlog and Board views, and filters by kind, priority, label and milestone, kept in the address. Drag requests into the order you’ll take them; filtered to a milestone, the backlog is its plan. On the board, dragging from Triage accepts a request and to Closed declines it, while In progress, In review and Done follow the work. See Backlog and board.
Votes, reactions and templates. Requests and comments take the eight GitHub reactions; a 👍 on a request is a vote, and the list sorts by Most wanted. Templates in
.moru/request-templates/give new requests a kind, labels and a starting text. See Request templates.Agents file what they find.
search_requestsandfile_requestlet an agent look for related requests and file what it notices outside its task instead of fixing it there. Its requests wait in triage, and the person it works for hears how they’re triaged. See MCP.Release notes on their own pages. Each release now has its own page, such as
/changelog/2026.11.9, with screenshots of what’s new.Link previews for the docs and the changelog. A link to a docs page or a release, shared in chat or on social media, now shows a preview card with the page’s title and summary. The links point at the node’s address, so set
MORU_PUBLIC_URLto the address people use.Link previews for public repos. A link to a public repo now shows a card with its name, the first paragraph of its README, and how many requests are open and changes merged. Links to a request or a change get their own card with its title, description and status. Private repos show no preview, so a link can’t reveal that one exists.
A shorter first run. A public GitHub repository can now be followed without a token: on Import from GitHub, leave Token empty and choose Follow without a token. Agents work on it right away, and Moru asks for a token with Add a token when there’s an approved change to send back as a pull request. A private repository still needs a token first. A node that has no admin yet now says so on its front page, with the command that prints the setup link, where it used to show an empty repository list. See the quick start and GitHub.
Tags on the Code tab. A repository with tags shows how many next to Go to file, and the count opens a list of them, newest first, with each annotated tag’s message and who made it, the commit it points at, and links to its files and history. The branch picker keeps branches and tags on separate tabs, so tags don’t get lost below a long list of branches. The API lists tags at
/repos/owner/name/tags. See Tags.Tabs say what’s waiting. A repository’s Requests and Changes tabs show how many wait on you in amber, next to how many are open. The CI tab shows how many runs are queued or running, and a red dot when the default branch’s CI fails.
A way to a runner from a waiting job. When your CI job waits because none of your runners is online, its run page links to Set up a runner if you have none, or to Your runners if you do.
A steadier change page. A change page no longer reloads its diff and comments each time a CI event arrives, so the diff stops flashing while CI runs.
Upgrading#
- The check needs git 2.40 or later on the node. The image ships 2.47. A node run without the container on an older git logs a warning once and skips the checks: no badges, and loops don’t count conflicts. See Without a container.
- The first check after the upgrade is quiet. Changes that already conflict get the badge, but no notification and no
change.basewebhook, so you don’t get one for every old conflict at once. Attempts that passed in the last seven days may still be reopened to rebase, a few at a time. - Upgrade runners. Older runners don’t fetch the commit a round should rebase onto ahead of time and don’t check for an unfinished rebase before submitting.
- On a host with several nodes, upgrade them together: a node still on an older version shows a loop that ended because a round changed a workflow as Stopped, without the files.
- Existing webhooks keep their list of events, so they don’t get
change.baseuntil you add it. Webhooks subscribed tochange.*get it now. - Anyone who can read a repository can now file requests in it. On a public repository that means anyone with an account on the node; their requests wait in triage, and each account may file 10 an hour on repositories it can’t write to (
--request-rate,MORU_REQUEST_RATE). To keep the old behaviour, set Settings → Requests to Writers only. - Triage, planning, labels, milestones, reactions and templates use a new format for the records they write in repositories, format 3. Nodes on an earlier release can’t read a repository once it has any. A repository that uses none of them stays readable by them. On a host with many nodes, upgrade every node first: until every node reads format 3, those writes are refused with a 503.
- The index is rebuilt when the node starts, as after any release that changes it.
- Agents started before the upgrade can’t use
file_request: their tokens don’t carry the newrequest:filepermission. Agents started after can. - Notifications gain the reason
triage(Triage). Webhooks gain the eventtracker.updated, and request payloads gaintriage,declined_reason,kind,priority,milestone,labelsandwhat. Existing webhooks keep their list of events.
2026.11.8#
November 17, 2026 · This release on its own page
Repositories get CI: workflows in .moru/workflows/, or GitHub’s in .github/workflows/ as they are, run on every new revision, push, schedule or manual start, on the runner of the person each run is for, and a repository can require jobs to pass before a change merges.
CI. A workflow is a YAML file in
.moru/workflows/, close to GitHub Actions’ syntax but without an expression language: jobs,needs, matrices, timeouts,when:conditions on the trigger,paths:filters, and steps that are shell commands. Four triggers: a change’s new revision (optionally only for some target branches), a push to a branch or tag (merges included), a schedule, and a manual start. A file with a mistake doesn’t run: its run is refused and lists each problem with its line and column. See CI and the CI file reference.Runs on your own runners. Each run is for one person: whoever started the agent, proposed the revision, pushed, merged or started the workflow. Its jobs run only on that person’s runners, as the runner’s user, with no sandbox, in a fresh checkout of the commit, and the job’s token can only fetch the repository. A new revision cancels the unfinished jobs of the change’s earlier runs, and a new push those of the branch’s previous run, unless the workflow sets
cancel-superseded: false. Runners take CI jobs by default;--kind cimakes a CI-only runner, and--kind implement --kind reviewkeeps CI off one. See Where to run a runner.Secrets stay on the runner. A job lists the secrets it needs, and the runner’s owner puts them in the runner’s
ci.toml, scoped to repositories, refs and triggers. The node sees their names, never their values. A runner that can’t give a job every secret it lists doesn’t take the job, and the run page says which secret is missing. By default secrets aren’t given to changes’ runs or to scheduled runs. Values are redacted from logs and outputs. See CI secrets.The CI tab and run pages. A repository’s CI tab lists its runs with filters, the workflows on the default branch and any that don’t parse, and Run workflow for workflows with a manual trigger. A run’s page shows the job graph and each job’s steps with their logs, with Cancel and Re-run for people with write access. The change page shows each revision’s CI results. On a public repository anyone who can read it sees CI logs and outputs; on a private one only people with write access do. Which runner ran a job is always for people with write access.
Required CI jobs. A repository admin can require jobs, such as
checks/test, to pass before a change merges, in the repository’s settings or withmoru-node repo-policy --required-ci. A job counts when every matrix combination passed on the latest revision, on a runner whose owner had write access when the runner took the job. A required job that doesn’t run for a revision by design, because itswhen:or its workflow’spaths:leave it out, counts as passed, as on GitHub; one skipped because a job it needs failed doesn’t. See Required jobs.Signed CI results. Each finished CI job for a change’s revision becomes an attestation in the change, signed by the node, with the runner’s own signed claim inside, so results travel with the repository and verify offline.
moru-node verifyand the API’sverifylist them. See Provenance.Local runs.
moru-runner ci run checks/testruns a workflow’s job in your working tree without a node, with the same step runner and environment a runner uses.--matrix,--eventand--refpick what to run as, and--secretsgives jobs the secrets fromci.toml. See moru-runner ci run.GitHub workflows run as they are. A repository with no file in
.moru/workflows/runs the workflows in.github/workflows/, translated into the same jobs:push,pull_request(every revision of a change),scheduleandworkflow_dispatchtriggers,${{ }}expressions with GitHub’s contexts and functions, jobif,needsresults and outputs, matrices withincludeandexclude,continue-on-error,fail-fast,max-parallel, theGITHUB_*variables and command files, and reusable workflows from the same repository.ubuntu-*andmacos-*run on your Linux and macOS runners; Windows combinations of a matrix are dropped, and the rest run. Each workflow gets a compatibility report on the CI tab: runs as is, runs with notes, or refused and why. What can’t run on Moru, such asenvironment:,pull_request_targetor actions that need GitHub’s API, is refused rather than run halfway. See Running GitHub workflows.Actions. Steps can use actions, in GitHub workflows and native ones.
actions/checkout, thesetup-*actions,jdx/mise-action,dtolnay/rust-toolchain,actions/cache, the artifact actions anddorny/paths-filterare built into the runner: setup actions check that the machine has the version asked for rather than installing it. Other JavaScript and composite actions are fetched from GitHub and run with the machine’snode, and Docker actions in a container. Actions never get a job’s secrets unless the workflow passes them.Containers. Jobs can start
services:such as a database next to them, run their steps in acontainer:image, and use Docker actions anddocker://images, in GitHub workflows and native ones. The runner usesdockerorpodmanon its machine, Linux or macOS (Docker Desktop, OrbStack, colima, podman machine), and takes such jobs only while its engine answers; until one of the person’s runners can, the job waits and says so. Services are reached atMORU_SERVICE_<ID>_HOSTand_PORT_<port>, with ports published on 127.0.0.1 only. A job container sees the job’s folder at the same paths as the machine. Images are pulled each job, with the copy already on the machine as a fallback, and run by the ID that was pulled; a run’s page lists each job’s images and digests, which a change’s signed CI results carry too. Containers get none of the runner’s own environment:optionscan’t copy a variable in (-e NAME,--env-host), and thedockerorpodmancommand itself only sees what the engine needs. Everything a job starts is labelled and removed when it ends, and a runner that was killed removes what’s left when it starts again. See Containers.Locked actions.
moru-runner ci lockwrites.moru/actions.lock, the commit and content of every action your workflows use, nested ones included, and the digest of everydocker://image, and the runner checks each action and image against it. Without a lock the node looks tags up when a run starts and marks the run Unlocked actions. A repository admin can require locked actions under Merging. See Locking actions.Schedules. A
scheduletrigger runs the default branch’s workflow from cron lines, in UTC or atimezoneyou give, at most every 5 minutes. Runs are for the person a repository admin picks under Scheduled runs use in the repository’s settings; a person’s repository defaults to its owner, and an organization’s runs none until someone is picked. If that person loses write access, schedules stop and the admins get a Stopped schedules notification. See Schedules.Caches. A job’s
cache:(oractions/cache) keeps directories on the runner between runs, with GitHub’s key and restore-key rules. A change’s runs restore only from their own change, their target branch and the default branch, and don’t save.[cache] max_sizein the runner’sci.tomlsets the room they take, 10 GiB by default. See Caches.Artifacts. A job’s
artifacts:(oractions/upload-artifact) uploads zips to the node, for later jobs of the run and for download from the run’s page by anyone who may see its logs. Kept 30 days, at most 500 MiB each and 1 GiB per run. See Artifacts.Manual inputs. A manual trigger’s inputs can be strings, booleans, choices or numbers. Run workflow asks for them, the API takes them, a native step reads them as
MORU_INPUT_<NAME>, and a re-run keeps them.Named runners. A job can ask for one runner by name,
runs-on: { runner: mira-deploy-box }. A runner started with--only-namedtakes only CI jobs that name it, from pushes and manual starts, never a change’s runs, and scheduled runs only with--schedules: the place for deploy secrets. See Deploy runners.Local runs of GitHub workflows.
moru-runner ci runreads.github/workflows/too, with actions, caches and artifacts, kept in your user cache directory. Services, job containers and Docker actions run with your owndockerorpodman, and Ctrl-C removes them.Reusable workflows. A job in
.moru/workflows/can call another workflow of the same repository,uses: ./.moru/workflows/checks.yml, with inputs inwith:. The called file declares acalltrigger, and its jobs join the caller’s run under the calling job, required asci/checks/lint. See Calling a workflow.Moving to Moru’s format.
moru-runner ci importwrites.moru/workflows/from your GitHub workflows, keeping file names and job IDs so required jobs keep their names. Calls to reusable workflows of the repository stay calls;--flattencopies the called jobs into each caller instead. What has no native form gets a# TODO:comment, and a step or job condition it can’t carry over is replaced by a step that fails until someone ports it, so nothing runs that GitHub would have skipped. On the CI tab of a repository that runs GitHub workflows, Move CI to Moru’s format opens a request for the move, filled in and ready for an agent. See Moving to Moru’s format.Jobs wait for a new enough runner. Runners send their version when they ask for work, and a CI job that uses a feature older runners don’t know waits for a runner that has it; the run page names the version it needs.
One workspace per repository. A CI job checks out in
<work-dir>/<owner>/<name>on its runner, the same folder for every job of the repository, as on GitHub, so a build from one job (a nextest archive) runs in the next. A runner runs one job of a repository at a time;--work-dirsets the folder, the same on every machine for builds that cross them. See Where a job runs.Revise rounds. A single agent can now revise its own change until it’s ready: when a revision’s CI fails or its pre-reviewer requests changes, it starts another round on the same change, up to the number of rounds you pick (3 by default with a pre-review). You get the change when it passes or the rounds run out. The attempt shows each revision’s results, comments on the change steer the next round, and Stop after this round ends the loop early. Nothing merges without you. See Revise rounds.
One job and exit.
moru-runner run --oncetakes at most one job, runs it and exits, for autoscalers, Kubernetes Jobs and spot machines.Notifications, webhooks and agents. A failed or refused run notifies the person it was for (CI failures in your notification settings). Webhooks can subscribe to
ci.run.queued,ci.run.startedandci.run.finished, or to a family of events such asci.*, which includes events later versions add. Agents read their revisions’ CI results, and reviewers their candidates’, with the MCP toolget_ci_results.Discord.
/discordon every node takes you to Moru’s Discord server.Moru vs GitHub. Nodes with the landing page on serve
/compare/github: the samegit cloneagainst GitHub and Moru, what happens on each when an agent’s token leaks or you want to leave, and where GitHub is the better fit. It has its own link preview, it’s listed insitemap.xmlandllms.txt, and its questions are marked up for search engines. The landing page now names every agent a runner can run, not only Claude Code.Moru vs GitLab, Forgejo, Radicle and Tangled. Four more comparison pages, built like
/compare/github, at/compare/gitlab,/compare/forgejo(Gitea included),/compare/radicleand/compare/tangled, and/comparelists them all. Each was checked against that forge’s own documentation on the date it shows, and says where that forge is the better fit. The landing page’s footer links to/compare.Readable without scripts. With the landing page on,
/is the page itself, not an empty page the browser fills in, so search engines and AI agents read what’s on it. The node also serves/llms.txt, a list of the docs pages, and/llms-full.txt, every docs page in one Markdown file, both linking to the node’s public URL.sitemap.xmlno longer lists/explore, which shows nothing without scripts.Real 404s. An address that’s no page of the web UI, such as a docs page that doesn’t exist, is answered with a 404 status. It showed the not-found page with a 200 before, so crawlers kept it as a page.
Trying Moru with a GitHub repository. A node at
localhostcan’t register a GitHub App, so Import from GitHub now leads there with Link a repository with a token, and Create a token on GitHub opens GitHub’s token form filled in with the permissions Moru needs. The quick start goes fromdocker runto a pull request an agent wrote, and the landing page has a Try it on your laptop quick start.Disconnect a GitHub App. Site admins can disconnect an app renamed or deleted on GitHub from the GitHub page. The node forgets it and its keys. Repositories linked through it stay linked but stop syncing, say so in their bar, and move onto another connected app with Use the GitHub App. See Disconnect an app.
A runner in one command. Add a runner shows one command that installs, registers and starts the runner (
install-runner.shtakes--code,--name,--nodeand--run), and says when the runner comes online. The three separate steps are still there under Step by step. Opening the page more than five times within 15 minutes no longer locks you out: each new code retires your oldest unused one. See Add a runner.Getting started. The repository list shows a checklist until you’ve brought a repository, added a runner, asked an agent for something and shipped the result. It ticks itself off from what the node knows, and × hides it.
Claude Code only where it can sign in. A runner offers Claude Code only when its user has a Claude login or key: Claude Code’s own sign-in,
ANTHROPIC_API_KEY,CLAUDE_CODE_OAUTH_TOKENand the like. Someone who uses only Codex or Gemini CLI no longer gets jobs for the default Claude profiles sent to a runner that fails on sign-in. The runner says when it found none;--harness claudeoffers it anyway. Add a runner lists how each agent signs in. See Agents.A first request that’s quick. A repository’s first request starts on Single agent and offers small tasks to start from: tests for an untested part of the code, checking the README’s setup steps, or resolving a TODO.
Docs beside the page. Docs links in the product open the page in a panel on the right instead of leaving the screen you’re on: next to it on wide screens, over it on narrow ones. The header’s Docs button opens the docs for the screen you’re on, and the command menu’s docs results open there too. A link held with Cmd or Ctrl, or Open full page, still goes to the full docs.
Running from your own registry. The install guide shows how to copy each release’s image, both architectures, into a registry you run, or load it on a host with no registry access, so your hosts never pull from
ghcr.io. Runners installed from your node then come from your copy too. See From your own registry.Sign-in and push hardening. The five-failure sign-in lockout now holds against sign-ins sent in parallel, and reads the client’s address correctly behind a proxy that adds its own
X-Forwarded-Forline. Pushes can’t reach a protected branch or a ref the node manages by spelling its name in another case, which mattered on case-insensitive filesystems such as macOS. A push to a repository is limited to 2 GiB by default (--push-quota-mib). Webhooks refuse more addresses that lead into the node’s own network (IPv6 forms that carry an internal IPv4 address), read only the start of a receiver’s response however long it is, and give up on a delivery that can’t be sent instead of trying it forever. A runner that stops a job no longer leaves behind a process the job was starting at that moment.
Upgrading#
- A push to a repository larger than 2 GiB is now refused, on existing repositories too. Raise
--push-quota-mib(MORU_PUSH_QUOTA_MIB), or set it to0for no limit. Imports aren’t limited. - Pushes to
refs/heads/,refs/tags/,refs/for/orrefs/moru/spelled in another case, such asrefs/Heads/main, are refused. A protected branch is protected in any case: withmainprotected,Maincan be created but not moved or deleted by a push. - On a host with many nodes, upgrade the control node before the repo nodes. Until the control node runs this release, CI doesn’t run on the repo nodes: pushes and changes there start no runs, and no runner gets their jobs.
- Upgrade runners to run CI. Older runners never take CI jobs, so a run’s jobs wait until one of the person’s runners is upgraded. GitHub workflows, actions, caches, artifacts, named runners and jobs with
container:,services:or Docker actions need runners on this release. - Upgraded runners with
dockerorpodmanon their machine take container jobs, and run their images as the runner’s user can. To keep a runner off them, start it with--container-cli none(orMORU_CONTAINER_CLI=none). moru-runner ci runkeeps its fetched actions, caches and artifacts in your user cache directory by default, not in./runner-cache. Pass--cache-dirto use another.- Runners can’t be named
linux,macos,x64orarm64, the labels every runner has. Existing runners keep their names. - Repository policies gain
require_locked_actionsandschedule_as, inrepo-policies.json,PUT /api/v0/repos/{owner}/{name}/policyandmoru-node repo-policy(--require-locked-actions,--schedule-as). Older files read as off and as the default. - Scheduled runs are opt-in on runners. A
ci.tomlsecret goes to scheduled runs only when itstriggerslistschedule; the default is now push and manual. If you set up secrets with an earlier build of this release and lefttriggersout, they stop going to scheduled runs: addschedulewhere a scheduled job needs one. A runner started with--only-namedtakes scheduled runs only with--schedules. - Repositories owned by a person run their workflows’ schedules as the owner as soon as you upgrade. An organization’s repository runs none until an admin picks someone.
- When a run uses an action that
.moru/actions.lockdoesn’t list, the node looks its tag or branch up on github.com (git ls-remote) as the run starts. A node that can’t reach GitHub refuses such runs, naming the action: commit a lock. - CI artifacts are stored under
ci/artifacts/in the data directory and aren’t in backups. The node refuses uploads that would leave less than 2 GiB free. - Notifications gain the reason
ci_schedule_stopped(Stopped schedules), for repository admins. It has no webhook event; the new webhook events areci.run.queued,ci.run.startedandci.run.finished. - Upgraded runners take CI jobs by default and run the commands in a repository’s workflow files as the runner’s user. If a runner shouldn’t, start it with
--kind implement --kind review. - Existing webhooks keep their list of events, so they don’t get CI events until you add them. A webhook created without a list gets every event, the CI ones included.
- Merging checks change records. A merge is refused when the change’s latest revision names a commit or base that isn’t an object ID. Change records fetched from GitHub could carry such values, and they reached
git rebase. - Breaking (API):
PUT /api/v0/repos/{owner}/{name}/policynow changes only the fields in the body, and refuses unknown ones. A field left out keeps its value instead of being reset.
2026.11.7#
November 13, 2026 · This release on its own page
One host can run on several nodes, repositories move between them, and nodes check signatures against everything they know about a host, not only what each repository carries.
- Many nodes per host. Your node becomes the host’s control node when it serves with
--internal-listenand--internal-url, and keeps its repositories, accounts and keys. Empty nodes join it with a one-time node code (moru-node node-code, thenmoru-node join) or by themselves with an enrollment token (moru-node node-token, thenMORU_CONTROL_URLandMORU_JOIN_TOKEN). New repositories go to the node with the fewest, every node takes requests for any repository, and lists ask every node. Runners keep one address and get jobs from every node.moru-node nodeslists the nodes. A new host can start from a control node that holds no repositories (--role control), and on Fly.io--replay flylets Fly’s proxy send a request straight to the machine that serves it. See Running many nodes. - Moving repositories. A site admin moves a repository to another node from its Settings → Node, or with
moru-node move-repoon the control node. Reads keep working while it moves; writes pause with a 503 andRetry-After, queued jobs are cancelled, and running ones get 10 minutes (--drain) to finish. Pending webhook deliveries go with it, and open pages reconnect by themselves. An organization’s.morurepository, a repository linked to GitHub and one in the trash stay where they are.moru-node movesand Settings → Network follow every move, and a move can be aborted until it switches over. - Draining a node.
moru-node drain-node <node>, or Move all repositories off this node… in Settings → Network, moves every repository it can off a node, one at a time, each to the node with the fewest. A move that fails is rolled back and the drain goes on; five failures in a row stop it. What can’t move stays and is listed with why. The node takes no new repositories from then on, also after the drain, until--undoor Take new repositories again: use it before retiring a node, or to leave your original node holding only what the control node must. The Activity tab andmoru-node movesfollow drains, and--abortor Abort stops one. See Drain a node. - Settings → Network. One page for site admins, in three tabs. Nodes draws the host and its nodes as a diagram: each node’s certificate, role, version, repositories and last report, and the moves under way; a node’s menu drains it, retires it, revokes it, or restores its repositories from a backup, the same as the commands on the control node. Hosts is a grid of what each node knows about each host: its DID document and when the directory was last asked, revoked keys and where the node learned them, and a host the node doesn’t trust because its documents conflict. A host that one node trusts and another doesn’t shows in one row. Activity follows drains, moves, revocations and restores, with a count of those still running. Add a node, at the top, makes a node code or an enrollment token. While the control node is down, a repo node still shows the page from its own copy of the node list, without the actions. The same data is at
GET /api/v0/nodes,GET /api/v0/nodes/local(the answering node’s copy) andGET /api/v0/hosts. See Running many nodes. - Repo nodes keep working while the control node is down. Pushes, reads and changes go on for
--control-grace(5 minutes), a repo node that restarts meanwhile keeps what’s left of it, agents can submit, and running jobs keep reporting to the end. Pages work without organizations, under a notice. Register runners against the host’s public address, never a node’s own. - Protocol levels. Every node says which protocol level it speaks, and nodes within one level of each other work together, so you can upgrade one node at a time. The control node refuses a node further away.
- Backups by node.
moru-node backupknows which kind of node it runs on. A control node’s backup holds the host-wide state and keys; restored, it gets where each repository lives back from the repo nodes’ reports, and moves or revocations that hadn’t finished come back failed, to be started again. A repo node’s backup holds its repositories without its key: restored, it joins the host as a new node and takes over the old node’s repositories. Stop the old node first. - Retire or revoke a node’s key.
moru-node retire-node <DID>retires the key of a node that left cleanly: everything it signed keeps verifying, and it can’t sign anything new.moru-node revoke-node <DID> --at-ms <time> --vouched-from <checkpoint>revokes a key that leaked, keeping only what a checkpoint taken before then lists. Both refuse this node’s own key and keys this host never certified. On a host with many nodes, run them on the control node or use Revoke… in Settings → Network: the node’s moves are rolled back, every node writes the host’s signed revocation into each repository the node signed in, and what it signed stays valid as far as the newest checkpoint the control node received from it by then. Revoking works in a repository where the key signed more than 10,000 objects. See moru-node. - Checkpoints. The node records, every 10 minutes and when it starts, which objects in each repository its key signed, in
checkpoints/in the data directory. It keeps the last 144 that differ, and backups include them.moru-node checkpointtakes one by hand. Keep a copy off the node: after a leak, only a checkpoint from before it is worth anything. - Revocation records.
revoke-nodeandretire-noderecord each revocation inhost/revocations.json, with the checkpoint it vouches from inhost/checkpoints/, before they write any repository. A rerun after a failure writes from the recorded time and checkpoint. The control node records every node it revokes the same way and sends the records to the other nodes, which keep applying them while it’s down. Backups keephost/. A finished revocation’s message counts every repository that holds it: ”… is revoked in N repos on M nodes (W written now, A held it already)“. - Restoring a revoked node’s repositories.
moru-node restore-reposon a node of the host, or Restore its repositories from a backup… in Settings → Network (an upload, up to--max-restore-upload, 20 GiB by default), brings a revoked or retired node’s repositories back from its backup. A revoked node’s revocation goes into each one before it’s served. A node runs one restore of a given old node’s repositories at a time, and refuses a second until the first finishes or is aborted. - Revocations a copy lacks still count. A node checks every repository against the revocations it knows from its other repositories, from its own revocation records, and, on a host with many nodes, from the control node. An old copy of a repository, an import or a restored backup can’t make a revoked node key trusted again. Ops the key signed after its revocation don’t load, and its attestations stop counting for merges. See How trust works.
- Revocations are written where they’re missing. The node writes its own host’s revocations into any repository that lacks them: an import before it’s served, a GitHub link right after it fetches Moru’s data, every repository when a new revocation is recorded, and a repository a push brought old host data into. Failed writes are retried in the background.
- Fresh DID documents from the PLC directory. For
did:plchosts it trusts as attesters, and hosts imported repositories carry a valid DID document of, the node fetches the host’s log from the PLC directory about every 12 hours, so a rotated key stops counting even in repositories that never stored the rotation, and a host’s recovery of its log takes effect. A log that takes back what the directory served before is refused. - Why a signer isn’t trusted. The change page’s Evidence panel and the API’s
verifysay “revoked by … from …”, with “(known to this node)” when the repository itself lacks the revocation, or that the trusted host behind the signer isn’t trusted on this node because its DID documents disagree (untrusted_host). An object that no longer loads says the same in its error. - Import report. Importing from another node lists the hosts the repository names: known or new, the revocations the copy lacked and whether they were written before it was served, and any conflict between its DID documents. The JSON has
hostsandwarnings. - Nodes sign for password accounts and agents. A node now signs a password account’s or an agent’s changes with its own key, under a one-time authorization from that person’s or agent’s key. Older changes keep verifying as they are.
- Free disk space is checked first. A move’s target and
moru-node restorefrom a file refuse up front when the disk lacks free space of twice the archive’s size plus 64 MiB;moru-node restore-reposand a restore upload in Settings → Network need three times the backup’s size plus 64 MiB, since the backup is kept while its repositories are unpacked. Each says how much it needs and how much is free, and a move whose target lacks the room fails at once rather than trying again. - Fixed: two changes to the same person’s preferences, notification read state or dismissed suggestions at the same moment, for example from the web app and the command line, could overwrite each other.
Upgrading#
- Breaking: nodes on 2026.11.6 or earlier can’t read changes this release signs for password accounts and agents. Upgrade every node that reads your repositories, including nodes you import them into, along with this one.
- Breaking (API): the API and
/mcpno longer take Basic credentials (curl -u). Send the token asAuthorization: Bearer. Git is unchanged: it still takes a token as the password. - Upgrade runners too. On a host with many nodes, a runner from before this release can have a job update refused for a moment after it registers or renews its token; this release’s runner tries once more.
- On a host with many nodes, every node must run a release within one protocol level of the control node’s, or the control node refuses it. Upgrade the control node first, then the repo nodes.
- An object that loads today can stop loading after the upgrade, if the node knows that a key that signed one of its ops was revoked before that op. Its error, the Evidence panel and the import report name the host and the time. Repositories that held such objects were relying on a signature their host had withdrawn.
- Imports now write the node’s own host’s known revocations into the copy before it’s served. Imports and restores fail if
host/revocations.jsoncan’t be read, rather than serve a repository without its revocations. The error says what to do. - The node makes outbound HTTPS requests to the PLC directory (
--plc-url) for thedid:plchosts it trusts as attesters and those imported repositories name. On a node that can’t or shouldn’t reach it, setMORU_NO_PLC_REFRESH=1(--no-plc-refresh) forserveand every other command you run on the data directory. - A
did:plchost whose directory log the node can’t refresh for about a day stays trusted, including one that recovered its log (Settings → Network shows Recovered, stale). It is shown as Not trusted until a fetch succeeds only when a document a repository carries diverges from the node’s last log in a way that log’s recovery doesn’t explain. - If you restore a node from a backup taken before you revoked a node key, run
revoke-nodefor that key again with the same time (orretire-nodeagain for a key you retired).
2026.11.6#
November 11, 2026 · This release on its own page
Every runner has an owner, agents run directly on the runner’s machine without a sandbox, and runners run Codex, Gemini CLI or an agent of your own as well as Claude Code.
Any agent. Runners run Codex and Gemini CLI as well as Claude Code, using the logins already on the machine, and offer each one whenever it’s on the runner’s
PATH. Any other agent you can start from a command line goes in the runner’sagents.toml: its command, how it takes a model, and which jobs it takes. A profile’sharnessnames the agent, and new nodes come withcodexandgeminiprofiles. Their output reads in the job log as Claude Code’s does: messages, commands, edits and tool calls. Usage limits send Codex and Gemini jobs back to the queue as they do for Claude Code, and your own agent says so by exiting with 75. Only Claude Code can be pinned to a version, so a repository that requires pinned runs doesn’t merge the others’ changes. See Agents.Your own profiles. Settings → Agent profiles lets anyone make agent profiles of their own: an agent, a model, a description and runner labels. They’re named after you (
mira/codex-high), only you can pick them, and they run on your runners. Any agent can now be picked as a reviewer, not only Claude Code. See Agent profiles.Every runner has an owner. A runner runs only the jobs of the person it belongs to. The shared pool is gone: Settings → Runners offers only your own registration code, and
moru-node create-runner-tokenneeds--owner. A team that pays with an API key gives it to each person’s runner. Site admins still see everyone’s runners, and runners without an owner in a tab of their own. See Runners.No sandbox. The runner runs agents as its own OS user, in a working copy under its cache directory, with the machine’s tools, network and files. Repos build and test the way they do in your terminal, with no image to build, no
--read-pathand no egress allowlist. In return, an agent can reach everything the runner’s user can. Run the runner on a machine or account you’re happy for an agent to use, or in a VM or container you set up. See Where to run a runner.Credentials from the machine. Agents use the runner user’s Claude Code login, or
ANTHROPIC_API_KEYorCLAUDE_CODE_OAUTH_TOKENfrom the runner’s environment. Setting both no longer stops the runner from starting.Setup is one binary. Install,
moru-runner register,moru-runner run. No Docker, no sandbox check, no AppArmor profile on Ubuntu. Runners can now run on Fly.io, Railway, Render and Kubernetes.Pinning means the Claude Code version.
--require-pinnedasks only for a pinned Claude Code version. The Evidence panel says “no sandbox (macOS)” or “no sandbox (Linux)” for new runs; older runs keep showing the sandbox and image they ran with, and their attestations still verify.Bake-offs no longer have the “Shared runners don’t review their own work” option, since every runner reviews only its owner’s work.
separate_reviewersin the API is ignored.Requests read as one thread. The request page shows every attempt in order: a Bake-off, the revisions that followed it, and, at the end, Your call to approve and merge the latest revision or revise it again. The request’s comments sit in the thread where they were made. Each attempt folds to a summary you can unfold, and a Bake-off shows its candidates at the revision its reviewers ranked, with where each one was continued. Each attempt has its own address,
…/requests/<id>/attempts/<n>, and a new attempt starts at…/attempts/new; older links still work.Diffs with many files. Every diff can list its files, fold each one, and expand or collapse them all. With more than 8 files, or a file over 400 changed lines, they start folded. A Bake-off’s Diff between candidates adds a grid of which files each candidate changed, with line counts; click a cell to open that file.
Smaller pages. The node compresses the UI, the docs and API responses with Brotli or gzip for browsers that accept them. Git traffic, the live event stream and runner downloads are sent as before.
Fixed: when a request’s change merged after its Bake-off was replaced by a revision, the other candidates stayed open and kept asking for review. A request’s other open changes now close as Not picked once one of its changes merges, and the node tidies up requests that merged before this release on its own. A closed change can’t be approved until it’s reopened (status
open), and its page no longer offers Approve or Merge.Fixed: an agent revising a change couldn’t fetch the revision or push its work to the node.
Upgrading#
- Breaking: runners without an owner stop getting work.
moru-node list-runnersshows them withowner=none (can't lease), and Settings → Runners under “No owner”. Give each one an owner withmoru-node create-runner-token <name> --key <DID> --owner <user>and restart it with the new token, or revoke it. - Breaking:
moru-runnerno longer takes--sandbox,--read-path,--image,--sandbox-node-urlor--egress, and thesandbox-checkandsandbox-execcommands are gone. Scripts and service files that pass them fail: drop the flags and start the runner again. - Breaking:
moru-node pin-imageis gone, and profiles no longer have animagefield. - Breaking: agents run without a sandbox. Before you start an upgraded runner, check that its machine and user are ones you’re happy for an agent to use. See Where to run a runner.
- Breaking (API): runners in
GET /api/v0/runnersno longer havedocker,sandboxorcredential. A runner registration code no longer takesshared. - Runners no longer need Docker or the agent image. You can remove the
moru-agentimages andubuntu/squid. - Existing nodes keep their
profiles.jsonas it is. To offer Codex and Gemini CLI, add{ "name": "codex", "harness": "codex" }and{ "name": "gemini", "harness": "gemini" }to it. See Agent profiles. moru-runner run --harnessnames agents now, and its default is every agent the runner has rather thanclaudeandfake. A runner on a machine withcodexorgeminiinstalled starts offering them.
2026.11.5#
November 10, 2026 · This release on its own page
Documentation on every node, notifications and webhooks, suggested changes and reviews, and “merge” instead of “land”.
Documentation. Every node serves these docs at /docs, for its own version, with search, and this changelog at /changelog. Links in the docs to a repository’s pages open them in yours, and the command menu finds docs pages by title.
Notifications. The Inbox has an Activity tab for what happened to you: mentions, replies, new threads on your changes and requests, approvals, revisions, merges, agents finishing and assignments. The header’s Inbox shows a dot for unread activity, live. Each reason can be switched off in Settings → Account → Notifications. See Inbox and notifications.
Watching a repo. A Watch button in the repo header (off by default) notifies you of new changes, new requests and merges in that repo.
Webhooks. Repo Settings → Webhooks: hooks for changes, requests, comments, reviews, Bake-off recommendations and pushes, signed with HMAC-SHA256 and retried with backoff, with a log of recent deliveries and “Send again”. Private and internal addresses are refused unless the node runs with
--webhooks-allow-private. See Webhooks.Suggested changes and reviews. A line comment can carry replacement lines, and a writer applies one or several in a click, as a new revision of the change (and of the branch it tracks). Comments can be gathered into a review and submitted once, as a comment, an approval or a request for changes. Reviewer agents do the same over MCP (
submit_review, andsuggestiononadd_comment), and agents revising a change see the suggestions. See Reviewing.Runners install from the node.
curl -fsSL https://moruforge.com/install-runner.sh | sh. The node image carries its release’s runner archives and serves them at/download/runner/, so a self-hosted node installs runners of its own version from its own URL. “Add a runner” shows the command for your node. The script checks each download against its checksum before it installs it. New option:--runner-downloads(MORU_RUNNER_DOWNLOADS, set in the image). See Add a runner.New repos can start with a README. “Add a README” is on by default when you create a repository (
"readme": trueonPOST /api/v0/repos):mainstarts with one commit by you and gets the first branch’s protection. Agent work can no longer be started in a repo withoutmain; before, an agent did the whole task and failed only when it submitted.Assigning a person. Assigning someone to a request (yourself included) records it and notifies them, and works on an empty repo. The assignee pushes a branch and proposes it for the request; the propose form preselects requests assigned to you and offers a pre-review agent. Every revision of a change linked to a request is now pre-reviewed, including later pushes to its branch and to
refs/for/….Requests for any branch. A request can say which branch it merges into, under Merge into in the form (
"target"in the API). Agents start from that branch, and its changes merge into it. See Requests.Deleting repositories. Repo Settings ends in a Danger zone for admins: changing visibility asks first, and “Delete this repository” asks for the repo’s name. A deleted repo is gone at once but kept for 7 days: its owner, an owner of its organization or a site admin can restore it, with its requests, changes, discussions, collaborators and webhooks, from “Recently deleted” (account settings or the organization page) or with
moru-node restore-repo. Backups leave deleted repos out.“Merge”, not “land”. Everywhere: the UI, the node’s messages, the CLI, the API, events, webhooks and the stored history.
Fewer stuck tabs. A browser tab now shares one live connection to the node, and a tab hidden for a few seconds closes it and catches up when shown. Before, three tabs on plain HTTP could use up the browser’s connections and leave links hanging.
A new landing page that walks one example request from writing it to merging the change, and link previews: with the landing page on,
/has a title, description and image for Slack, X, LinkedIn and Discord, and the node serves/robots.txtand/sitemap.xml.Rules come along when you import a repository. Its protected branches, “approval from someone other than the author” and “only writers can comment” are taken from its access record where they’re stricter, and the default branch is protected, as in a new repository. People still wait until an admin applies the record. Applying a record now only tightens these rules: it adds protected branches and never removes or relaxes one. See Organizations and access.
Smaller things: repo Settings is a tab like the others, Enter in the last “done when” criterion adds another, a branch’s tree says whether it’s proposed or merged, the request form shows the right command to start a runner when none is online, an expired sign-in no longer sends you to the login page from public pages, and backups leave out temporary clones.
Upgrading#
- Breaking: “land” is now “merge” in the API, events, webhooks and stored history. Repos with changes or Bake-offs landed before this release no longer load. Clients calling
POST …/changes/{id}/landmust call…/merge. - Breaking (API):
POST …/scratchwithrequestis refused (400), and the request detail no longer hasattempts[].scratch. - The index is rebuilt on first start. Nothing to do.
- Installing a runner needs
sha256sumorshasumon the machine.
2026.11.4#
November 8, 2026 · This release on its own page
A new home at moruforge.com, a new look, and error pages that help.
moruforge.com. The AT Protocol binding record and its sign-in scope are now
com.moruforge.host.binding. New attestations sayhttps://moruforge.com/agent-run/v0.2; ones already in repos with the oldmoru.devtype still verify.New look. One palette in both themes, with an indigo accent, pill buttons and rounder corners.
Landing page. Walks one example request through Moru: agents working in sandboxes, reviewer agents ranking a Bake-off, the change page, a comment sent back for a new revision, and merging. Then a quick-start builder, what’s built in for production, GitHub, runners and identity, and an FAQ.
Error pages. A 404 can suggest the closest repository you can read, or search the ones you can. A 500 can retry by itself or show what the browser saw. “Copy details” includes a request ID.
Request IDs. Every response carries
x-request-id, and the node’s log lines for that request carry the same ID.
Upgrading#
- Breaking:
--source-url(MORU_SOURCE_URL) is gone. A node started with the flag refuses to start until it’s dropped; the environment variable is ignored.GET /api/v0/setupreturns"landing": true | falseinstead of{ "source_url": … } | null.
2026.11.3#
November 8, 2026 · This release on its own page
Finding your way, and sending agents back to fix things.
Revise with an agent. Send an agent back to a change to work through its open threads and the request’s conversation; it replies to each thread and submits a new revision. Offered on the change page, on a single agent’s card and in a Bake-off’s decision panel, where revising a candidate replaces the Bake-off.
One tab per concept. Every repo page shares a header with Overview, Requests, Changes and Code. Overview lists what needs you; Changes lists every change, with the request and attempt that made it.
Inbox. Everything waiting on you across all your repositories, at
/inboxand as a count in the header (GET /api/v0/attention).Command menu and shortcuts. ⌘K / Ctrl+K searches pages, repositories, changes and requests and runs commands.
?lists the shortcuts:gthen a letter to move between sections,j/kthrough lists,[/]between revisions. See Keyboard shortcuts.Comment drafts. Unsent comments, replies and edits survive navigating away and reloading.
Clearer feedback. Toasts confirm approving, merging and saving settings; in-app dialogs replace the browser’s confirmations; diffs show a placeholder while loading; a bar shows slow page loads; “5 minutes ago” stays current.
Landing page for nodes that offer Moru to the public:
MORU_LANDING=trueshows signed-out visitors a page introducing Moru, and public repositories move to/explore(on every node). Off by default.Smaller things: a “Not found” page that says which account you’re signed in with and offers to switch, signing in always returns to the page you were on, and every page has a title.
Upgrading#
- The index is rebuilt on first start. Nothing to do; a large node takes a little longer to start once.
- Breaking (API): the changes list takes
?origin=request|standaloneinstead of?loose=true, andGET …/countsno longer hasloose_changes./r/{owner}/{name}redirects to Overview or Code.
2026.11.2#
November 8, 2026 · This release on its own page
A daily driver for people.
Code browser. Browse a repo’s files at any branch, tag or commit, with syntax highlighting, rendered READMEs, a file tree, “Go to file” (
t), links to lines and raw URLs (/r/{owner}/{name}/raw/{path}?rev=).Discussions on changes, requests and commits. Line comments follow the code across revisions. Reply, edit (with the edit history), hide and resolve. A repo setting decides who may comment (
everyoneorwriters). Discussions are stored in git and move with the repo.Agents in discussions. Reviewer agents leave line comments, implementers reply to threads, and “Revise with an agent” on a change sends an agent back to address the open threads.
Changes proposed by people. Push a branch and propose it, or push to
refs/for/<branch>. Later pushes add revisions. Protected branches, and an optional “someone else must approve” rule, under Settings → Merging. See Changes.Preferences. Per-account settings on the node, starting with the diff layout.
Runner setup moved into
moru-runner register. The git check, the AppArmor profile offer and the sandbox check run there, before the one-time code is spent.install-runner.shonly downloads and unpacks.Images rebuilt weekly with fresh base packages (
YYYY.M.N-rYYYYMMDD, andlatest). See Upgrading.Smaller things: the clone URL includes your handle, a hint about using a token as the git password, a new repo opens its page, and clearer sign-in when the node has a waitlist.
Upgrading#
- Breaking: new repos protect the branch their first push creates; push other branches and propose them, or push to
refs/for/<branch>. Existing repos are unchanged until an admin turns protection on. Unlinking a GitHub-linked repo protects its default branch unless you uncheck it (or pass--no-protect). - Breaking:
MORU_RUNNER_NO_APPARMORis gone frominstall-runner.sh. Usemoru-runner register --sandbox dockerto skip the AppArmor offer. - The index is rebuilt from the repos on first start.
2026.11.1#
November 7, 2026 · This release on its own page
The first release: the node image at ghcr.io/webstonehq/moru-node and moru-runner binaries for Linux and macOS.