Nairinairi
Try Now

GitHub integration

AI agents that ship code in your repos

Connect Nairi to your GitHub repos. Ask it from Slack or Discord to open PRs, review code, fix bugs, iterate. For automatic per-PR review, call the Nairi REST API from your CI.

Connect GitHub Read the docs

A few things teams use Nairi for on GitHub

These are starting points, not the limit. The agent runs whatever you mention it on, with whatever tools you've connected.

Open PRs from a Slack thread

Ask Nairi in Slack to fix a bug or implement a Linear ticket. The agent clones the repo, makes the changes, runs your tests, opens the PR, and posts the link back in the same thread.

Review pull requests on demand

Ask Nairi from Slack: "review PR #123 in foo/bar". It fetches the diff, runs your tests and linter in its sandbox, posts review comments to the PR, and summarizes back in your thread.

Automatic per-PR review via the API

Wire the Nairi REST API into a GitHub Action. On every PR open, your workflow calls Nairi and the agent posts its review comments to the PR. No more "did anyone look at this yet?"

Multi-person collaboration on a PR

A PM kicks off a feature from #product, an engineer iterates in the same Slack thread, Nairi keeps pushing changes to the PR. The conversation lives where the team is; the code lives in GitHub.

Iterate on existing PRs

Reply in the same Slack thread to ask for changes. Nairi reads the current PR state, pushes additional commits, and updates the thread when CI passes.

+ whatever else your team does

Hand it your migration runner, your release script, your codemod tool. The agent uses what you give it.

GitHub is where the work lives

GitHub is not the trigger. The trigger is your team in Slack or Discord, or your CI calling the Nairi REST API. The agent then works on your GitHub repos and any other tools you connect.

Where you trigger the agent
Slack
Mention @Nairi in a channel or thread
Discord
Mention @Nairi in a server channel or thread
REST API
Call from CI, cron, or any system that triggers programmatically
Nairi agent
Isolated container, one per agent, inside your org
Claude CodeCodexOpenCodeCursor
What the agent can reach
GitHub repos
Read code, open PRs, run CI
MCP servers
1,000+ including Postgres, Linear, Notion
Skills
Reusable prompts and playbooks
Vaults
Secrets injected at runtime
Rules
Custom instructions per agent

Two ways to use Nairi with GitHub

Pick the one that fits the workflow. Most teams use both.

Mode 1

Conversational from Slack or Discord

Mention @Nairi and ask it to do something on a repo. "Open a PR that adds X." "Review PR #123." "Fix the failing test on main." The agent works in its sandbox and posts results back in the thread.

Fits multi-person collaboration. A PM kicks off a feature, an engineer iterates, the agent keeps pushing commits. The conversation lives in your team channel; the code review trail lives in GitHub.

Mode 2

Automated via the REST API

Call the Nairi API from a GitHub Action (or any other system). On PR open, on Issue creation, on a cron schedule, on whatever event makes sense for your team.

Common pattern: a workflow file that fires on every PR open, passes the diff to Nairi, and the agent posts a review with test results, lint output, and inline suggestions back to the PR. No human in the trigger loop.

Common workflows

A few of the patterns teams reach for on day one. The agent does much more than this once you wire it into your stack.

01

PR review automation via GitHub Actions

Add a workflow file that calls the Nairi REST API on every PR open. Pass the diff, the repo, and any review instructions. Nairi spins up its sandbox, runs your tests and linter, and posts review comments to the PR. The whole team gets a baseline review on every change without waiting for a human.

02

Multi-person feature from Slack to GitHub

A PM drops a feature spec in #product and asks Nairi to scaffold it. An engineer pings the same thread with implementation feedback. Nairi iterates: pushes commits, runs the tests, replies with the diff. The PR ships from a single Slack conversation; the code review trail lives in GitHub.

03

Bug fix from a Linear ticket

Drop a Linear ticket link in Slack. Nairi clones the repo, reads the ticket, finds the relevant code, makes the fix, runs the tests, opens a PR with a writeup of what changed and why, and links back to the ticket. You review the PR in GitHub, merge when ready.

How it works

Install in 30 seconds, then choose what to connect. Your secrets stay in your vault, injected at runtime via a secret proxy. The agent’s execution surface never sees them in plaintext.

  1. 1

    Give Nairi access to your repos

    Connect the GitHub repos you want the agent to work in. Read-only for review workflows, write access for ship-from-Slack flows. Per-repo permissions, changeable any time.

  2. 2

    Configure what the agent can reach

    Per agent: pick repos, MCP servers (for Postgres, Linear, Notion, internal APIs, anything), reusable skills, custom rules, env vars, and vault-backed secrets.

  3. 3

    Trigger from Slack, Discord, or the API

    For conversational use: mention @Nairi in a Slack channel or Discord server. For automation: call the Nairi REST API from your CI, cron, or any other system that needs to invoke an agent programmatically.

  4. 4

    The agent runs in its sandbox

    Each invocation spins up an isolated container with shell, file system, and your build toolchain. The agent clones the repo, runs your code, runs your tests, pushes commits, opens or updates the PR, and posts back to the original surface.

Get started in two minutes

Sign up, connect your GitHub repos, and mention Nairi from Slack or Discord (or call the API). No infra to deploy.

Try Nairi free View pricing

Questions about GitHub

The things teams actually ask before installing.

Only if you want it to open PRs or push branches. You can install the GitHub app with read-only access for review-only workflows, or grant write access for full ship-from-Slack flows. Permissions are per-repo and changeable any time from your GitHub Apps settings.
No, not natively. There’s no “@-mention Nairi in a PR comment” flow. Triggers come from Slack, Discord, or the Nairi REST API. For GitHub-native automations like reviewing every new PR, wire the Nairi API into a GitHub Action: the workflow runs on PR open, calls the API, and Nairi posts its review to the PR.
Two ways. On demand: ask Nairi in Slack, e.g. “review PR #123 in foo/bar, focus on the migration logic”. The agent fetches the diff, runs your tests and linter in its sandbox, and posts review comments to the PR (plus a summary back in your Slack thread). Automated: a GitHub Action calls the Nairi REST API on every PR open. Same review, no human in the trigger loop.
Yes. A PM can kick off a feature from #product, an engineer can iterate in the same Slack thread, a designer can add a follow-up. Nairi reads the full thread context for each request and keeps pushing commits to the same PR. The conversation lives in Slack; the code review trail lives in GitHub.
Yes. Each agent has shell access in an isolated container. Configure what tooling you want available (we ship with most common languages and package managers pre-installed; you can add anything else). The agent runs your build, your tests, your linter, your custom scripts, whatever you point it at.
You pick: Claude (Sonnet 4.6, Opus 4.7), GPT-5 via Codex, or open-weights via OpenCode. Configurable per agent. The default is Claude Code under the hood.
Private repos are first-class. The Nairi GitHub app respects standard GitHub permissions. The agent runs in an isolated container inside your org, and you can opt for self-hosted agent containers via the open-source nairid daemon if you don’t want code leaving your infrastructure.
Copilot Workspace is GitHub-native: you work inside github.com and the agent lives there. Nairi is invoked from Slack, Discord, or the REST API, and works *on* your GitHub repos from a separate sandbox. Different shape, different tradeoffs. If your team’s daily collaboration happens in Slack rather than github.com, Nairi fits that workflow more naturally.
Yes. Agent containers can run on your own servers via the open-source nairid daemon. The backend stays managed by Nairi, so you don’t handle the orchestration layer. Self-hosted agents are free and unlimited on every plan.

Related

Slack integrationDiscord integrationPricing