Cursor Plugin

Archgate integrates with Cursor to give its AI agent the same structured governance workflow available in Claude Code: read the applicable ADRs before writing code, validate after, and capture new patterns for the team. The integration combines an always-apply Cursor rule with the Archgate skills and agents.

Beta access required

The Cursor plugin is in closed beta. Run archgate login to sign up and authenticate. The plugin is distributed from plugins.archgate.dev and the CLI manages your token for you. The CLI itself is free — even without the plugin, Cursor can consult ADRs through CLI commands (see Without the plugin below).

What the plugin provides

The plugin (archgate, version 0.7.0) registers a Cursor marketplace entry and installs an agent, five skills, and a governance rule. Cursor’s plugin system handles namespacing, so skills and agents use their direct names without an archgate: prefix.

Agents

Name	Mode	Purpose
developer	Edits	General development agent. Reads ADRs before coding, validates after, orchestrates the skills.
planner	Read-only	Designs ADR-compliant implementation approaches without writing or modifying any files.

Skills

Name	When it is used
reviewer	After a code change — validates changes against project ADRs using focused per-domain sub-agents.
lessons-learned	After coding and validation — captures recurring patterns and codifies them into ADRs.
adr-author	When creating or editing an ADR — follows the project’s established structure and conventions.
onboard	Once per project — runs archgate init, explores the codebase, interviews you, writes ADRs.
cli-reference	Internal: loads the authoritative CLI command, rules-authoring, and ADR-format references.

These are the same agent and skills shipped in the Claude Code plugin, adapted for Cursor’s plugin system.

Governance rule

File	Purpose
.cursor/rules/archgate-governance.mdc	An always-apply rule that instructs the agent to consult ADRs and run checks.

The rule uses alwaysApply: true, so Cursor’s agent always has governance context available without manual activation. It tells the agent to run archgate review-context before coding and archgate check --staged after, and reinforces the key principle: architectural decisions are enforced, not suggested — if archgate check reports violations, they must be fixed.

Installation

1. Log in with GitHub.

   archgate login

   This obtains your plugin token and stores credentials in your OS credential manager.

2. Initialize the project for Cursor.

   Run archgate init with the --editor cursor flag:

   archgate init --editor cursor

   If you are logged in, this also installs the Archgate plugin. To request the plugin explicitly:

   archgate init --editor cursor --install-plugin

The plugin is delivered through two channels, both handled by the CLI:

• Cursor team marketplace — a git-based marketplace repository served from plugins.archgate.dev. After installation, Cursor discovers the plugin from the marketplace URL the CLI prints. (Under the hood, the plugin archive is served as a tar.gz.)
• VS Code extension (VSIX) — a .vsix is installed into Cursor via cursor --install-extension when the cursor CLI is available.

The archgate plugin install --editor cursor command installs the VSIX via the cursor CLI if present and prints the team marketplace URL; otherwise it prints manual instructions.

Installing on an existing project

archgate plugin install --editor cursor

To retrieve the authenticated marketplace URL for manual setup:

archgate plugin url --editor cursor

Tip

Commit the .cursor/ directory. This ensures every teammate gets the same governance configuration when they clone the repository.

First-time setup: onboard

After installing the plugin, run the onboard skill once per project. It:

1. Explores your codebase structure — directories, key files, package configuration.
2. Interviews you about your team’s conventions, constraints, and architectural decisions.
3. Creates an initial set of ADRs from your answers.
4. Sets up the .archgate/ directory with your first rules.

After onboarding, the other skills handle day-to-day development. See Writing ADRs for the format it follows.

How it works in practice

With the plugin

The developer agent follows a structured workflow for every coding task:

1. Read applicable ADRs — runs archgate review-context to see which ADRs apply to the changed files. It does not write code until it has read them.
2. Write code following ADR constraints — implements changes against the Do’s and Don’ts from the applicable ADRs.
3. Run compliance checks — runs archgate check --staged to execute automated rules; fixes any violations before proceeding.
4. Reviewer pass — invokes the reviewer skill, which launches a focused sub-agent per affected domain to verify structural compliance against the full ADR set.
5. Capture learnings — invokes the lessons-learned skill to identify patterns worth codifying as new ADRs or updates to existing ones.

For planning-only work, switch to the planner agent: it reads the relevant ADRs, analyzes the codebase, and produces an ADR-compliant plan without modifying any files.

Without the plugin

Even without the plugin (the free path), archgate init --editor cursor configures the governance rule. The agent uses that rule and CLI commands to follow four manual steps:

1. Review context — run archgate review-context to see which ADRs apply to the changed files.
2. Read individual ADRs — run archgate adr show <id> (for example, archgate adr show ARCH-001) for full context on a decision.
3. Write code — implement changes following the applicable ADR constraints.
4. Run compliance checks — run archgate check --staged to validate compliance.

The free path gives Cursor governance context and CLI-driven checks, but not the role-based skills and sub-agents above.

ADR-driven refusal

When a task would require violating an ADR, the agent refuses, names the ADR, and suggests a compliant alternative — consistently, regardless of phrasing. ADRs are mandatory constraints. For example, asked to add a disallowed dependency in a project governed by a dependency-policy ADR, the agent declines, cites the ADR and the approved list, and proposes the sanctioned alternative.

Session transcript access

The archgate session-context cursor command reads Cursor agent session transcripts from disk, letting skills recover context that may have been compacted or truncated. It accepts two optional flags:

• --max-entries <n> — maximum number of (most recent) entries to return; default 200.
• --session-id <uuid> — a specific session UUID; if omitted, the most recent session is used.

For exact command flags and output formats, see the authoritative reference at cli.archgate.dev.

When to use each agent or skill

Scenario	Use
Setting up Archgate on a new project	onboard
Planning an approach before coding	planner
Day-to-day coding tasks	developer
Reviewing changes for ADR compliance	reviewer
Capturing a recurring pattern as an ADR	lessons-learned
Creating or editing an ADR by hand	adr-author

Most of the time you interact only with the developer agent — it orchestrates reviewer and lessons-learned automatically.

Next steps

Claude Code plugin The most complete integration, with deeper workflow detail.

Plugin ecosystem Compare all six editor integrations and the distribution model.

CLI reference Authoritative commands, rules API, and ADR format.