# Connect your coding agent

**`https://mcp.loopops.dev`** — the base URL is the endpoint: no path, no
query, no key. First use opens a one-time email sign-in (any email; the
one-time PIN proves you control it). LoopOps tracks the current MCP
specification release, so a modern harness connects natively. Installing the
native plugin — or the LoopOps skill plus MCP for clients without a native
plugin — is a required first step.

## Claude Code

```bash
claude plugin marketplace add codeyogi911/loopkit-plugin
claude plugin install loopkit@loopkit --scope user
claude plugin list
```

Run `/reload-plugins` or restart Claude Code after a new install.

## Codex

```bash
codex plugin marketplace add codeyogi911/loopkit-plugin --ref main
codex plugin add loopkit@loopkit
codex mcp login loopops
```

The **LoopOps** plugin registers the hosted endpoint and bundles the loop's
workflow instructions, so Codex gets the bounded-read and approval-gated
choreography with the connector. Verify with `codex plugin list --json` and
`codex mcp list --json`, then start a new thread.

## Any MCP harness

Install the shared skill, then add the URL in the client's native MCP config:

```bash
npx -y skills add codeyogi911/loopkit-plugin --skill loopkit --yes --global
```

Cursor uses `mcpServers` in `.cursor/mcp.json`; GitHub Copilot / VS Code
uses `servers` in `.vscode/mcp.json`; Windsurf uses
`mcpServers.loopops.serverUrl`; OpenCode uses a remote entry under
`mcp.loopops` followed by `opencode mcp auth loopops`. Complete the email
sign-in when prompted. Headless/CI setups use the plain [HTTP API](/docs/api)
with project keys, but interactive coding-agent onboarding still installs the
skill and MCP first.

## Choose the path

- **Quick check** — inspect recent failures and product feedback with
  `loopops_diagnose` and bounded reads. Nothing is claimed and no cursor moves.
- **Governed cycle** — claim a window with `loopops_observe`, diagnose, record
  the decision, act through your normal coding workflow, record progress, then
  verify the next telemetry window.

## The five verbs

The five verbs are stages of the product loop, not five equivalent tool calls:

| Verb | Tool | What it does |
|---|---|---|
| Observe | `loopops_observe` | Claim a bounded telemetry window — handled pain never resurfaces |
| Diagnose | `loopops_diagnose` | Evidence-backed candidates, clustered, joined against loop history |
| Decide | `loopops_decide` + `loopops_issue_decide` | Admit cited Issues with recommendations, then record the human's attributed disposition |
| Improve | your coding tools + `loopops_improve` | Your agent implements and tests the fix; LoopOps only records progress |
| Verify | `loopops_verify` | Window comparison; recording proof also requires the latest patch receipt |

`loopops_improve` never edits code, runs tests, calls GitHub, or deploys.
Issue and PR milestones are optional: record only the stages your workflow
actually reaches.

Plus bounded reads (`loopops_telemetry`, `loopops_sessions`,
`loopops_session`, `loopops_loops`, `loopops_issue`, `loopops_map`), account
tools (`loopops_projects`, `loopops_claim`), and policy tools
(`loopops_scoring`, `loopops_redaction`). `loopops_redaction` is security
administration, not part of a normal diagnose-and-fix cycle. `loopops_feedback`
sends feedback about the LoopOps toolkit; product-user feedback is read from
`feedback.user`, `feedback.reviewer`, `feedback.auto`, and `feedback.toolkit`
evidence (`feedback.toolkit` is agent-filed and lands on LoopOps' own project,
where it is that project's product feedback).

## Claim a headless project

A project minted by CI or the onboarding runbook belongs to its keys, not an
account. Bind it once, from inside the agent:

```text
Claim project <project_id> with recovery code <recovery_code>, then diagnose the last hour.
```

## The approval gate

The endpoint is read-first. Its only writes are loop-native: claiming a
project to your account, recording lifecycle and verification events,
archiving a project you explicitly name. LoopOps never posts issues, opens
PRs, merges, or touches production — every external write waits for a human.

**Next:** [Run your first loop →](/docs/run-your-first-loop)