Short answer: use it for recurring work with a human decision
Our source install took 3 seconds, but the tests timed out at 900 seconds. Use agent-autoloop if you already run a coding agent and want scheduled or incoming work to stop at a question, then continue after your answer. Skip it if you need an English interface or expect an approval card to enforce what the agent can do: the CLI is Chinese, and the project's security guidance puts enforcement in permissions and isolation. The source-run results, language warning and security guidance support those boundaries.
Agent-autoloop is a local dispatcher for existing command-line agents, rather than a model you talk to. Its useful promise is that your decision can arrive later without leaving an agent process waiting. Whether the next round is cheap depends on the conversation it resumes. That distinction should govern your first task, your cost controls and how much access you give it.
What people use agent-autoloop for
Independent reviewers have exercised both real Claude Code incident handling and model-free decision cards, with different levels of evidence behind each result. These are the examples worth reading before adapting a recipe:
| Who used it | What they did | What happened |
|---|---|---|
| GitTested reviewer Kahtaf Alam | Investigated simulated service alerts with Claude Code and asked before restarting | Reported that 6,600 acknowledged events and answers survived 3,000 forced hub kills; each approved restart ran once. His incident review also records the refusal problem described below. |
| Kartikay Dhar, writing on his personal blog | Used mock shell agents for decision cards and lead triage, without a model | Reported a card arriving in 2,148 ms, no waiting agent processes, and resumption after answering. The mock's final result said it drafted locally and sent nothing. His walkthrough distinguishes the mock from a real sales workflow. |
| GitHub user xiaojian94xiaojian | Ran the demonstration and service commands under Windows 10 with WSL2 and Ubuntu | Reported a working two-round loop, but no Windows desktop notifications, expired agent logins and a service PATH that needed an absolute Node path. The Windows discussion preserves those details. |
| Contributor shilefumaoqu, acknowledged by the maintainer | Connected Antigravity through ACP, the Agent Client Protocol used to connect agent programs | Completed the demonstration twice on Windows. The maintainer recorded working multi-turn questions and session resumption with agy 1.5.5 in issue #285. |
Alam's refusal case is more useful than a successful restart alone. When the instructions placed a later health check only under approval, refusing the restart ended the investigation with an unresolved-fault report. Rewriting the task to require a check after every answer produced the missing follow-up. The hub ran the checks the agent requested; it didn't invent an incident policy. Keep independent health monitoring when you use this pattern for operations, as GitTested recommends.
What happened when we ran it
Our November 20 workflow attempt stopped at the safety check because no Compose file existed. The exact error was: unsafe repo: none of compose.yaml, compose.yml, docker-compose.yaml, docker-compose.yml exists (rule: a compose file is required). The failed safety step is the outcome that controls our workflow conclusion.
The November 20 run summary describes a deployment using the project's own Docker Compose with ports bound to 127.0.0.1. That broad description conflicts with the concrete safety failure. We cannot treat it as evidence of a working deployment. The teardown returned ok. Requiring Compose was a constraint of this lab route, while the README describes a native background service.
The separate source run on November 19 cloned commit d1ec2d8 and reached dependency installation and tests. The sandbox configuration recorded 3 CPUs, 8 GB of RAM and image label lab-node:22.
| Source-run step or observation | Our recorded result |
|---|---|
| npm install | Succeeded in 3 seconds; 6 dependencies recorded, 44 MB on disk |
| Build | Skipped because there was no build script or target |
| Tests | Timed out after 900 seconds |
| npm audit | 0 known vulnerabilities: 0 critical, high, moderate or low |
| Checkout | 264 files, approximately 32,724 source lines, 1.8 MB |
| Repository signals | 2 CI workflow files, a tests directory and no Dockerfile |
These are our sandbox observations, rather than timings borrowed from the README. Installation was quick. The test command did not finish within the cap, so it earned no passing-suite result.
The tail shows successful checks for user-level service restarts, service readiness, literal spaces and special characters in systemd paths, rejection of control characters, and session-usage baselines. One Mac/systemd case was skipped. It then prints a simulation summary with seed 24301, steps:200000, completed:16510 and ms:388792.480461. Those are simulation fields, not a count of passing tests. The test tail gives no basis for choosing between a slow remaining workload and some other reason the overall command exceeded its limit.
Where people get stuck: answers, notices and business IDs differ
Typing into a notice can close it without resuming the agent; an ask card is the route for a decision that should continue work. That distinction caused a user to type "just merge it" without waking the agent in GitTested's account. If your workflow ends at a review step, choosing the wrong card type can make a healthy dispatcher look inactive.
| Symptom and reporter | What to change | Resolution recorded |
|---|---|---|
| In issue #226, a Feishu user could click an option but couldn't send the extra words the agent needed | Use the question card's text box and text-submit action on a version containing PR #228 | The maintainer said PR #228 was merged and would ship in the next version; questions still require two to five options. Feishu report. |
In issue #320, the original business ID became card:37 in the answer round |
Read originating IDs from context.answers[].events; keep context.events for the current answer event |
PR #329 was merged, with release described as forthcoming in that thread. Correlation report. |
| A GitHub integration described by GitTested failed to start work on edits or comments | Give each change a fresh event ID | Repeated IDs are ignored; reusing the issue's ID for every change suppressed new work. Integration account. |
| The migration report summarized by GitTested hit repeated OpenClaw timeouts | Set OpenClaw's --timeout for the task; 0 removes that tool's limit |
The README documents a default limit of 600 seconds for agent exec. OpenClaw guidance. |
Each answer can carry the IDs of the events that prompted the question, including chains of questions. Your first event can carry custom-id-1, while the answer is a new event of its own. The result processor should use the answer's originating-event list to associate the result with your business object. Replacing that with an assumption that context.events[0].id is always your original ID recreates the integration error. Contributor argszero explains this distinction in issue #320; the list is empty for a question that didn't originate in a round.
There is a later wrinkle. Release v1.9.4, published November 20, says an answer to a question asked during a scheduled check now retains the source event ID instead of timer:N. That release is later evidence than the original issue's promise of a forthcoming fix. Our source run remains tied to d1ec2d8.
Long conversations hurt when they resume
A user in issue #268 reported that an otherwise idle Codex round reread an additional 180,000 to 190,000 input tokens because it resumed a long conversation. Waiting and resuming are separate costs. In that report, the expensive rounds included checks that found an external service still unavailable, and even rounds with nothing to do. Those are the reporter's token figures, not our cost benchmark.
The maintainer kept the rule that answers and scheduled rechecks return to their originating conversation, declined a resumeWithin limit, and merged guidance in PR #272. For a long external wait, a command rule should run a script periodically and emit a fresh event only when the service recovers. A receiving rule without resume then starts a new conversation. Reserve later for a follow-up that actually benefits from the conversation already in progress, as the maintainer explains in #268.
A separate user asked for a numeric round cap after feedback conversations accumulated dozens of rounds. The maintainer closed issue #325 by referring to #327. That closure is not an implementation announcement. For your first recurring task, prefer a bounded output such as a local daily brief over a thread expected to remember every feedback item forever.
Approval cards rely on the agent's instructions
The security document says askFirst is a prompt instruction, and the hub cannot stop an agent that ignores it. Permissions and the agent's own sandbox provide the restrictions. The same guidance says a generic command adapter doesn't constrain an arbitrary program, and ordinary read access doesn't mean the agent cannot read machine credentials. Use a separate system account or container when those credentials must be out of reach, following the project's stated security boundaries.
Separating event text from the prompt doesn't fully prevent prompt injection. Dhar put an instruction to email a CEO into an event summary: it stayed out of the mock prompts and appeared in the context data file. An actual model reading that file would still encounter it. His model-free experiment demonstrates placement of the text, rather than resistance by a model. The security document explicitly acknowledges this remaining route.
The current security guidance also warns against adding the hub's MCP server, the interface assistants use to call its tools, to the user-level configuration of a CLI the worker launches: a round could answer its own card. Card links authorize whoever holds them to answer that card. Keep those links private and expose a remotely reachable hub behind HTTPS, as SECURITY.md directs.
English docs don't make the CLI English
The English README says command output and default notifications are still Chinese, and its English terminal examples are translations. Dhar independently reported Chinese doctor, status, cards and notifications in his v1.1.1 walkthrough. For an English-speaking operator, this affects the failure messages you need to understand, not just onboarding copy.
The README also labels recipe instructions as Chinese. Several business recipes default to Asia/Shanghai and the owner's private Feishu chat. Change the timezone and destinations when adapting them for another region. A ready-made inbox-triage recipe writes local reply drafts without sending or changing the mailbox; that makes it a more sensible first delegation than a recipe whose normal outcome is a merge or deployment.
Native Windows works; integrations need individual checks
Windows is a supported platform in the current README, alongside macOS and Linux. The older WSL2 reports remain useful for service PATH and desktop-notification problems, but they no longer define the platform limit. The Antigravity result in issue #285 is particularly concrete: the maintainer acknowledged two complete demonstration loops on Windows and merged the documentation. Connect it through use: "acp" with ["agy", "acp"]; model and effort settings belong in Antigravity itself.
An existing chat bot can also be the worker, but that requires a bridge you own. The team in issue #323 reported a working replacement program script that imitated the DSH CLI and collected the bot's answer through a local file. The maintainer declined a generic built-in Feishu-bot adapter because different bots expose completion and replies differently. A working bridge for one bot framework isn't a universal adapter.
Stopping the hub is also different from cancelling an agent. The host implementation says active agents are detached and left running when it stops; the worker can find them again after returning. If you are trying to halt a sensitive action, shutting down the dispatcher alone is the wrong operation.
agent-autoloop vs Claude Code scheduling, OpenInterpreter and Zapier
For recurring Claude Code tasks alone, GitTested recommends starting with Claude Code's built-in scheduling; agent-autoloop adds event routing and coordination across agents. The choice is whether you need that extra dispatch layer, as Alam's comparison explains.
| Option | Choose it for | Basis for the comparison |
|---|---|---|
| Claude Code directly or its built-in scheduling | A one-off coding task, or recurring work that stays within Claude Code | GitTested recommends its scheduler for the narrower case. SanShao Technology considers direct use faster for one-off tasks. Incident review, video explanation. |
| agent-autoloop | Events or schedules that route work to existing agents and resume after human answers | The README documents configurable sources, agents and cards. Project workflow. |
| OpenInterpreter | The program doing the work, when that is what you need to choose | SanShao Technology distinguishes an executing agent from agent-autoloop's dispatcher role. These roles can coexist. Video comparison. |
| Zapier | Hosted workflows across services when you'd rather use a hosted integration layer | BuildRun presents this alternative in a guide with sponsored links; it reports no migration or comparative workload. BuildRun guide. |
SanShao Technology's video uses an imagined overnight website incident to explain the approval loop. Treat that as an explanation, while Alam's simulated incident and Dhar's mock-agent run are reported executions. The distinction matters when a polished walkthrough makes an unexercised scenario look proven.
What the other reviews get wrong
BuildRun's guide still says Windows support is pending, despite its November 19 update label; the current README lists Windows. ToolPilot's tutorial goes further than the security document when it suggests a compromised or confused agent cannot quietly escalate. An approval question is a requested behavior. The Windows support statement and security boundaries are the better references for those decisions than BuildRun or ToolPilot.
SanShao Technology calls the rules file workflows.json; the README specifies ~/.agent-autoloop/rules.json. Heatdrop's feature leads with a 1,651-line kernel, while Dhar counted 1,772 TypeScript lines under src/kernel at commit 22312e1 and noted the older README figure. A line count needs a commit and counting method. Follow the documented configuration path, rather than the video's filename, and read Dhar's snapshot explanation alongside Heatdrop's headline.
"Zero-cost waiting" also needs a noun: the waiting agent exits and makes no model requests, but the hub remains alive. Dhar explicitly distinguishes those processes. A post by stepeee_en on X repeats the zero-token waiting claim; it supplies no measurement of resumed conversations. That is consistent with a long conversation costing tokens when it wakes, as Dhar's process check, the X post and issue #268 illustrate.
Search the full name KKKKhazix/agent-autoloop. Kore.ai's Autoloop, mrauter1/autoloop, armgabrielyan/autoloop and the Autoloop failure in githubnext/tsb identify other products or repositories. Their results aren't evidence about this hub: the Kore.ai announcement, mrauter1 repository, armgabrielyan repository and tsb issue identify the entities separately.
Questions people ask
Yes, agent-autoloop can keep work independent of an open terminal when its background service and computer remain running; the hub stores questions for later answers, as the README describes.
Does agent-autoloop keep tasks running after I close the terminal?
Yes, with the background service running on an awake computer. Questions persist while the agent exits, and answering starts another turn. Stopping the hub leaves active detached agents running, according to the host implementation; it isn't an agent-cancellation command.
Where do agent-autoloop's tasks come from?
Tasks come from configured schedules and event sources, including GitHub and GitLab webhooks, an HTTP API and issue polling. Your rules choose the agent and working folder. The README's source list describes those inputs; the hub doesn't discover an agenda by itself.
What should I delegate to agent-autoloop first?
Start with a local morning brief or inbox triage that drafts without sending. Those are documented recipes, and the inbox recipe description explicitly excludes sending or modifying mail. Run the demonstration question-and-answer loop before connecting a real source.
Who is agent-autoloop useful for?
It suits people already using CLI agents who need recurring or incoming work to continue around human decisions. SanShao Technology recommends the pattern for repeated tasks containing approval steps and considers direct Claude Code use faster for a one-off job in the setup video.
Can an unattended agent go rogue despite the approval cards?
Yes. The security document says the hub cannot enforce askFirst if an agent ignores that prompt instruction. Restrict the agent's actual permissions and isolate secrets using the documented security boundaries.
Does agent-autoloop need its own model or API key?
The hub itself needs neither a model nor a model API key. Real workers use the login or key of their own CLI agent. Dhar demonstrated the hub with mock shell scripts and no model in his decision-card walkthrough.
Which Node.js version does agent-autoloop require?
The README requires Node.js 24 or newer, plus Git and an agent already signed in; macOS and Linux also use curl. The requirements apply to adoption, regardless of the image label recorded by our source harness.
Is agent-autoloop's CLI available in English?
The README says CLI output and default notifications are still Chinese. English documentation exists, but its English command-output examples are translations. Both that language warning and Dhar's observed output make the distinction explicit.
Does separating event data from prompts fully prevent prompt injection?
No. The agent still reads the external text in its context data file. Dhar's mock experiment showed where the string landed, and SECURITY.md says the split doesn't stop all prompt injection.
Can I run agent-autoloop natively on Windows?
Yes. The current README lists native Windows support and a PowerShell installer. WSL2 is an alternative route, not a requirement. Antigravity's multi-turn loop and resumption were also reported working on Windows in issue #285.
Can agent-autoloop run on Android despite its POSIX process assumptions?
A user named Verchiel666 reported working real-device loops with local patches, but the maintainer explicitly declined upstream Android support. The Android discussion documents altered process-command behavior and unsupported sandbox conditions. Choose a listed platform for a supported deployment.
How can I send a free-text answer through a Feishu question card?
PR #228 added a multiline text box below the options and a text-submit action. The maintainer said it was merged for the next version in issue #226. Questions still require two to five options; the text field supplies an additional answer path.
What we have not tested yet
Our completed work consists of the November 19 source installation and partial test execution; the November 20 workflow attempt stopped at the Compose safety requirement. We have no measured agent task, known-answer result, live notification delivery, workflow latency or hub memory result from that attempt. There are no screenshots or question-and-answer records from it. The image label alone doesn't establish the actual Node.js or operating-system version, so the timeout cannot be blamed on a runtime mismatch without the raw toolchain logs.
The README says Feishu delivery and callbacks have been exercised, while the four other webhook-channel templates have only local mock-server checks and GitLab's webhook has documentation-payload checks. The business recipes also describe fictional sample data and fake-CLI checks. Those are upstream coverage boundaries, not our live-account results. We have not reproduced Windows, Android patches, Antigravity, the bot bridge or the newer correlation fixes, and we have no same-workload comparison with the alternatives.
Stars and rapid releases don't establish sustained adoption. GitHub records a November 20 push and the v1.9.4 release that day, while the sampled issues show both accepted contributions and deliberately declined features. That is evidence of ongoing work, not a support guarantee. The next useful run is a native, supported installation that completes one bounded task, waits for an answer and resumes, with the actual runtime and agent permissions recorded.


