Skip to main content
The Weave Cursor plugin is a lightweight telemetry hook installed on each developer’s machine. It captures per-session, per-developer activity directly from Cursor’s hook events and sends it to Weave. Unlike the Cursor Admin API integration (which requires a Team or Enterprise plan and reports daily per-user totals), the plugin works on any Cursor plan and reports prompt-, edit-, and tool-level detail per developer.
The Cursor page covers the Admin API integration (usage, costs, acceptance rates via API polling). This page covers the per-machine Plugin, which adds prompt-level telemetry and finer-grained activity signals, and works without an admin plan.

What’s tracked

The plugin hooks into Cursor’s agent lifecycle and reports:
  • Session activity — session start/end, duration, model, composer mode, and whether it’s a background agent
  • Prompts — prompt submissions and (optionally) prompt text for activity classification
  • File edits — files touched with lines added and removed
  • Shell commands — command execution and exit codes
  • Tool & MCP calls — tool name, inputs, results, and failures, including MCP executions
  • Subagents — subagent start/stop, task, and message/tool-call counts
  • Agent output — agent responses and reasoning/thoughts
  • Context compaction — when context is compacted, with context usage %, token counts, and window size
  • Install health — a per-machine install ping so you can confirm each developer is reporting

What it unlocks

  • No Team/Enterprise requirement — the Admin API is gated to paid org plans; the plugin works on any Cursor plan, including individual setups
  • Per-developer, per-session granularity — attribute activity to individual machines and developers
  • File- and shell-level detail — edits, line counts, and command execution the API doesn’t expose
  • Context-window visibility — track how often and when sessions hit compaction
  • Richer agent signals — tool calls, subagents, and agent reasoning beyond API usage counts
  • AI skills — per-session conversation scoring (planning, verification, ownership, and more) requires the plugin’s session-level signals
  • Easy rollout — a single install command per machine, with auto-update built in

Prerequisites

  • Cursor installed (the installer looks for ~/.cursor)
  • Node.js 18 or later on each machine
  • A Weave plugin telemetry API key (created in the steps below)

Setup

1

Create a plugin API key in Weave

Go to Data → Cursor → Connect, select Weave Plugin Install, and click Install Weave Plugin. If you can’t open that page, open Personal plugin setup on the Data page and choose Cursor. Any signed-in member can click Create my install command. That command writes telemetry onto their own Weave account. Revoke my install command removes those personal commands. An admin can also click Create API key for a shared key that attributes by email. Weave shows the full key once.
2

Run the install command on each machine

Copy the command from the configuration modal and run it on each developer’s machine.macOS / Linux:
Windows (PowerShell):
To route telemetry through your redacting OpenTelemetry Collector, choose Through an OpenTelemetry Collector in the configuration modal. The generated command sets --telemetry-mode collector and the collector URL for you. The equivalent shell form is:
Remote collectors must use HTTPS. Redact prompt and tool content in the collector, but preserve the weave.token resource attribute so Weave can associate the records with the organization.The installer verifies your token, downloads weave-telemetry.js to ~/.weave/cursor-plugin/hooks/, writes config to ~/.weave/cursor-plugin.json, and merges Weave hooks into ~/.cursor/hooks.json. It then fires an install ping. Direct mode confirms that Weave accepted it; collector mode confirms only collector receipt, so check the collector’s Weave exporter for downstream delivery.
3

Restart Cursor

Quit Cursor completely and reopen it for the hooks to take effect, then run a session and confirm activity appears in Weave.
The plugin auto-updates: when Weave ships a new version, installed plugins pick it up automatically, so you don’t need to re-run the installer on every release.

Content settings

