Which AI Agents Are Supported by No-Mistakes: Complete Back-End Reference

No-mistakes supports eight AI agent back-ends including Claude, Codex, Copilot, Rovo Dev, OpenCode, Pi AI, and dynamic ACP agents, with an auto-detection mode that selects the first available implementation.

The no-mistakes repository provides a flexible pipeline for code review and automation by integrating with multiple AI agent providers. Understanding which AI agents are supported by no-mistakes helps developers configure the right back-end for their specific workflow and infrastructure requirements.

Supported AI Agent Back-Ends

The complete list of supported agents is defined in internal/types/types.go as the AgentName constants. These constants map to specific implementations in the internal/agent/ package.

Auto-Detection Mode

The AgentAuto constant ("auto") enables automatic discovery. When selected, no-mistakes scans the host environment during startup via the factory in internal/agent/agent.go and selects the first available concrete agent implementation.

Anthropic Claude

Constant: AgentClaude ("claude")
Implementation: internal/agent/claude.go

Integrates with the Anthropic Claude Code CLI for code generation and review tasks.

AWS Code Codex

Constant: AgentCodex ("codex")
Implementation: internal/agent/codex.go

Drives the pipeline using the AWS Code Codex CLI.

Rovo Dev

Constant: AgentRovoDev ("rovodev")
Implementation: internal/agent/rovodev.go

Connects to the Rovo Dev environment for enterprise development workflows.

OpenCode

Constant: AgentOpenCode ("opencode")
Implementation: internal/agent/opencode.go

Provides a vendor-neutral OpenCode driver for standardized AI interactions.

Pi AI

Constant: AgentPi ("pi")
Implementation: internal/agent/pi.go

Integrates with GitHub's Pi AI system.

GitHub Copilot

Constant: AgentCopilot ("copilot")
Implementation: internal/agent/copilot.go

Supports the GitHub Copilot CLI as a back-end agent.

Dynamic ACP Agents

Constant: AgentACP ("acp")
Implementation: internal/agent/acpx.go

Supports dynamic ACP agent resolution using the format acp:<target>. The target name is supplied at runtime, allowing connection to custom ACP back-ends without hardcoded constants.

How Agent Selection Works

Agent instantiation is handled by the factory function in internal/agent/agent.go. This factory receives the selected AgentName from the configuration and returns the corresponding concrete implementation.

The selection process follows this priority:

1. Check for explicit agent configuration via CLI flag, config file, or programmatic API
2. If AgentAuto is specified, probe each concrete agent in order of availability
3. Instantiate the first responsive agent or return an error if none are found

Configuration Methods

You can specify which AI agents are supported by no-mistakes through three primary interfaces.

YAML Configuration

Create a .no-mistakes.yaml file in your project root:

# Explicit selection

agent: claude

# Auto-detection

agent: auto

# ACP dynamic target

agent: acp:my-custom-backend

CLI Flags

Override configuration file settings at runtime:

no-mistakes run --agent claude

Programmatic Selection

When using no-mistakes as a library in Go:

import (
    "github.com/kunchenguid/no-mistakes/internal/config"
    "github.com/kunchenguid/no-mistakes/internal/types"
)

func configurePipeline() {
    cfg := &config.Config{
        Agent: types.AgentClaude, // Explicitly select Claude
    }
    // Pass cfg to the pipeline executor
}

Implementation Architecture

Each agent integration resides in a dedicated file within internal/agent/:

• internal/types/types.go – Declares the AgentName type and constants
• internal/agent/agent.go – Factory that creates agent instances based on AgentName
• internal/agent/claude.go – Claude CLI integration
• internal/agent/codex.go – AWS Code Codex CLI integration
• internal/agent/rovodev.go – Rovo Dev CLI integration
• internal/agent/opencode.go – Vendor-neutral OpenCode driver
• internal/agent/pi.go – Pi AI integration
• internal/agent/copilot.go – GitHub Copilot CLI integration
• internal/agent/acpx.go – Dynamic ACP agent loader for acp:<target> values

Summary

• Eight built-in agents are supported: Claude, Codex, Copilot, Rovo Dev, OpenCode, Pi AI, and dynamic ACP agents, plus an auto-detection mode
• Agent constants are defined in internal/types/types.go with implementations in internal/agent/
• Auto-detection via AgentAuto selects the first available agent on the host system
• Configuration supports YAML files, CLI flags (--agent), and programmatic Go API
• Dynamic ACP agents allow runtime resolution using the acp:<target> syntax for custom back-ends

Frequently Asked Questions

How do I check which AI agents are available on my system?

Run no-mistakes with agent: auto in your configuration file. According to the internal/agent/agent.go implementation, the tool probes each concrete agent and selects the first one that responds successfully. If no agents are detected, the pipeline exits with an error indicating that no back-end could be initialized.

Can I use multiple AI agents simultaneously in one project?

No, no-mistakes operates with a single active agent per execution context. The factory in internal/agent/agent.go instantiates exactly one back-end based on the AgentName constant specified in your configuration. To switch agents, you must modify the configuration or use the --agent CLI flag to override the current setting.

What is the difference between OpenCode and other vendor-specific agents?

AgentOpenCode (internal/agent/opencode.go) provides a vendor-neutral abstraction layer that standardizes interactions across different AI providers, while vendor-specific implementations like AgentClaude or AgentCopilot directly invoke their respective CLIs with provider-specific optimizations. Choose OpenCode when you need portability across environments, or select a specific agent when you require native CLI features.

How do I configure a custom ACP agent that is not in the default list?

Use the dynamic ACP syntax with the format acp:your-target-name in your configuration file or CLI. The internal/agent/acpx.go implementation resolves this at runtime by parsing the target identifier after the colon and connecting to the specified ACP endpoint. This requires no code changes to the no-mistakes repository.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}