← All reviews

agent-autoloop puts coding agents on a schedule

agent-autoloop automates coding agents on your computer, starting tasks from schedules or incoming events and saving questions for your decision.

A slate-blue pigeon in a teal headset presses a brass alarm bell in a busy fire station while the orange Claude mascot rests under an oversized blanket.
agent-autoloop lets Claude nap until the bell, and the bell rings only for the checks Claude booked.

A coding agent can do useful work while you are away, then need your decision before taking the next step. agent-autoloop is a local automation hub (a background service) that starts your existing command-line agent from schedules or incoming events. You supply task instructions; the hub saves questions and resumes the conversation when you answer.

Tested: commit c157aa2a8350ec2e799d5e66bb23a8e292ceec52 on November 10, 2026, on Linux with Claude Code (Anthropic’s coding agent). Workflow: investigate simulated service alerts, ask before restarting, check health after either answer, and recover saved records after hub crashes. Result: saved questions and answers survived repeated hub crashes, and each approved restart ran once. Refusals got a later health check only when the task rules asked for one after every answer. Verdict: adopt with care for scheduled and event-driven agent work.

Set up agent-autoloop with your coding agent

Paste this into your coding agent:

Install the latest agent-autoloop from https://github.com/KKKKhazix/agent-autoloop using its installation guide.
Run the `agent-autoloop try` command and help me answer its demonstration question.
Check that the conversation resumes and finishes before adding a low-risk scheduled task.

agent-autoloop needs your rules and integrations

A schedule or incoming alert starts an agent in a folder chosen by your rules. The agent can finish, ask a question, or request a later check. Questions and pending work live in a local database. The hub stays running while the agent process exits; answering starts another turn in the saved conversation. While a question waits, the agent makes no model requests.

You can inspect and answer questions in the terminal or through configured notification channels. The English README explains the workflow, but command output and default notifications are in Chinese, and the maintainer has declined an English interface for now. You keep your computer running and maintain the task rules and integrations. The project is MIT-licensed, with tagged releases and outside contributions. The README lists Windows, macOS and Linux support, and Codex (OpenAI’s coding agent) as well as Claude Code.

The project’s security guidance says that “ask first” is a prompt instruction. Actual restrictions come from the agent’s permissions and isolation. Use a separate system account or container when the agent must be kept away from secrets.

Users report steady long runs and some integration gotchas

One user’s migration report describes a 79-hour file migration using a separate background process and periodic checks. They report that the core event, question and resume loop worked steadily, but OpenClaw (another command-line agent) timed out repeatedly. agent-autoloop’s maintainer, KKKKhazix, recommends setting --timeout in the OpenClaw command to suit the work.

A developer integrating GitHub issues found that editing an issue or adding a comment failed to trigger new work: the hub ignores repeated event IDs, so the sending script must use a new ID for each change. Another user typed “just merge it” on a notice, which closed the card without waking the agent. The maintainer’s fix: when work needs your review before the agent continues, have the agent ask a question instead. A typed answer works there too and resumes the conversation.

Every answer and later check reloads the whole conversation. One user measured an overnight Codex session in which a check with nothing to do still read about 180,000 extra input tokens. For long waits on an outside service, the maintainer advises a scheduled script that sends a new event only on recovery, which starts a fresh conversation.

agent-autoloop keeps questions and answers through crashes

All 6,600 acknowledged events and answers survived 3,000 forced kills of the hub process, and waiting questions could still be answered. Each approved restart ran once.

Here is a real question Claude Code saved, translated from Chinese, with the note it wrote for its next turn (shortened). Notification cards show the question and options, not the note.

Catalog requests keep failing because the cache format is outdated.
A restart clears the old cache and should restore it, without affecting
the checkout service. Restart recommended.

Options: Restart | Leave unchanged

Note for the next turn: If approved, send the restart event, use later to
recheck in about one minute ... If refused, do not restart; say the
problem is still unresolved.

The agent must plan the check after a refusal

agent-autoloop runs the checks the agent requests and the rules you schedule; it adds none on its own. The note above plans a check only for approval, so choosing Leave unchanged ended with a report of the unresolved fault and no later check. That happened on each refusal when the task rules listed the check only among the approval steps.

When the rules asked for a check after every answer, Claude Code’s note scheduled one for the refusal as well. A few minutes later, that check found the fault had changed:

catalog health=unhealthy, restarts=0 (no restart, per operator's Leave
unchanged). Fault now reads upstream-outage on build b2, not the original
stale cache, so it is still broken and unresolved.

Ask for a later check after every answer

Adopt agent-autoloop with care for scheduled and event-driven agent work, if your task rules tell the agent to request a later check after every answer. For production incidents, keep independent health monitoring alongside it. If you only need recurring Claude Code tasks, start with its built-in scheduling; agent-autoloop adds event routing and coordination across different agents.