What’s new in Aviator

Aviator status, inline on the PR page

• Aviator's queue status now renders inside GitHub's native merge-status sidebar, so you can see exactly where a PR stands without switching to the dashboard.
• State-aware badges: a queued PR shows as Queued instead of just "Open."
• The blocked panel now explains why a PR is blocked and gives you a Queue button to act on the spot.
• The extension now persists its cache and caches managed config, so the popup opens instantly instead of waiting on a fetch.

FlexReview: no more reviewer streaks

• Reviewer selection now uses weighted randomness across equally-good candidates, so the same person no longer gets picked on back-to-back PRs — review load spreads evenly.

Also shipped

• Runbooks: REST update endpoint with PR-overrides on create and update; full edit access for every account user; auto-archive when a runbook's PR merges.
• MergeQueue: significant queue-page performance improvements for large repos; `skip-validation` now works independently of `skip-line`.

We recently released agent plugins for the Aviator CLI that bring stacked PR workflows to coding agents like Claude Code.

What the plugin does

The av-cli plugin teaches Claude Code and other coding agents how to use the Aviator CLI ( av ) for branch and PR management. Once installed, the agent will:

• Detect av-initialized repos and automatically use av commands instead of raw git
• Create branches within your stack using av branch so dependencies stay intact
• Open PRs with correct base branches via av pr — no more manually fixing targets
• Keep stacks in sync with av sync when parent branches change
• Handle merge conflicts using --continue , --abort , and --skip flags
• Adopt remote branches with av adopt --remote for collaborating on shared stacks

Getting started

Install from the Claude Code plugin marketplace:

/plugin marketplace add aviator-co/agent-plugins
/plugin install av-cli

Prerequisites: Aviator CLI installed, repo initialized with av init , and GitHub CLI or a GitHub PAT for auth.

The plugin activates automatically in av-initialized repositories — no extra prompting required.

Why stacked PRs

Stacked PRs let you break large features into small, reviewable chunks while maintaining dependencies between them. Instead of one massive PR that nobody wants to review, you get a chain of focused, incremental changes. When a parent branch changes, av sync automatically rebases the dependent branches.

Pair that with a coding agent that actually understands the workflow, and you get fast iteration without the manual bookkeeping.

Check out the plugins repo: github.com/aviator-co/agent-plugins

‍

Runbooks becomes addressable from places other than the dashboard — Linear, a REST API, existing PRs, and uploaded spec files.

Trigger from Linear

Kick off a Runbook directly from a Linear issue.

• Connect Linear from **Settings → Integrations** via OAuth.
• Once connected, issue events in Linear create Runbook sessions automatically, with the issue's context passed through as the initial prompt.

REST API

Create and monitor Runbook sessions programmatically.

• POST /api/v1/runbook creates a session — pass a repo , a prompt , and optional title , pr_mode , and target_branch .
• GET /api/v1/runbook/<runbook_number> returns the session status, step tallies (generating / not started / in progress / partially completed / completed / failed), and any PRs the session has opened.
• Authenticated with an Aviator API token.
• Read the Docs

Run on existing PRs

/aviator revise now works on PRs that weren't created by Runbooks.

• Drop the command as a comment on any existing PR and Runbooks spins up a retroactive session around the PR's current state, so the agent can address review feedback just like on a Runbook-authored PR.
• Useful for bringing Runbooks into PRs that started life as a manual change but would benefit from agent-driven revisions.

Spec file uploads

Upload .md and .txt spec files from the Runbooks page to seed a session.

• Supports spec-driven planning — drop in a design doc, requirements file, or migration plan and the agent uses it as primary context when generating steps.
• Uploaded files are attached to the session and carried through into step execution.

‍

Runbooks gets a major chat UX rewrite and scoped-per-repository configuration, plus a round of MergeQueue improvements focused on scale and control.

Runbooks: revise PRs directly from chat

The chat session becomes the primary surface for steering the agent — including on PRs that are already up for review.

• **Revise from chat**: ask the agent to apply review-comment changes (or new instructions) straight from the session, without leaving a PR comment.
• **Real-time processing indicator** shows exactly when the agent is working, so it's clear whether the session is waiting on you or on the model.
• **Separate Claude sessions per step execution** with a shared session for the main chat — step runs no longer pollute the chat's context, and the chat stays fast across long runbooks.
• **Pre-execution scripts run once per sandbox** instead of on every step, cutting a meaningful chunk of overhead from multi-step runbooks.

Runbooks: repository-level configuration

Runbook configuration now cascades through three levels: Account → Repository → Session.

• Set workspace-wide defaults at the account level, override them per repository where a different sandbox, tool list, or MCP config makes sense, and still let individual sessions fine-tune on top of that.
• Applies to sandbox config, Claude Code tool allow/deny lists, MCP servers, and PR settings.
• Templates also get edit and delete support this month, so you can iterate on shared starting points without recreating them.

MergeQueue improvements

• Scaled affected-targets processing to handle repos with 350K+ targets.
• New config to restrict which sources can submit PRs to the queue. Docs .
• PR details page now tracks who queued and dequeued each PR.
• More graceful failure handling for partially tagged stacked PRs.
• Stacked PRs now consistently pick up the latest master during bot PR creation.

‍

Runbooks picks up three primitives that make longer sessions safer to work in: reverting completed steps, deleting steps outright, and a proper task queue that serializes everything you do in a session.

Revert completed steps

Roll a runbook session back to any previously completed step.

• Hard-resets the working branch to the commit at the end of the target step and marks that step — plus every step after it — as Not Started, so you can replan or re-execute from that point forward.
• Triggered from the three-dot menu on any completed step, with a confirmation modal that previews exactly which steps will be reset.
• Optional "close discarded PRs" toggle cleans up any PRs that were opened by the steps you're reverting, so you don't leave orphaned PRs behind.

Delete steps

Remove steps from a runbook without touching git.

• Available from the step's action menu, and also from inside the chat session so you can trim the plan without leaving the conversation.
• Restricted to **Not Started** and **Failed** steps, so you can't accidentally delete work that's running or already completed.
• Deleting a parent step deletes its child steps in the same action, with a preview of everything that will be removed.

Task queue for every session action

Every action inside a runbook session now flows through a per-session task queue.

• Covers chat messages, step executions, /aviator revise commands, and automatic CI rework — concurrent actions no longer step on each other.
• **FIFO with priorities**: chat messages take priority over step execution, which takes priority over revisions and CI rework, so interactive feedback stays responsive even while the agent is busy.
• **Queue visibility**: a task queue card in the session UI shows the currently running task and any pending ones, with an expandable list when the queue is deep.
• **Deterministic ordering**: if you kick off a step execution and immediately send a chat message, both will run in a predictable order instead of racing.

‍