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

> Discover which AI agents no-mistakes supports, including Claude, Codex, Copilot, and more. Get the complete back-end reference for seamless integration.

- Repository: [Kun Chen/no-mistakes](https://github.com/kunchenguid/no-mistakes)
- Tags: api-reference
- Published: 2026-06-28

---

**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`](https://github.com/kunchenguid/no-mistakes/blob/main/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`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/agent/agent.go) and selects the first available concrete agent implementation.

### Anthropic Claude

**Constant:** `AgentClaude` (`"claude"`)  
**Implementation:** [`internal/agent/claude.go`](https://github.com/kunchenguid/no-mistakes/blob/main/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`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/agent/codex.go)

Drives the pipeline using the AWS Code Codex CLI.

### Rovo Dev

**Constant:** `AgentRovoDev` (`"rovodev"`)  
**Implementation:** [`internal/agent/rovodev.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/agent/rovodev.go)

Connects to the Rovo Dev environment for enterprise development workflows.

### OpenCode

**Constant:** `AgentOpenCode` (`"opencode"`)  
**Implementation:** [`internal/agent/opencode.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/agent/opencode.go)

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

### Pi AI

**Constant:** `AgentPi` (`"pi"`)  
**Implementation:** [`internal/agent/pi.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/agent/pi.go)

Integrates with GitHub's Pi AI system.

### GitHub Copilot

**Constant:** `AgentCopilot` (`"copilot"`)  
**Implementation:** [`internal/agent/copilot.go`](https://github.com/kunchenguid/no-mistakes/blob/main/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`](https://github.com/kunchenguid/no-mistakes/blob/main/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`](https://github.com/kunchenguid/no-mistakes/blob/main/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`](https://github.com/kunchenguid/no-mistakes/blob/main/.no-mistakes.yaml) file in your project root:

```yaml

# Explicit selection

agent: claude

# Auto-detection

agent: auto

# ACP dynamic target

agent: acp:my-custom-backend

```

### CLI Flags

Override configuration file settings at runtime:

```bash
no-mistakes run --agent claude

```

### Programmatic Selection

When using `no-mistakes` as a library in Go:

```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`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/types/types.go) – Declares the `AgentName` type and constants
- [`internal/agent/agent.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/agent/agent.go) – Factory that creates agent instances based on `AgentName`
- [`internal/agent/claude.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/agent/claude.go) – Claude CLI integration
- [`internal/agent/codex.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/agent/codex.go) – AWS Code Codex CLI integration
- [`internal/agent/rovodev.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/agent/rovodev.go) – Rovo Dev CLI integration
- [`internal/agent/opencode.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/agent/opencode.go) – Vendor-neutral OpenCode driver
- [`internal/agent/pi.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/agent/pi.go) – Pi AI integration
- [`internal/agent/copilot.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/agent/copilot.go) – GitHub Copilot CLI integration
- [`internal/agent/acpx.go`](https://github.com/kunchenguid/no-mistakes/blob/main/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`](https://github.com/kunchenguid/no-mistakes/blob/main/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`](https://github.com/kunchenguid/no-mistakes/blob/main/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`](https://github.com/kunchenguid/no-mistakes/blob/main/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`](https://github.com/kunchenguid/no-mistakes/blob/main/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`](https://github.com/kunchenguid/no-mistakes/blob/main/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.