Arbiter

Autonomous GitHub Issue Solver

Let AI solve your issues while you sleep. Wake up to pull requests ready for review.

Website • Documentation • Discord • Get License

Arbiter is a local-first automation system that monitors your GitHub repositories, picks up labeled issues, and autonomously creates pull requests to solve them. It runs on your machine, uses your AI provider of choice, and handles all the Git workflow automatically.

Label an issue → Arbiter picks it up → AI solves it → PR ready for review

• 🤖 Autonomous Issue Resolution - Label issues with agent-ok and let Arbiter handle the rest
• 🧠 Multi-AI Support - Works with Claude Code, Cursor, Ollama, and LM Studio
• 🔒 Local-First - Your code never leaves your machine
• 📊 Web Dashboard - Monitor progress, configure settings, view logs in real-time
• 🔄 PR Iterations - Comment-based commands to request changes on existing PRs
• ✅ Automated Testing - Runs your test suite before committing
• 🎨 AI Code Review - Optional second AI instance reviews PRs before posting
• 🔐 Security Layer - Protected commands and configurable policies

• Docker and Docker Compose installed
• GitHub Personal Access Token with repo access (Create one here)
• AI Provider (choose one):
  • Claude Code - Recommended for best quality
  • Cursor - Great for integrated workflows
  • Ollama - Free, local models
  • LM Studio - Free, local models with GUI

1. Pull and run Arbiter:

docker run -d \
  --name arbiter \
  -p 3927:3927 \
  -v ~/.arbiter:/home/arbiter/.arbiter \
  -v ~/.ssh:/home/arbiter/.ssh:ro \
  gitarbiter/arbiter:latest

2. Access the web dashboard:

Open your browser to http://localhost:3927

3. Configure your setup:

1. Navigate to the Configuration tab
2. Add your GitHub token
3. Add repositories to monitor (e.g., owner/repo)
4. Configure your AI worker (Claude Code, Ollama, etc.)
5. Click Save Configuration

4. Verify everything works:

Click Run Doctor Checks to verify:

• ✅ GitHub token is valid
• ✅ AI worker is accessible
• ✅ Repository permissions are correct

5. Start solving issues:

• Label a GitHub issue with agent-ok
• Click Run Now in the dashboard
• Watch Arbiter solve the issue and create a PR!

github:
  token: ghp_xxxxx                    # Your GitHub Personal Access Token
  repos:                              # Repositories to monitor
    - owner/repo1
    - owner/repo2
  requiredLabel: agent-ok             # Label to trigger Arbiter

Create a GitHub Token:

1. Go to GitHub Settings → Tokens
2. Click Generate new token (classic)
3. Grant repo scope (full repository access)
4. Copy the token and paste it in the Configuration tab

Arbiter supports multiple AI providers. Choose the one that fits your needs:

Best quality, paid API costs.

worker:
  type: claude-code
  model: sonnet                       # sonnet | opus | haiku
  maxTurns: 50
  maxBudgetUsd: 5.0

Setup:

1. Install Claude Code CLI
2. Authenticate: claude auth login
3. Configure in Arbiter dashboard

Great for developers already using Cursor.

worker:
  type: cursor-agent
  model: claude-sonnet-4-5
  maxTurns: 50

Setup:

1. Install Cursor
2. Authenticate Cursor with your Claude API key
3. Configure in Arbiter dashboard

Run models locally on your machine. Free, but requires good hardware.

worker:
  type: ollama
  url: http://host.docker.internal:11434
  model: llama3.1:8b-instruct-q8_0
  maxTurns: 30

Setup:

# Install Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Pull a model
ollama pull llama3.1:8b-instruct-q8_0

# Start server
ollama serve

Recommended Models:

• llama3.1:8b-instruct-q8_0 - Fast, good for simple tasks
• llama3.1:70b-instruct-q8_0 - Better reasoning (requires powerful GPU)
• qwen2.5-coder:7b-instruct - Code-focused model

Local models with a user-friendly GUI.

worker:
  type: lmstudio
  url: http://host.docker.internal:1234
  model: model-name
  maxTurns: 30

Setup:

1. Download LM Studio
2. Download a chat/instruct model
3. Load model and start local server
4. Configure in Arbiter dashboard

Configure per-repo settings in the Repositories tab:

repos:
  owner/repo1:
    enabled: true                     # Enable/disable monitoring
    allowPush: true                   # Push branches to GitHub
    allowOpenPr: true                 # Open pull requests
    openPrAsDraft: true               # Open PRs as drafts
    reviewers:                        # Auto-request reviewers
      - username1
    checks:                           # Run before committing
      - npm test
      - npm run lint
    aiReviewer:                       # AI code review
      enabled: true
      mode: normal                    # lax | normal | hyper-critical

