Do I need a GitHub Personal Access Token or OAuth app to use Lapu AI with GitHub?

No. Lapu AI does not issue or store its own token. It shells out to the official `gh` CLI, which uses the credentials you already set up with `gh auth login`. Whatever scopes you granted `gh` are the scopes Lapu has — nothing more. There is no third-party OAuth app to install on your org's repos, and no PAT pasted into a cloud automation panel.

How is this different from GitHub Copilot or GitHub Agentic Workflows?

GitHub Copilot is a coding-assistant inside your editor and on github.com — it suggests code and reviews diffs in the GitHub UI. GitHub Agentic Workflows (technical preview, announced February 2026) run inside GitHub Actions in the cloud and execute Markdown-defined workflows on your behalf with safe-output guardrails. Lapu AI runs on YOUR desktop — it can drive `gh`, `git`, GitHub Desktop, your local test suite, and your browser in the same session, and it can connect a GitHub workflow to local files, other desktop apps (Linear, Slack, your editor), and shell scripts that never touch the cloud.

Can Lapu AI auto-merge pull requests?

Lapu can run `gh pr merge --auto` on your behalf only when you explicitly ask. It will not auto-merge in the background, and by default destructive or production-impacting commands (`git push --force`, `gh repo delete`, branch protection changes) require an explicit per-command approval that cannot be pre-authorized. This is intentional — agent write access to GitHub is the highest-blast-radius permission in your stack, so the agent stays in proposal mode unless you say otherwise.

Does Lapu AI work with GitHub Enterprise Server?

Yes. Because Lapu shells out to `gh`, it inherits whatever host you configured with `gh auth login --hostname github.your-company.com`. The audit trail records the host on every command, so you can confirm work is happening against the right environment. The agent does not separately ping github.com when you're working in an Enterprise context.

Is my source code or PR content sent to Lapu AI's cloud?

No. Repositories live on your filesystem, the same place `git` and `gh` already keep them. When the agent needs to reason about a diff or test failure, only the specific lines it needs are sent as context to AI model providers — never the full repository. For privacy-sensitive code, this is the main reason teams choose Lapu over a SaaS PR-review bot that uploads the whole diff to a third-party service.

Can Lapu AI run the full test suite as part of a review?

Yes, with shell:exec permission. The agent runs your existing `npm test` / `pytest` / `cargo test` / `make test` in your terminal on your machine, captures output, and includes failure traces in the review draft. Long-running test suites can be configured to run in the background and post the result when complete. For tests that need a real database or external service, the agent uses whatever local setup you already have — it does not spin up its own infrastructure.

Does Lapu AI work with GitHub Desktop on both macOS and Windows?

Yes. Lapu ships native builds for both macOS and Windows, and GitHub Desktop is available on both platforms. The agent drives GitHub Desktop through OS accessibility APIs — the same approach it uses for any native desktop app — so the same workflows behave identically across the two operating systems.

When should I NOT use Lapu AI for GitHub work?

Use GitHub Actions if you need a workflow that runs on every push, on a schedule, or on events your desktop isn't online for — a server-side workflow is the right tool for 24/7 automation. Use GitHub Agentic Workflows if you want repository-level AI automation that any teammate can trigger from the GitHub UI. Lapu AI is built for interactive, permissioned, desktop-first GitHub work — the kind of task you'd otherwise do across `gh`, your editor, your terminal, and your browser tabs, all stitched into one approved plan.

developer tools

Automate GitHub with Lapu AI

GitHub is the source-of-truth most engineering teams ship through — for issues, pull requests, releases, and CI. Lapu AI automates GitHub from your macOS or Windows desktop the same way you do: it runs the `gh` CLI in your terminal, drives the GitHub Desktop app through OS accessibility APIs, and navigates github.com in a browser tab. Repositories stay on your machine, your existing `gh auth` token is reused in place, and every action is recorded in a local audit trail — no Personal Access Token pasted into a cloud automation, no GitHub Action you have to write and review for security, no third-party bot you have to install on every org repo.

