Your CI already reads every pull request. It runs tests, checks formatting, builds the binary. It knows exactly what changed.

It just never tells you anything useful.

That's the gap octomind-action fills. It brings Octomind — the same AI agent you run locally — directly into your GitHub Actions workflow. GitHub AI code review, PR briefs, diff analysis, custom prompts — triggered automatically on every push, posted as a comment.

What it does

octomind-action is a GitHub Action that runs any Octomind role in your CI pipeline. You pick the role, pass your AI provider key, and it runs on whatever trigger you define — PR opened, push to main, scheduled, whatever you need.

The output can post as a GitHub comment (full or compact), print to the workflow log, or feed into the next step via outputs. The binary is cached between runs so you're not downloading it every time.

You can use it for a few practical jobs right away:

Automatic PR briefs — on every PR open and push, get a structured breakdown of what changed: behavior changes (not file changes), risk level, and confidence score. It shows up as a PR comment automatically. You don't touch anything.

Code review — code review automation that flags issues by severity before a human touches the PR. Catches things reviewers miss when they're tired or rushing.

Custom prompts — anything you'd type into Octomind locally, you can automate. Summarize changes, explain architecture decisions, check for security issues, generate release notes from a diff.

Adding It to Your Repo

This is the workflow we added to Octomind itself, the one that generates PR briefs automatically:

yaml
name: CI
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  brief:
    name: PR Brief
    runs-on: ubuntu-latest
    if: github.event_name == 'pull_request'
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Generate PR Brief (New PR)
        if: github.event.action == 'opened'
        uses: muvon/octomind-action@master
        with:
          role: developer:brief
          model: ollama:glm-5.1
          prompt: "Compare branch '${{ github.head_ref }}' to '${{ github.base_ref }}' and provide a brief summary of all changes"
          comment: 'full'
        env:
          OLLAMA_API_KEY: ${{ secrets.OLLAMA_API_KEY }}

      - name: Generate PR Brief (Push to existing PR)
        if: github.event.action == 'synchronize'
        uses: muvon/octomind-action@master
        with:
          role: developer:brief
          model: ollama:glm-5.1
          prompt: 'Analyze changes from commit ${{ github.event.before }} to ${{ github.event.after }} and provide a brief summary of incremental changes'
          comment: 'full'
        env:
          OLLAMA_API_KEY: ${{ secrets.OLLAMA_API_KEY }}

Two catches: fetch-depth: 0 is required — without it, checkout only gets the tip commit and the action can't see the full diff against the base branch. Two separate steps handle the two cases: a fresh PR gets a full summary against the base branch; a push to an existing PR gets an incremental summary of what changed since the last commit.

You need an AI provider key as a repo secret. We use Ollama (self-hosted). OpenRouter, Anthropic, OpenAI — anything Octomind supports works. Just pass the right key in env.

What a PR brief looks like

The PR where we added this workflow produced this output:

PR brief example

Two cards. Both 🟢 LOW risk, both high confidence. A reviewer sees that in 10 seconds and knows it is safe to merge, with the actual behavior changes called out.

That's the point of developer:brief specifically — it reports behavior changes, not file changes. "The MCP server now propagates working directory to all sessions" is a different sentence from "3 files changed, +60 lines." Both describe the same PR. One tells you what it means.

Why Behavior Changes Matter More Than Diffs

The average diff is noisy. Tests, formatting, generated files, config tweaks buried in 300-line files. Reading it takes time and attention you'd rather spend on the code that actually matters.

The DORA 2025 report found PR size is up 51.3% with AI-assisted coding. Incidents per PR are up 242.7%. We're shipping bigger changes faster — but reviewing them with the same cognitive budget as before. That gap is the AI slop tax in action.

Research on code review defect rates shows that at 450 lines of diff, 87% of reviewers miss at least one defect. Not carelessness — just the limits of working memory.

developer:brief cuts through that by extracting the semantic changes: what the system does differently now, how risky each change is, how confident the analysis is. You read the brief first, then open the diff knowing exactly what to look for. The orientation cost drops from 10 minutes to 30 seconds.

Other roles you can run

Brief is one role. The action runs any role Octomind supports:

yaml
# Compact summary as a PR comment
- uses: muvon/octomind-action@v1
  with:
    prompt: 'Summarize changes in this PR'
    comment: compact
  env:
    OPENROUTER_API_KEY: ${{ secrets.OPENROUTER_API_KEY }}
yaml
# Code review with severity filtering
- uses: muvon/octomind-action@v1
  with:
    prompt: 'Review this PR for security issues and bugs. Flag anything severity high or critical.'
    comment: full
  env:
    ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
yaml
# Override the model for a specific job
- uses: muvon/octomind-action@v1
  with:
    prompt: 'Explain the architecture changes in this PR'
    model: anthropic:claude-sonnet-4
  env:
    ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

You can also chain steps — run analysis in one step, then resume with context in the next:

yaml
- uses: muvon/octomind-action@v1
  id: analysis
  with:
    prompt: 'Analyze the security implications of these changes'

- uses: muvon/octomind-action@v1
  with:
    prompt: 'Based on the security analysis, suggest specific mitigations'
    resume: analysis

The model doesn't have to be expensive

We run developer:brief with ollama:glm-5.1 — a local model, no API cost. The output in the screenshot above was generated by that model. Coherent, structured, actionable.

The value isn't the model — it's the role. Structured output, risk taxonomy, card format. A well-prompted mid-tier model beats an unprompted frontier model for classification and summarization tasks every time. Start with whatever you have. Upgrade if you need sharper reasoning on complex changes. And if you're weighing this against Copilot's built-in review, note that Copilot code review now consumes your Actions minutes on top of the subscription.

Try it

octomind-action is an open-source AI code review tool, Apache 2.0 licensed. 20 lines of YAML to get started.

Your CI already reads every PR. Now it can tell you what it found.