1. Label an issue in GitHub with agent-ok
2. Arbiter picks it up on the next run
3. AI solves the issue by reading code, making changes, running tests
4. PR is created as a draft for your review
5. Review and merge when satisfied

• Real-time status and logs
• "Jump In" to view live worker output
• Stop running tasks if needed

• Edit all settings via UI
• Manage GitHub repos
• Configure AI worker
• Test notifications

• View all monitored repos
• Enable/disable per repo
• Configure policies (push, PR, checks)
• Set up AI code review

• Query run history
• Filter by date, repo, status
• View detailed worker output
• Export logs for debugging

# Check system health
docker exec arbiter node dist/cli.js doctor

# Run once manually
docker exec arbiter node dist/cli.js run

# View current configuration
docker exec arbiter cat ~/.arbiter/config.yaml

Arbiter can iterate on existing PRs based on your comments:

Comment Commands:

• /arbiter-change <instructions> - Request changes to the PR
• /arbiter-review - Request AI code review
• #arbiter-note <text> - Add context for next iteration

Example:

/arbiter-change Please add error handling for the API call and update the tests accordingly

Arbiter will:

1. Read your comment
2. Re-run the AI worker with your instructions
3. Push new commits to the same PR
4. Comment when complete

Run Arbiter automatically at intervals:

1. Go to Dashboard tab
2. Set interval (e.g., 60 minutes)
3. Click Start Auto-Run
4. Arbiter runs every N minutes

Perfect for overnight processing or continuous issue resolution.

Enable a second AI instance to review PRs before posting:

repos:
  owner/repo:
    aiReviewer:
      enabled: true
      mode: normal                    # lax | normal | hyper-critical

The reviewer checks for:

• Security vulnerabilities
• Logic errors
• Code quality issues
• Missing edge cases

Results posted as GitHub review (Approve / Request Changes / Comment).

Get notified when runs complete:

notifications:
  desktop:
    enabled: true
    onSuccess: true
    onFailure: true
  browser:
    enabled: true                     # In-dashboard notifications

Arbiter takes security seriously:

• Your code never leaves your machine
• All processing happens locally
• Only GitHub API calls go to the internet

• Command allowlisting for safety
• Forbidden path protection (e.g., .github/workflows/**)
• Diff size limits (max files/lines changed)
• Draft PRs by default for human review

• Only repo members with write access can use PR iteration commands
• Unauthorized comments get 😕 reaction and are ignored

• GitHub token stored locally in ~/.arbiter/config.yaml
• Never logged or exposed in output
• Only used for GitHub API calls

1. Scan GitHub - Arbiter checks your repos for issues labeled agent-ok
2. Prioritize - Issues sorted by labels, age, and custom rules
3. Create Workspace - Clone repo, create feature branch
4. AI Worker - Claude/Ollama/LM Studio reads the issue and implements solution
5. Validate - Check diff size, run tests, validate changes
6. AI Review (optional) - Second AI reviews the code
7. Create PR - Open pull request as draft
8. Iterate (if needed) - Respond to your comments with additional commits

• 💬 Discord Community: Join our Discord
• 📧 Email Support: support@git-arbiter.com
• 📖 Documentation: git-arbiter.com/docs.html
• 🌐 Website: git-arbiter.com

Arbiter isn't finding issues:

• Verify issues have the agent-ok label
• Check GitHub token has repo access
• Run docker exec arbiter node dist/cli.js doctor

AI worker not responding:

• Verify Claude Code / Ollama / LM Studio is running
• Check worker configuration in dashboard
• View logs in the Logs tab

Permission errors:

• Ensure GitHub token has repo scope
• Verify Docker volumes are mounted correctly
• Check file permissions in ~/.arbiter directory

• CPU: 2 cores
• RAM: 4GB
• Disk: 10GB free space
• Network: Internet connection for GitHub and AI APIs

• CPU: 8+ cores
• RAM: 16GB+ (32GB for large models)
• GPU: NVIDIA GPU with 8GB+ VRAM (for Ollama/LM Studio)
• Disk: 50GB+ free space (model storage)

Arbiter is a commercial product with flexible subscription options:

• Pay what you think is fair, starting at $3/mo or $32 (save 15% on annual plans)
• Unlimited repositories and issues
• 7-day free trial
• Student discount: 50% off

No auto-renewal - You decide if it's worth continuing each billing period.

Get Started with Free Trial

Arbiter is commercial software. See Terms of Service for details.

Built with:

• Claude AI - Anthropic's AI assistant
• Cursor - AI-powered code editor
• Ollama - Local LLM runtime
• Docker - Containerization