amux for Open-Source Maintainers

Q: How does amux generate changelogs?

The agent runs git log --oneline since the last release tag, categorizes commits by type (feat/fix/chore/docs), groups them semantically, and drafts a CHANGELOG.md entry or release notes page in your project's format. You specify the format and style in CLAUDE.md. The agent handles the reading and sorting; you do a final editorial pass before publishing. This works best with conventional commits (feat/fix/chore) since they give the agent explicit signals.

Q: Does amux work for projects with hundreds of issues?

Yes — this is exactly the use case it was designed for. You can run one agent per batch of issues overnight. For a backlog of 200 open issues, queue them in batches of 20-30 per agent session. Agents read in parallel and draft responses independently, sharing a kanban board so no issue is touched twice. A 200-issue triage backlog that would take a maintainer 3 days can often be drafted in one overnight run.

Run AI agents overnight to triage issues, review contributor PRs, generate release notes, and keep documentation current — so you can stay ahead of a growing project without burning out. Updated July 2026.

amux is an open-source control plane for AI coding agents. It launches, coordinates, and self-heals dozens of parallel Claude Code, Codex CLI, or Gemini CLI sessions from a single web dashboard. For open-source maintainers, this means one dashboard showing every maintenance task in progress — issue triage, PR review, doc updates, changelog generation — all running overnight while you sleep.

The open-source maintainer backlog problem

As a project grows, the maintainer's job shifts. Less coding, more reading: reading 30 new issues to figure out which are duplicates, which need more info, which are real bugs. Reading contributor PRs to check if they follow conventions before you spend time on a review. Reading git history to write release notes. Reading old documentation to find what needs updating.

Most of this reading-and-drafting work doesn't require your judgment — it requires your context. The maintainer's advantage is knowing the project: the conventions, the gotchas, the prior decisions. That context lives in the codebase and in your CLAUDE.md. An agent with that context can do most of the reading and drafting overnight, so your time goes to final decisions — approve, request changes, merge, close — not to the mechanical first pass.

Issue triage overnight

The most time-consuming part of issue triage is the reading: reading each issue, checking if it's a duplicate, determining if there's enough context to reproduce, categorizing it, and drafting a first response. An agent can do this for 50 issues while you sleep.

# In your project CLAUDE.md, specify the triage rules:
# - Bug: assign label "bug", check for reproduction steps, if missing ask for them
# - Feature: assign label "enhancement", compare against roadmap in ROADMAP.md
# - Question: assign label "question", search existing docs for an answer
# - Duplicate: link to the original issue, close with a note

# On the amux board, queue issues as tasks
amux board add "Triage GH issues #450-#480 — see CLAUDE.md for rules"

# Agent runs overnight and produces a Markdown report:
# Issue #451: Bug (missing repro steps — drafted request for steps)
# Issue #452: Duplicate of #391 — drafted close comment
# Issue #453: Feature (added to backlog.md)
# ...

# You wake up, review the draft comments, approve and post

The agent works from your CLAUDE.md context: your project's issue templates, common duplicate issues, the difference between bugs and misconfigurations, which features are out of scope, and how you like to communicate with contributors. A well-written CLAUDE.md makes the agent's output directly usable with minimal editing.

Contributor PR review drafts

Reviewing contributor PRs is the highest-leverage maintenance task — and the most time-consuming when a project grows. You can't merge without reviewing; you can't review 20 PRs a day and also write code. An agent can do the mechanical first pass: checking coding conventions, spotting missing tests, identifying breaking changes without migration notes, and flagging patterns that don't match the codebase.

# Queue contributor PRs for overnight review
amux board add "Draft review for PR #512 — check conventions, test coverage, breaking changes"
amux board add "Draft review for PR #514 — new API endpoint, check error handling"
amux board add "Draft review for PR #516 — performance fix, check benchmark comparison"

# Agent produces a structured review draft:
# PR #512: 3 issues — missing docstring on new public method; test for edge case not present;
#   import ordering doesn't follow project convention (see CLAUDE.md §imports)
#   Draft review comment: [...]

# You review the draft, add your judgment, post

The agent is strongest at mechanical convention checks (did they follow your style guide? did they add tests? is there a CHANGELOG entry?). Your judgment is needed for architectural decisions and contribution acceptance. The split is usually 80% mechanical / 20% judgment — and agents handle the 80%.

Changelog and release notes generation

Writing release notes is the task most maintainers put off longest. It requires reading all commits since the last release, categorizing them, and writing human-readable summaries. An agent with git access and your CHANGELOG format in CLAUDE.md can draft a full release entry overnight.

# Queue a changelog generation task
amux board add "Generate CHANGELOG entry for v1.4.0 — commits since tag v1.3.2, format per CLAUDE.md §changelog"

# Agent runs git log v1.3.2..HEAD --oneline, categorizes by feat/fix/chore,
# groups semantically, and drafts a CHANGELOG.md entry:
#
# ## v1.4.0 — 2026-07-16
# ### New features
# - Add CSV export to reports page (#412)
# - Support multiple file uploads in the editor (#419)
# ### Bug fixes
# - Fix mobile layout overflow on Safari (#407)
# - Correct timezone handling in scheduler (#415)
# ### Internal
# - Upgrade dependencies (see lock file diff)
#
# Review, edit, commit

