---
title: Autter MCP Server - Connect Coding Agents to Code Review
description: The Autter MCP server gives Claude Code, Cursor, OpenCode, and any MCP-compatible coding agent direct access to Autter's review findings, codebase intelligence, security scans, and team conventions, so the agent that writes the code can fix its own review.
url: https://autter.dev/features/mcp
site: Autter - Autter is your AI teammate for code review and testing: it reviews code, tests product impact, checks security, governs releases, and closes the loop from production failure to verified fix.
---

## MCP Server at a glance

| Fact | Value |
| --- | --- |
| Role | The machine-facing layer: coding agents read Autter's reviews and act on them |
| Endpoint | https://api.autter.dev/mcp (Streamable HTTP, stateless JSON; POST only) |
| Auth | Autter personal access tokens (autter_pat_...), sent as a Bearer header |
| Scopes | mcp:read, mcp:write, mcp:llm; tokens expire and revoke from the dashboard |
| Clients | Claude Code, Cursor, OpenCode, Windsurf, and any MCP-compatible client |
| Guardrails | No arbitrary SQL, no generic GitHub writes; every call audited and rate limited |

## How it works, step by step

The old loop had a human courier: read the finding on GitHub, explain it to the agent, paste the fix back, click resolve. Over MCP the agent runs the whole circuit itself.

1. **Pull the review.** get_pr_review returns the verdict and up to 50 findings, each pinned to file and line with a ready-to-run fix_prompt.
2. **Fix in place.** The agent applies each fix_prompt in the working tree, with the conventions from get_learnings already in context.
3. **Answer the thread.** reply_to_review_comment posts the fix commit; resolve_review_thread closes the thread out on GitHub, which stays the source of truth.
4. **Push.** Commits go up exactly the way they always do. Nothing wraps Git.
5. **Ask for another pass.** trigger_review re-runs the review on the latest revision. Green means merge.

## Sixteen tools, five jobs.

Not an API dump behind an MCP wrapper. Each tool is built around something an agent genuinely needs mid-change, and every call lands in the audit log.

| # | Capability | What it does |
| --- | --- | --- |
| 1 | Identity and repositories | whoami and list_prs anchor the session to the right org, connected repos, and open pull requests. |
| 2 | The review loop | get_pr_review returns findings with ready-to-run fix_prompts; reply, resolve, and trigger_review close the round trip. |
| 3 | Team knowledge | get_learnings reads the conventions Autter has learned from your reviews; add_learning teaches new ones that future reviews enforce. |
| 4 | Codebase intelligence | query_codebase, get_symbol_info, get_impact_analysis, and get_repo_health answer before the first edit. |
| 5 | Security and scans | check_dependency vets packages before they are installed; trigger_scan, get_scan_status, and get_scan_findings run the full sweep. |
| 6 | Controlled access | Scoped personal access tokens, per-token rate limits, structured errors, and an audit entry for every call. |

## In one line

> The code writer can finally talk to the code reviewer.

Agents already write the code. The MCP server hands them the context they were writing blind without: findings, conventions, blast radius, and dependency risk, at the exact moment they need it.

## Tool reference

All 16 tools, generated from the same catalog the page renders. Every tool takes a `context` parameter where the agent states why it is calling; the reason is recorded alongside the call in the organization audit log.

| Tool | Area | What it does |
| --- | --- | --- |
| `whoami` | Identity and repositories | The authenticated user, org, token, and connected repositories. Call it first. |
| `list_prs` | Identity and repositories | Tracked pull requests for a repo, newest first, with per-PR review status. |
| `get_pr_review` | The review loop | The verdict, the chapters, and up to 50 findings, each pinned to file and line with a ready-to-run fix_prompt. |
| `reply_to_review_comment` | The review loop | Answer a review thread as the agent, attributed to your token. |
| `resolve_review_thread` | The review loop | Close a thread once its finding is fixed. GitHub stays the source of truth. |
| `trigger_review` | The review loop | Re-run the review on the pull request's latest revision. |
| `get_learnings` | Team knowledge | Team conventions learned from review feedback, dismissed findings, and repo rules. |
| `add_learning` | Team knowledge | Teach Autter a new repo convention. Future reviews enforce it. |
| `query_codebase` | Codebase intelligence | Natural-language questions answered from generated docs and the code graph, with citations. |
| `get_symbol_info` | Codebase intelligence | Definition, callers, blast radius, and change risk for any symbol. |
| `get_impact_analysis` | Codebase intelligence | What a change to a file can reach: dependents, churn history, test coverage. |
| `get_repo_health` | Codebase intelligence | Architecture concerns, hotspots, and risk insights at repository level. |
| `check_dependency` | Security and scans | Known CVEs, fixed versions, and typosquat flags before the package is installed. |
| `trigger_scan` | Security and scans | Start a full codebase scan across Autter's scanning agents. |
| `get_scan_status` | Security and scans | Poll a running scan with per-agent progress. |
| `get_scan_findings` | Security and scans | Unified findings from the latest scan, filterable by severity and agent. |

## Connecting a client

Create a personal access token in the Autter dashboard under Organization → Access Tokens (scope it to `mcp:read` for a read-only agent), then register the server.

Claude Code:

```sh
claude mcp add --transport http autter https://api.autter.dev/mcp \
  --header "Authorization: Bearer autter_pat_..."
```

Cursor and most other MCP clients:

```json
{
  "mcpServers": {
    "autter": {
      "type": "http",
      "url": "https://api.autter.dev/mcp",
      "headers": { "Authorization": "Bearer autter_pat_..." }
    }
  }
}
```

## Protocol facts

| Fact | Value |
| --- | --- |
| Endpoint | https://api.autter.dev/mcp |
| Transport | Streamable HTTP, stateless JSON responses (POST only; GET returns 405) |
| Auth | `Authorization: Bearer autter_pat_...` |
| Token scopes | `mcp:read`, `mcp:write`, `mcp:llm` |
| Errors | Structured codes such as `repo_not_found`, `insufficient_scope`, `scan_limit_reached`, `github_unavailable` |
| Rate limits | Per token, so runaway agent loops are slowed rather than billed |

## Related

- [Code Review](https://autter.dev/features/code-review.md)
- [Autter CLI](https://autter.dev/features/cli.md)
- [Integrations](https://autter.dev/features/integrations.md)
- [Full product overview](https://autter.dev/index.md)