Moadim: an open-source loop engine that runs AI agents on a schedule against your repos

What Moadim is

Moadim, which appeared on the Hacker News front page via a Show HN post, is an open-source scheduler built around one idea: AI agents should be able to run against a repository on a recurring basis rather than only when a human types a prompt. According to the project's site, a loop in Moadim combines three elements — the prompt, the schedule, and the agent to run — and the engine executes that loop every time the schedule fires.

The supported agent list currently covers Claude, Codex, Hermes, Pi and NanoClaw. Four of them run directly inside what Moadim calls an isolated workbench; NanoClaw is handled differently, with Moadim queuing a one-shot task in that agent's configured group instead.

Local-first by design

The daemon starts in the background on localhost port 5784 after installation via cargo or a global npm install. It requires a Unix-like system with tmux available on the PATH: the scheduler is an in-process component of the daemon itself, and each agent launch happens inside a tmux session, so no host cron daemon is needed. To keep loops running across logins and reboots, moadim install registers a launchd service on macOS or a systemd unit on Linux.

One detail from the FAQ: the built-in Claude agent also expects python3 on the PATH, which Moadim uses to pre-seed unattended trust and MCP-approval state.

Every loop is an API

Moadim exposes its loops through three surfaces. Every loop is a documented HTTP endpoint, with an OpenAPI schema and Swagger UI served by the daemon itself; listing them is a single REST call to /api/v1/routines. The same operation is available as an MCP tool named list_routines, callable by any MCP-compatible agent connected to the daemon's /mcp endpoint. A web UI and an iCal feed round out the interfaces, the latter letting you subscribe to a loop's schedule from a calendar client.

Run isolation

Each tick of a loop starts the agent in a fresh, isolated workbench, and a watchdog terminates runs that hang and cleans up the session once it finishes — the stated goal being that one run cannot leak state into the next. That is the kind of guardrail that matters when software writes code unattended.

The project is MIT-licensed, with no paid tier and no account creation, and everything runs on the user's own machine: no cloud queue and no sign-up, per the FAQ. The site also leans on the term loop engineering, linking to third-party commentary arguing that orchestrating agents on recurring schedules is becoming a discipline of its own, distinct from prompting.

Why it matters

Most agent tooling today assumes a conversational, one-shot workflow: open a session, make a request, review the diff. Moadim points at a different model — agents as scheduled background workers that touch a codebase on a cadence, closer to cron for coding agents than to a chat window. Making that model credible requires exactly the plumbing Moadim tries to bundle: isolation between runs, a watchdog for stuck processes, persistence across reboots, and machine-readable interfaces so other tools — or other agents, via MCP — can inspect what is scheduled and when it last ran.

The claims here come from the project's own documentation, so they should be read as the developer's description rather than independently verified behaviour. But as a self-hosted, permissively licensed building block for recurring agent work, Moadim is a concrete example of where orchestration tooling appears to be heading: away from hand-run prompting and toward durable, observable, scheduled agent loops.