ClawQueueClawQueueLOCAL · OPERATOR · v0
GitHub issues in · agent work out

Turn GitHub Issues into a local agent queue.

ClawQueue keeps GitHub Issues and Projects as the durable work contract, then uses a local scheduler to pick eligible work, launch the right agent mode, and report results back to the issue.

Get StartedRead the Docs
●Local-first●GitHub-native●Markdown-configurable●PR-reviewable
ClawQueue claw with queue dial
Issue#128 · refactor scheduler
Labelagent:fixrouted
Modecode-review
StatusPR opened ✓
01GitHub holds the contractIssues, labels, projects, comments, branches, PRs.
02Your machine runs the workersOpenClaw, Claude Code, Codex, or other local runners.
03Humans review the workOutput returns as comments, artifacts, and PR-ready changes.
How it works

Issue-driven agent work — without losing the thread

Every tick of the scheduler resolves a single eligible issue, runs a configured local backend, and writes the result back where humans can audit it.

01IssueA task lands in GitHub Issues or Projects.
02SchedulerCQ checks status, locks, attempts and policy.
03Agent ModeLabels resolve to the right mode + role.
04Local RunnerOpenClaw, Codex, Claude Code — your choice.
05Comment / PRResult returns to the issue, ready to review.
$ python3 scripts/scheduler.py
[pick] eligible issue in Todo
[route] labels → mode + agent
[run] local backend started
[report] comment + artifact + PR link ✓
Why local-first

Small surface. Inspectable policy. Reviewable output.

ClawQueue is intentionally a thin dispatch layer — not a hosted workflow suite — so you can read it, audit it, and modify it.

⌂

Private by default

Secrets and runtime context stay on your machine.

⇄

No vendor lock-in

Swap runners without losing the task contract.

≡

Inspectable policy

Routing and behavior live in markdown/config you can patch fast.

✓

Reviewable output

Final state stays in GitHub where humans can judge it.

Use it for

Your own projects, or contributions through a fork

◴

Operate your own queue

Run CQ against your own repos, boards, profiles, and worklog. Keep product, engineering, ops, and review inside one GitHub-native loop.

↗

Contribute through a fork

Use the same issue-driven flow for outside projects. Shape work into issues on your fork, dispatch locally, then open a cleaner upstream PR.

Minimal config

One yaml. One operator. One queue.

Keep dispatch policy, routing, and artifact destinations in a tiny, readable file. Patch it the way you'd patch any markdown.

See full config →
# clawqueue.yml
projects:
  - repo: your-org/your-repo
    dispatch_statuses: [Todo]
routing:
  agent_roles:
    cto: cto
    cmo: cmo
    reviewer: reviewer
artifacts:
  backend: local
  path: .clawqueue/boards
  commit: false
Honest scope

What ClawQueue is — and what it isn't

ClawQueue is yes

  • A local GitHub issue dispatcher
  • A way to turn labels into agent modes
  • A reviewable workflow for human-agent work
  • A small layer you can read and modify

ClawQueue is not no

  • A hosted PM suite
  • A magical autonomous company in a box
  • A secure multi-tenant executor
  • A replacement for human review

Put your GitHub issues to work. Locally.

Start with the docs, wire up one board, and let CQ pick one safe issue at a time.

Get StartedRead the WorkflowView GitHub