Works best with conventional commits (feat/fix/chore prefixes) — they give the agent explicit signals for categorization. Even with mixed commit messages, agents can usually infer the category from the commit body.

Documentation drift prevention

Documentation goes stale as code changes. An agent can scan the codebase for places where code and docs diverge — function signatures that don't match, configuration options that exist in code but not in docs, examples that reference deprecated APIs. Queue a doc audit monthly and wake up to a list of specific diffs to fix.

# Monthly doc audit task
amux board add "Audit docs/ against src/ — find stale API references, missing config options, broken examples"

# Agent produces a report:
# docs/api.md line 142: function signature outdated (params changed in commit a3f92b1)
# docs/config.md: missing 'timeout_ms' option (added in v1.3.1)
# docs/examples/auth.js: uses deprecated AuthV1 (removed in v1.2.0)
#
# You fix, commit, ship

Feature comparison

Maintenance task	Without amux	With amux agents
Triage 50 new issues	3–5 hours of reading and typing	Overnight run; 30-min review of drafts
Review 10 contributor PRs	5–8 hours including context-switching	Overnight drafts; 1–2 hours of final judgment
Write release notes for v1.x	1–2 hours of git log reading + writing	10-minute edit of agent draft
Monthly doc audit	Usually skipped (too slow)	Overnight scan; 1-hour fix session
Respond to stale issues	Periodic manual sweeps; often missed	Scheduled weekly agent run
Cost	Your time (the scarcest resource)	~$5–20 in API tokens per overnight run

Scheduling recurring maintenance

amux has a built-in scheduler. You can set it to triage new issues every Monday morning, audit docs monthly, and generate release notes draft before every planned release — all running unattended.

# Weekly issue triage (every Monday at 6am)
curl -sk -X POST -H 'Content-Type: application/json' \
  -d '{"title":"Weekly issue triage","command":"Triage all GitHub issues opened this week. See CLAUDE.md for rules. Post a summary to the amux board.","schedule_expr":"weekly on Monday at 6am","session":"myproject"}' \
  $AMUX_URL/api/schedules

# Monthly doc audit (1st of each month at 7am)
curl -sk -X POST -H 'Content-Type: application/json' \
  -d '{"title":"Monthly doc audit","command":"Audit docs/ for stale content vs src/. Report in board task.","schedule_expr":"monthly on 1 at 7am","session":"myproject"}' \
  $AMUX_URL/api/schedules

Monitor everything from your phone

The native iOS app gives you a live view of all running agents — peek at their output, check board status, approve or close tasks, and send new instructions without opening a laptop. For open-source maintainers who also have day jobs, this means checking on overnight triage runs during lunch or between meetings.

Get started

Install amux, register your open-source project, write a CLAUDE.md with your project context and triage rules, and queue your first overnight issue triage.

# Install (choose your preferred method)
brew install mixpeek/amux/amux      # Homebrew (macOS)
pipx install amux                    # PyPI
uvx amux serve                       # Zero-install

# Register your open-source project
amux register myproject --dir ~/Dev/myproject --yolo
amux start myproject
amux serve  # → https://localhost:8822

# Queue your first triage run
amux board add "Triage all open issues — categorize, label, draft responses per CLAUDE.md"

Frequently Asked Questions

Can AI agents actually triage GitHub issues reliably?

Yes, for the triage step: categorizing by type (bug/feature/question), assigning labels, checking for missing reproduction steps, linking to existing issues, and drafting a first response. amux runs Claude Code agents overnight with your CLAUDE.md context — they know your project's conventions, issue templates, and common patterns. Judgment calls (prioritization, acceptance/rejection) remain yours; the agent does the reading and drafting so you make decisions faster.

How does amux help with contributor PR reviews?

You queue each PR as a board task. The agent runs overnight, reads the diff and the project CLAUDE.md, checks coding conventions, looks for common mistakes (missing tests, incorrect types, undocumented breaking changes), and produces a structured review draft. You wake up with pre-read PR notes, edit or approve the review, and post it. A 30-minute PR review becomes a 5-minute approval.

How does amux generate changelogs?

The agent runs git log --oneline since the last release tag, categorizes commits by type (feat/fix/chore/docs), groups them semantically, and drafts a CHANGELOG.md entry in your project's format. You specify the format and style in CLAUDE.md. Works best with conventional commits (feat/fix/chore prefixes).

Does amux work for projects with hundreds of open issues?

Yes — you can run one agent per batch of issues overnight. For a backlog of 200 open issues, queue them in batches of 20–30 per agent session. Agents read in parallel and draft responses independently, sharing a kanban board so no issue is touched twice. A 200-issue triage backlog that would take a maintainer 3 days can often be drafted in one overnight run.

What is the cost for open-source maintainers?

amux itself is free and open-source (MIT license). You run it on your own machine — no SaaS fee, no per-seat charge. You pay only for AI model tokens. Issue triage and PR review are read-heavy tasks: triaging 50 issues typically costs a few dollars in API tokens. Claude Max ($200/month flat) gives unlimited Claude Code usage for maintainers with large backlogs.

Run an AI engineering team tonight — free and open-source

Install amux, write a CLAUDE.md with your project context, and queue your first overnight triage run.

brew install mixpeek/amux/amux
amux register myproject --dir ~/Dev/myproject --yolo
amux serve  # → https://localhost:8822

View on GitHub iOS App