Navin autonomous board: auto branches, pull requests and GitHub issues

Navin's task board is no longer just a kanban: with one explicit consent, it becomes a self-driving delivery pipeline. The agent chains through ready tasks, isolates every task on its own git branch, opens a pull request when the work is done, keeps GitHub issues in sync and can even fix an issue end to end - while you keep the final word on every merge.

What board autonomy actually does

The task lifecycle under autonomy

1. board next: the agent picks the best ready task (critical path first).
2. claim: the navin/task-<id>-<slug> branch is created automatically.
3. Implementation and validation: tests, lint, verify - evidence stays mandatory.
4. done: leftovers are committed (only on the task branch), the branch is pushed, the PR opens with the description, acceptance and evidence.
5. The linked GitHub issue is closed with a comment, and the agent moves to the next task.
6. A blocked task fires a warning notification and does not stop the rest of the queue.

Every step leaves a trail: branch, PR link, issue link and comments are recorded on the card. Weeks later, you can replay the whole story.

Explicit consent, never a hidden daemon

Nothing changes until you flip the Autonomy toggle in the Tasks panel. A dialog explains exactly what the agent will be allowed to do and lets you pick each capability:

• Isolated branch per task - on by default.
• Pull request on done - on by default, requires the gh CLI.
• GitHub issues sync - off by default.
• Fix issues autonomously - off by default: the agent may then drive an issue to a tested, committed, closed state.
• Autopilot loop - off by default: a session-bound cron processes the board continuously.

The consent is timestamped and written into <project>/.navin/board/settings.json: it travels with the repository and is shared by the Code module and every studio. For the operator, two machine-wide kill-switches in Settings > Security > Git disable auto-branch and auto-PR for every project at once.

Never lose work, by construction

This is the part other tools gloss over. Navin's autonomy plumbing only ever uses creating and preserving git commands: git switch -c, git add, git commit, git push -u without force. No reset, no clean, no force-push, no branch deletion - and a dedicated regression test fails the build if one is ever added.

• The agent never merges a pull request: review stays with you.
• Destructive commands typed through the raw shell (git reset --hard, git clean, git push --force, git branch -D) are intercepted and pause for your approval.
• A repository mid-merge or mid-rebase refuses auto-branching with a clear message.
• No gh, no remote, no network? The board keeps working and the reason lands as a task comment.

GitHub issues: three directions, zero duplicates

The Issues tab in Project Home lists the repository's issues and supports three moves, all deduplicated by URL:

1. Import to board: one task per open issue, labeled github plus the original labels.
2. Mirror issue: the agent creates the GitHub issue for a task with its description, acceptance and evidence.
3. Fix with agent: one click sends a strict brief - reproduce, fix on an isolated branch, tests green, commit, PR, and only then close the issue and re-sync the board.

Compared with a classic AI IDE

FAQ

Does enabling autonomy start work immediately?

No. It changes what happens during runs you start (Run agent, /forge, /cruise, /mission). The separate Autopilot loop option, off by default, covers continuous processing.

What if my project is not a git repository?

Branching and PRs are skipped with an explanatory comment; task chaining keeps working.

Can the agent close an issue it did not fix?

No. The instruction is explicit: never close without a tested, committed fix. Closing goes through a comment referencing the correction.

What do I need?

Git for branches, and the authenticated GitHub gh CLI for PRs and issues.

Download Navin · Features · Documentation

Recommended next reads

• Resume a project after weeks away → Project Home
• Cut branches / PRs globally → Git kill-switches
• Blueprint → Forge → Cruise → Plan / Mission
• Durable memory → Project Brain
• Plan and steer tasks (human / agent / hybrid) → expert board
• The full control room → Vision 360
• The Agent, Plan, Review, Security cycle → Code module
• Build an agent team → Navin agents

Conclusion

Board autonomy turns a list of cards into real throughput: clean branches, reviewable PRs, issues closed with evidence, and a human deciding every merge. That is autonomy that makes a difference - without ever putting your repository at risk.