Five content categories control what the plugin sends. They are the same set the Claude Code plugin and Codex plugin use. The install command Weave generates already includes your organization’s Telemetry content retention floor. Members can deny more categories, but can’t turn back on a category the organization denies. Pass false to deny a category, for example --tool-io false. --privacy-mode true denies all five at once. On Windows, set WEAVE_PRIVACY_MODE, WEAVE_PROMPT_BODIES, WEAVE_AGENT_MESSAGES, WEAVE_TOOL_IO, WEAVE_FILE_PATHS, or WEAVE_GIT_CONTEXT before running install.ps1. The installer writes these choices to ~/.weave/cursor-plugin.json. You can edit the file later; the hook reads it on every event:
"privacy_mode": true overrides content_policy and denies every category. Setting WEAVE_PRIVACY_MODE=true in the environment Cursor runs in does the same. Some reports need specific categories:
  • Agent autonomy and other prompt-pattern metrics need prompt_bodies. Weave classifies each prompt from its text, and leaves out sessions with no classified prompt.
  • AI skills conversation scoring needs prompt_bodies. It also uses agent_messages: without reply text, Weave scores a session only from its tool calls, and turns where the agent only replied in text add no evidence.
  • Skill usage records typed slash commands under any setting.

Fleet / MDM rollout

For large teams, pre-deploy ~/.weave/cursor-plugin.json (with the token and endpoint) via your MDM, then run the install command without arguments — it reuses the existing config. The installer is idempotent: re-running it updates the hook command and skips events that are already wired up. On macOS and Linux, the installer must run as the logged-in user, not as root. MDM tools (Jamf, Kandji, Intune, Fleet, Addigy) run scripts as root in a minimal environment where $HOME is unset and the user’s node isn’t on PATH, so a root-context run either fails outright or installs the hooks into the wrong account. If your MDM has a “run as current user” (user-context) option, use it. Otherwise, wrap the install command so it drops into the console user’s session:
This reuses the pre-deployed ~/.weave/cursor-plugin.json. If you don’t pre-deploy it, pass --token and --endpoint (plus any content flags such as --privacy-mode) to the install command instead; passing a token rewrites the config file, so don’t combine it with a pre-deployed one. Node.js 18 or later must be installed for the target user.

Uninstall

Quit Cursor completely, then run the script for the environment where the plugin was installed. It needs Node.js 18 or later. The script backs up hooks.json under a unique name, removes Weave hooks that point at ~/.weave/cursor-plugin/, preserves the original hooks.json permissions, and deletes ~/.weave/cursor-plugin/ and ~/.weave/cursor-plugin.json. Windows Cursor uses the PowerShell script, including when your projects live in WSL. Run the shell script inside WSL only if you installed the plugin in that Linux environment. macOS / Linux (cursor-plugin-uninstall.sh):
Windows (PowerShell) (cursor-plugin-uninstall.ps1):
Uninstall does not revoke the plugin API key. Delete it on the Cursor plugin API keys card where you created it if you want every install using it to stop.

Metrics enabled

Once reporting, the plugin feeds:

Cost tracking

The plugin captures prompt-, edit-, and tool-level activity, not billing data, so it does not report Cursor spend. Per-user Cursor cost comes from the Cursor Admin API integration (Team/Enterprise plans). Run the plugin and the Admin API integration together — the plugin adds per-developer detail, the Admin API adds actual spend.

Sync frequency

Telemetry is sent in real time as each hook event fires during a session.

Troubleshooting

The plugin requires Node.js 18+. Install it (brew install node, nvm, or your platform’s package manager) and re-run the install command. The installer bakes the absolute path to node into the hook, so GUI-launched apps work too.
The installer preflights the token before touching any hooks. If it stops with Error: Could not verify Weave connection., the key is wrong or was deleted, or the machine can’t reach Weave. Create a new plugin API key in Weave and re-run the command.
  1. Confirm the install reported ✓ Verified telemetry pipe
  2. Check that ~/.cursor/hooks.json contains hooks referencing weave-telemetry.js (weave-telemetry.cmd on Windows)
  3. Fully quit and reopen Cursor (hooks load on startup)
  4. Verify the machine can reach the ingest endpoint (check network/firewall)
The script ran as root from your MDM, where $HOME isn’t set. Install in the logged-in user’s context instead — use your MDM’s “run as current user” option, or the wrapper in Fleet / MDM rollout that re-runs the installer as the console user. Make sure Node.js 18 or later is installed for that user.

Data privacy

The plugin sends session metadata, file-edit counts, shell exit codes, tool usage, agent output, and — unless privacy mode is on — prompt text. It does not read source files or repository contents beyond what Cursor passes through the hook events.
Last modified on October 17, 2026