Download freeFree · macOS & Windows · No credit card

1-click uninstall
Cancel anytime
Files never leave your computer

Top GitHub workflows

1. Review a pull request end-to-end from your terminal
You open Lapu AI when a teammate pings you for a PR review. Instead of switching to the browser, the agent runs `gh pr view`, `gh pr diff`, and `gh pr checkout` against your local clone, reads the diff against the rest of the codebase, runs the test suite, and writes a structured review (correctness, risk, missing tests) that you post back as a draft comment — never auto-approved.
```
"Open PR #482 in this repo with gh. Read the diff, check it against the existing code in ~/code/api/, run `npm test` locally, then write a review covering: (1) correctness bugs you see in the diff, (2) missing test coverage, (3) anything risky about the schema migration in db/migrations/. Post the review as a draft PR comment via `gh pr review --comment` so I can edit before submitting."
```
Tools used: shell:exec, file:read, browser:control
2. Triage your issue inbox into a prioritized backlog
Your repo has 120 open issues with no labels. Lapu AI walks each one via `gh issue list` + `gh issue view`, reads the body and recent comments, classifies it (bug | feature | question | duplicate | stale), suggests labels and a milestone, and shows you a single approval pane before any labels are applied.
```
"List every open issue in org/repo with `gh issue list --state open --limit 200`. For each, read the body, classify as bug | feature | question | duplicate | stale, suggest labels from the existing label set, and propose a milestone. Build a Markdown table at ~/triage/issues.md with proposed actions. Pause for me to approve, then apply the labels with `gh issue edit` row by row."
```
Tools used: shell:exec, file:write
3. Open a PR from a local branch with a generated description
You finish a feature branch and want to open the PR. Lapu AI reads your recent commits with `git log`, diffs the branch against `main`, drafts a PR title and body (summary, test plan, screenshots-needed checklist), pushes the branch with `git push -u origin`, and runs `gh pr create` with the drafted body — you approve the body before it hits GitHub.
```
"I'm on branch feat/audit-export in ~/code/api. Diff against origin/main, read the commit messages, then draft a PR with: title (<70 chars), summary (bullets), and a 'Test plan' checklist. Push the branch and run `gh pr create --base main --draft` with that body. Stop after the draft PR opens so I can flip it to ready."
```
Tools used: shell:exec, file:read, file:write
4. Drive GitHub Desktop to commit + push when the CLI is fiddly
Some commits are easier in the GUI — picking individual changed lines into a commit, splitting a noisy commit, or co-authoring with a teammate. Lapu AI opens GitHub Desktop, selects the right lines via the accessibility tree, writes the commit message, and pushes — useful when you want the visual selection but not the manual clicks.
```
"Open GitHub Desktop, switch to the repo ~/code/marketing, and in the current diff for src/lib/integrations-data.ts include only the lines that touched the IntegrationPage interface (not the unrelated formatting changes). Write the commit message 'feat: add github integration page type' and push. Skip the formatting-only changes — I'll commit those separately."
```
Tools used: browser:control, shell:exec
5. Investigate a CI failure and propose a fix
A red check on a PR. Lapu AI runs `gh run view --log-failed` against the failing run, parses the test output, finds the specific assertion or build error, locates the suspect file in your local clone, and writes a focused fix proposal — without touching `main` and without auto-pushing.
```
"Run `gh run view <run-id> --log-failed` for the latest failed check on this PR. Parse the failure — likely a vitest assertion in tests/unit/. Open the related source file in ~/code/api, propose the minimal patch, and write the diff to ~/triage/pr-482-fix.patch. Do NOT apply the patch — I want to read it first."
```
Tools used: shell:exec, file:read, file:write
6. Generate release notes from merged PRs in a milestone
You ship every two weeks and the release notes always get written at 5pm on Friday. Lapu AI lists merged PRs in the milestone via `gh pr list --search 'milestone:v2.4 is:merged'`, groups them by label (feat, fix, chore), writes a Markdown changelog with PR links, and saves it as `RELEASE_NOTES_v2.4.md` in your repo.
```
"Run `gh pr list --search 'milestone:v2.4 is:merged' --limit 200 --json number,title,labels,author`. Group by primary label into sections: Features (feat:), Fixes (fix:), Internal (chore:). Write a clean changelog to ~/code/api/RELEASE_NOTES_v2.4.md with each PR linked. Mention every author once in a 'Contributors' footer."
```
Tools used: shell:exec, file:write

