OpenClaw, the open-source AI assistant project, accumulated more than 7,000 open issues and pull requests by April 2026. Most maintainers in that position would either declare bug-tracker bankruptcy or hire a triage team. The OpenClaw maintainers built a bot instead. ClawSweeper now reviews every open issue and PR on a rolling schedule, drafts a Codex-authored close proposal when the evidence is strong, and applies those closes through a separate execution lane that only runs when the proposal is still valid.
It is also a case study in restraint. ClawSweeper does not auto-close on a hunch, never touches maintainer-authored items, and refuses to apply any change if the underlying review left junk in the working tree.
This guide walks through what ClawSweeper does, how the three lanes work together, the safety rules that keep it from closing things it should not, and the Codex configuration that powers each review. For background on the model doing the heavy lifting, see what is GPT-5.5.
TL;DR
- ClawSweeper is OpenClaw’s maintenance bot for
openclaw/openclaw, scanning roughly 7,000 open items on a rolling schedule. - Three lanes: a scheduler chooses what to review, the review lane drafts close proposals, the apply lane executes them every 15 minutes.
- Codex with
gpt-5.5, high reasoning, fast service tier, and a 10-minute per-item timeout writes the reviews. - Closes happen only for six narrow cases: implemented, not reproducible, duplicate, out-of-scope, incoherent, or stale older than 60 days.
- Maintainer-authored items, items with open referencing PRs, and protected labels are never auto-closed.
- The bot has closed 10,217 items via automation overall, but the most recent week shows a 0.1% close rate per review pass; it errs heavily toward leaving things open.
- License is MIT, the stack is TypeScript on Node 24 with pnpm, and operations run through a GitHub App.
The maintenance problem ClawSweeper solves
OpenClaw bills itself as “your own personal AI assistant. Any OS. Any platform. The lobster way.” That positioning attracted a wide community fast: 3,546 open issues and 3,457 open pull requests as of the most recent dashboard snapshot on April 27, 2026. Plenty of those items reference behaviour fixed three releases ago, duplicate older threads, or describe features now better suited to OpenClaw’s plugin and skill ecosystem than to the core repo.
Manual triage at that volume is not realistic. Closing the wrong thing is also expensive, because contributors who feel ignored stop contributing. ClawSweeper threads that needle by separating the deciding what to close step from the executing the close step, and by spending most of its energy on items where the answer is plainly duplicate or incoherent.
The three lanes
ClawSweeper splits into three independent processes. Each one logs to its own report directory and can be paused without affecting the others.
Scheduler
The scheduler decides which issues and PRs get reviewed and at what cadence. From the README: “New and active items get more attention; older quiet items fall back to a slower cadence.” In practice that means hot items every hour, items under 30 days old daily, and older issues weekly. The cadence is intentional. You want to revisit a fresh bug report often, in case more evidence arrives, and an ancient one rarely, because the answer is unlikely to change.
Review lane
The review lane is where Codex earns its keep. ClawSweeper picks an item, builds a context shard with the title, body, comments, and a snapshot of repo state on main, then hands the shard to Codex. Codex returns a structured markdown report with one of three verdicts: keep open, close because X, or insufficient evidence. The README is blunt about scope: “Review is proposal-only. It never closes items.”
The reports live in items/ until the apply lane consumes them, and that gives the system its safety property. A human can read every proposed close in the repo before it lands.
Apply lane
Apply runs every 15 minutes. It walks items/, pulls the most recent report for each open issue or PR, and re-validates the proposal: is the report still consistent with the live state of the issue (no new comments, no maintainer label, no referencing PR opened in the last hour), and is it fresh enough to act on? If yes, apply lane closes the item, posts the Codex-authored explanation as a comment, and moves the report to closed/. If anything has shifted, the report is discarded and the scheduler reconsiders the item next pass.
This split is the single most important design choice in the project. Codex never touches GitHub directly, and the apply lane never reasons about close worthiness; it enforces the proposal under fresh conditions.
The close rules
ClawSweeper proposes closures only for items that fall into one of six narrow buckets, taken straight from the README:
- “implemented on current
main” - “not reproducible on current
main” - “duplicate or superseded by a canonical issue/PR”
- “concrete but not actionable in this source repo” (better suited for ClawHub skill or plugin work)
- “incoherent enough that no action can be taken”
- “stale issue older than 60 days with too little data to verify”
Every other situation, including reproducible bugs, valid feature requests, partial repros, and real but un-prioritised work, keeps the item open. The 0.1% close rate on the most recent review pass (4 proposed closes across 3,478 reviewed issues) tells you how aggressively the prompt avoids false positives.
A few protections layer on top of the close rules:
- Maintainer-authored items are never closed. If a maintainer files an issue, the bot leaves it alone regardless of staleness.
- Open referencing PRs block close. If issue #4321 has an open PR with
Closes #4321in the body, ClawSweeper waits. - Protected labels skip the bot entirely. Tag an issue
keep-open(or whatever label list the maintainers configure) and the scheduler skips it.
Codex configuration
The Codex setup is the part most worth borrowing for any team building their own automation:
Codex reviews with gpt-5.5, high reasoning, fast service tier, and a 10-minute per-item timeout.A few details matter here. High reasoning mode catches the dupes that look obvious to a human after twenty seconds but require chasing five linked threads to verify. The fast service tier keeps cost predictable on a 7,000-item backlog. The 10-minute timeout is a hard kill, not a warning; an item that takes longer is dropped for the next pass rather than blocking the queue.
The Codex environment also runs without GitHub write tokens. The README puts it plainly: “Reviews fail if Codex leaves tracked or untracked changes behind.” That forces the reviewer to behave like a read-only analyst; any side effect is a bug, not a feature.
If you want to use the same model interactively before wiring it into a bot, the Codex CLI is the easiest free path to GPT-5.5. For a cost model on programmatic API access, see the GPT-5.5 pricing breakdown and the GPT-5.5 API usage guide.
Local setup
Cloning ClawSweeper and running it locally is straightforward. The repo expects Node 24 and pnpm via corepack:
git clone https://github.com/openclaw/clawsweeper.git
cd clawsweeper
source ~/.profile
corepack enable
pnpm install
pnpm run build
A few secrets need to be present before the lanes will start:
OPENAI_API_KEY: authenticates Codex for the review lane.CLAWSWEEPER_APP_ID: GitHub App ID (3306130 for the production install).CLAWSWEEPER_APP_PRIVATE_KEY: the private key used to mint short-lived installation tokens.OPENCLAW_GH_TOKEN: optional, falls back to a personal access token when the App route fails.
You can run the review lane against any repo you own. The apply lane intentionally limits itself to openclaw/openclaw write operations unless you reconfigure the GitHub App permissions.
For teams that prefer a paid API key but want the same Codex behaviour, the free GPT-5.5 paths outline alternatives that route through trial credits or aggregator gateways.
Dashboard snapshot
The README ships a public dashboard that updates every apply pass. As of the most recent snapshot:
- 7,003 total open items (3,546 issues + 3,457 PRs)
- 3,478 issues reviewed in the last 7 days
- 4 proposed issue closes (0.1% of reviewed)
- 10,217 total items closed by automation since launch
The 0.1% number is the tell. ClawSweeper is not optimising for issue inbox zero; it is optimising for “never close something a contributor would defend if asked.” Across 10,000-plus closures, that conservative posture is what kept the project credible enough that contributors kept opening new issues.
Why this matters for API teams
Most API products on GitHub follow the same arc as OpenClaw. The SDK or the spec lives in a public repo, the issue tracker fills with mixed bug reports and feature requests, and triage falls behind. If you publish an OpenAPI spec out of Apidog and accept community contributions in GitHub, the ClawSweeper architecture is portable. The valuable parts are not the prompts, since those are tied to OpenClaw’s domain. The valuable parts are the lane separation, the hard close rules, and the policy of running Codex without write access.
You can stage the same approach in three steps:
- Run a Codex-driven review job on a sample of your tracker. Have it produce markdown reports without committing anything.
- Layer in the safety rules: never close maintainer items, respect protected labels, defer to open PRs.
- Add an apply lane only when the review reports look right when read by hand. Wire it to close at most a handful per day until trust builds.
If you are validating the API surface those issues describe, Apidog handles the contract side. The same OpenAPI document drives mock servers, automated tests, and the docs your contributors read before filing a bug. Pairing a triage bot with a tightly-versioned spec usually cuts the duplicate-issue rate by half before the bot ever runs. Download Apidog if you want to start with the spec discipline.
Limits and design trade-offs
A few things ClawSweeper deliberately does not do:
- It does not write code. No PRs, no patches, no review comments suggesting fixes. That work belongs to other OpenClaw bots.
- It does not reason about priority. Closing is binary; nothing gets “deprioritised” or labelled by the bot.
- It does not learn from past closes. Each review starts fresh against
main. Earlier decisions show up only as historical reports underclosed/, not as fine-tuning data.
These trade-offs are why the bot stays predictable. They also leave room for adjacent automation, like a labeller bot, a stale-PR pinger, or a release-note drafter, without stepping on ClawSweeper’s narrow remit.
FAQ
How often does ClawSweeper close issues automatically?The apply lane runs every 15 minutes, but most cycles produce zero closes. The 0.1% per-review close rate on April 27, 2026 means roughly 4 closes against 3,478 reviewed issues over a week. For background on the model behind the reviews, see what is GPT-5.5.
Can I run ClawSweeper on my own repo?Yes. Clone the repo, configure your own GitHub App with read/write access on the target, and point CLAWSWEEPER_APP_ID and CLAWSWEEPER_APP_PRIVATE_KEY at it. Reviewing other people’s repos is read-only by default.
Does ClawSweeper require a paid OpenAI plan?The review lane authenticates via OPENAI_API_KEY, which is a paid API credential. If you only want to run reviews interactively rather than at scale, the Codex CLI on a free ChatGPT plan works.
What stops Codex from closing real bugs?Three things. The narrow close rule list, the maintainer and protected-label exclusions, and the apply lane’s re-validation step that throws away any proposal where the underlying issue has changed since review.
Is ClawSweeper open source?Yes, MIT-licensed, with source on GitHub at openclaw/clawsweeper. The parent project OpenClaw is a separate repo with its own contributing guide.
