mrkeyoor.comAsk

KKKKhazix/agent-autolooptested 19 Nov 2026commit d1ec2d8

agent-autoloop review

Our npm install finished in 3 seconds, but tests hit the 900-second cap and the separate workflow attempt stopped at a missing-Compose safety check.

  • Safety failed
  • Tests timed out
3 sto install
  • 6 packages
Automationevaluationupdated 20 Nov 2026
+81 / 1dstars / 7d

Agent-autoloop is a local background service that routes schedules and incoming events to coding agents such as Claude Code, then resumes work after you answer a question. It's Chinese-first: English documentation exists, but the CLI and default notifications are still Chinese.

Verdict

Our npm install finished in 3 seconds, but tests hit the 900-second cap and the separate workflow attempt stopped at a missing-Compose safety check. Use agent-autoloop if you already run CLI agents and need events, schedules and saved human decisions in one local hub. Skip it if you need an English interface or expect approval cards to enforce permissions. Start with a local brief or draft-only triage, and keep long external waits out of growing agent conversations.

agent-autoloop infographic: routes work to coding agents and resumes after your answer, plus our test result and who it suits
Tested 19 November 2026: the source install took 3 s.

We ran it

Lab card: what happened when we ran agent-autoloop
Lab card from our sandbox run
Screenshot of agent-autoloop (github.com/KKKKhazix/agent-autoloop)
github.com/KKKKhazix/agent-autoloop
Install✓ · 3s6 packages · 44 MB
Buildn/ano build script
Tests✗ timed out · 900sran, no count parsed
Known vulns00 critical · 0 high · 0 moderate · 0 low (npm audit)
Repo264 files~32,724 lines of source · 1.8 MB · 2 CI workflows · tests dir

Answers from our run

Does agent-autoloop build from source?

Dependencies installed in 3 seconds (6 packages), and the project has no separate build step. We cloned commit d1ec2d8 into a clean Debian container with 3 CPUs and no project-specific setup.

Do agent-autoloop's tests pass?

We could not finish them: the suite was still running after 15 minutes in our container.

Does agent-autoloop have known vulnerabilities in its dependencies?

npm audit found none in the dependency tree at the time of our run.

Who should not use agent-autoloop?

Teams requiring an English CLI: command output and default notifications are still Chinese.

What are the alternatives to agent-autoloop?

Claude Code, OpenInterpreter, Zapier. Our npm install finished in 3 seconds, but tests hit the 900-second cap and the separate workflow attempt stopped at a missing-Compose safety check.

Setup4/5Our source checkout installed in 3 s with 6 dependencies, but we did not run a README task.Editor’s note: The source install succeeded in 3 seconds, but tests timed out and the workflow attempt stopped before agent work. Supported native setup quality is unassessed.
Docs4/5The README has an install command and usage examples in code; we did not run its quickstart ourselves, and the README is mostly in Chinese, not English.Editor’s note: We read English requirements, recipe boundaries and the Chinese security guidance. Documentation coverage is described here without assigning a separate numerical quality rating.
Community4/5Last push on 2026-11-20, 6,119 stars and maintainers answered or closed 10 of the 10 most-discussed issues we sampled.Editor’s note: The sampled issues show accepted contributions and deliberate feature refusals. They do not measure sustained adoption or support response quality.
Maturity2/5Latest release v1.9.4 on 2026-11-20, repository created 2026-11-03 and its test suite timed out in our sandbox.Editor’s note: Releases and issue fixes show ongoing work, while our partial suite and blocked workflow provide no production reliability assessment.

How we score

Who it’s for

Developers already using a signed-in CLI agent who want recurring work to wait for human decisions.
Operators who can write explicit follow-up rules and retain independent health monitoring.
Teams connecting business events to agent work who can maintain adapters and map answers back to originating event IDs.

Who it’s NOT for

Teams requiring an English CLI: command output and default notifications are still Chinese.
Operators treating approval cards as enforced authorization: askFirst is a prompt instruction, and actual restrictions depend on agent permissions and isolation.
Teams expecting a built-in generic Feishu-bot worker: the maintainer declined that adapter and recommends a replacement program script.
Android users seeking upstream support: the maintainer declined it despite a contributor's working local patches.

Setup reality

Our November 19 run at d1ec2d8 installed npm dependencies in 3 seconds, recording 6 dependencies and 44 MB on disk. The build was skipped because no script or target existed; tests timed out at 900 seconds. npm audit reported 0 known vulnerabilities. A separate November 20 workflow attempt stopped at the safety requirement for a Compose file, and teardown returned ok.

The README requires Node.js 24+, Git and a CLI agent already signed in; macOS and Linux also use curl. You configure rules.json with sources, agents, working folders and notification channels. The hub needs no model key of its own; the worker uses its agent's account. Text-channel answer links require a reachable hub.publicUrl.

Our sandbox configuration listed 3 CPUs, 8 GB RAM and lab-node:22. That image label alone doesn't identify the runtime or explain the timeout. Windows, macOS and Linux are supported; Android isn't. Expect Chinese terminal output even when following the English README, and review recipe timezones before enabling them.

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.

Alternatives

ProjectWhat it isPick it when
Claude Code gh↗The coding agent itself, with built-in scheduling discussed in GitTested’s comparison.Choose it for a one-off task or recurring Claude Code work that does not need routing across agents; GitTested recommends starting with its built-in scheduler for that narrower case.
OpenInterpreter gh↗An executing agent, distinguished from the dispatcher in SanShao Technology’s video.Consider it when you are choosing what performs the work. Agent-autoloop coordinates existing workers, so this is a different role rather than a measured replacement.
ZapierA hosted workflow alternative presented in BuildRun’s sponsored guide.Consider it when hosted service integrations are the priority and maintaining local routing is unwelcome; BuildRun’s positioning is not a comparative workload result.

What people are saying

  1. [velocity-scout] KKKKhazix/agent-autoloop

Sources

  1. Agent Autoloop: English README
  2. Agent Autoloop security boundaries
  3. GitTested: simulated incident handling and hub recovery
  4. Kartikay Dhar: mock-agent decision cards
  5. GitHub issue #268: long-session resumption costs
  6. GitHub issue #320: business event correlation
  7. GitHub issue #285: Antigravity on Windows
  8. Agent Autoloop v1.9.4 release

More automation reviews