7. Bulk-rename branches and clean up stale ones

Your repo has dozens of merged or abandoned branches. Lapu AI uses `git branch -r --merged` and `gh api` to find branches with no open PR and no recent commits, shows you the deletion list, and runs `git push origin --delete` only after you approve.

"List remote branches in this repo that are merged into main AND have no open PR AND no commit in the last 60 days. Use `git branch -r --merged main`, cross-check with `gh pr list --state all --head <branch>`, and produce ~/triage/stale-branches.md with proposed deletions. Wait for my OK before running `git push origin --delete` on each."

Tools used: shell:exec, file:write

8. Cross-reference a Linear issue with the matching PR thread
Your bug tracker lives in Linear (or Jira), but the discussion happens on the PR. Lapu AI reads a Linear issue, finds the linked PR via the branch name or commit reference, pulls the PR comments via `gh api`, summarizes the technical resolution, and appends it as a comment on the Linear issue.
```
"Open Linear issue ENG-1247. Find the linked PR (the branch name in Linear matches `feat/audit-export`). Use `gh pr view 482 --json comments,reviews` to pull the discussion, summarize the resolution in 4-6 bullets, and post it as a Linear comment with a link back to the PR."
```
Tools used: browser:control, shell:exec

How it works

1
Choose the right path: CLI, desktop app, or browser
For most engineer-grade work — opening PRs, reading diffs, triaging issues, generating release notes — Lapu AI shells out to the `gh` CLI and `git` against your local clones. For visual diff selection, individual-line commits, or co-authored commits, it drives the GitHub Desktop app through macOS/Windows accessibility APIs the same way a human would. For tasks the CLI doesn't expose (Project boards UI, Discussions, Settings → Branch protections), it falls back to driving github.com in a permissioned browser tab.
2
Reuse your existing gh auth — no new tokens
Lapu AI does not issue or store its own GitHub Personal Access Token. It shells out to `gh` which uses the credentials you already authenticated with via `gh auth login`. Scope tokens once, and every Lapu task inherits exactly that scope — nothing more. No PAT pasted into a cloud automation panel, no third-party OAuth app installed on every org repo.
3
Plan before mutating
For anything that writes to GitHub — opening a PR, applying labels, posting a review, deleting a branch — the agent writes a plan first: which command, which arguments, what the expected effect is. You approve the plan, the agent runs it, and the result is recorded. Read-only operations (listing PRs, reading diffs, viewing run logs) execute immediately without approval — the gating is on writes.
4
Run tests locally before posting a review
When the task includes running CI-equivalent steps (`npm test`, `pytest`, `cargo test`), the agent runs them in your terminal on your machine. Test failures and stack traces are captured into the review draft. You see the same output you would have seen running it yourself — no hidden execution in a remote sandbox where logs disappear.
5
Audit every gh command
Every `gh`, `git`, and accessibility action is recorded in your local audit trail: which command, which repo, what changed, what the exit code was. The audit log lives on your machine and is retained for up to 90 days. For destructive operations (`git push --force`, `git branch -D`, `gh repo delete`), the agent requires explicit per-command approval — `--auto-approve` is never available for these.

Permissions required

shell:exec — to run `gh`, `git`, and your existing test/build commands in a permissioned terminal session
file:read — to read source files, diffs, and CI log outputs from your local clones
file:write — to write generated review drafts, patch files, release notes, and triage docs to disk before any of it touches GitHub
browser:control — optional, for parts of GitHub the CLI doesn't cover (Project boards, Discussions, Settings) or for driving the GitHub Desktop app through OS accessibility APIs
network:github.com — outbound network only to github.com and api.github.com (and your own GitHub Enterprise host if configured). No background polling — the agent only talks to GitHub when a task asks it to

FAQ

Do I need a GitHub Personal Access Token or OAuth app to use Lapu AI with GitHub?: No. Lapu AI does not issue or store its own token. It shells out to the official `gh` CLI, which uses the credentials you already set up with `gh auth login`. Whatever scopes you granted `gh` are the scopes Lapu has — nothing more. There is no third-party OAuth app to install on your org's repos, and no PAT pasted into a cloud automation panel.
How is this different from GitHub Copilot or GitHub Agentic Workflows?: GitHub Copilot is a coding-assistant inside your editor and on github.com — it suggests code and reviews diffs in the GitHub UI. GitHub Agentic Workflows (technical preview, announced February 2026) run inside GitHub Actions in the cloud and execute Markdown-defined workflows on your behalf with safe-output guardrails. Lapu AI runs on YOUR desktop — it can drive `gh`, `git`, GitHub Desktop, your local test suite, and your browser in the same session, and it can connect a GitHub workflow to local files, other desktop apps (Linear, Slack, your editor), and shell scripts that never touch the cloud.
Can Lapu AI auto-merge pull requests?: Lapu can run `gh pr merge --auto` on your behalf only when you explicitly ask. It will not auto-merge in the background, and by default destructive or production-impacting commands (`git push --force`, `gh repo delete`, branch protection changes) require an explicit per-command approval that cannot be pre-authorized. This is intentional — agent write access to GitHub is the highest-blast-radius permission in your stack, so the agent stays in proposal mode unless you say otherwise.
Does Lapu AI work with GitHub Enterprise Server?: Yes. Because Lapu shells out to `gh`, it inherits whatever host you configured with `gh auth login --hostname github.your-company.com`. The audit trail records the host on every command, so you can confirm work is happening against the right environment. The agent does not separately ping github.com when you're working in an Enterprise context.
Is my source code or PR content sent to Lapu AI's cloud?: No. Repositories live on your filesystem, the same place `git` and `gh` already keep them. When the agent needs to reason about a diff or test failure, only the specific lines it needs are sent as context to AI model providers — never the full repository. For privacy-sensitive code, this is the main reason teams choose Lapu over a SaaS PR-review bot that uploads the whole diff to a third-party service.
Can Lapu AI run the full test suite as part of a review?: Yes, with shell:exec permission. The agent runs your existing `npm test` / `pytest` / `cargo test` / `make test` in your terminal on your machine, captures output, and includes failure traces in the review draft. Long-running test suites can be configured to run in the background and post the result when complete. For tests that need a real database or external service, the agent uses whatever local setup you already have — it does not spin up its own infrastructure.
Does Lapu AI work with GitHub Desktop on both macOS and Windows?: Yes. Lapu ships native builds for both macOS and Windows, and GitHub Desktop is available on both platforms. The agent drives GitHub Desktop through OS accessibility APIs — the same approach it uses for any native desktop app — so the same workflows behave identically across the two operating systems.
When should I NOT use Lapu AI for GitHub work?: Use GitHub Actions if you need a workflow that runs on every push, on a schedule, or on events your desktop isn't online for — a server-side workflow is the right tool for 24/7 automation. Use GitHub Agentic Workflows if you want repository-level AI automation that any teammate can trigger from the GitHub UI. Lapu AI is built for interactive, permissioned, desktop-first GitHub work — the kind of task you'd otherwise do across `gh`, your editor, your terminal, and your browser tabs, all stitched into one approved plan.