Claude Code Plugin

Overview

The Oxagen Claude Code plugin gives Claude Code direct, typed access to your workspace knowledge graph via MCP. Once connected, Claude can resolve entities, traverse the graph, generate blast-radius reports before refactors, query CI / coverage / security alerts, recall stored procedures, coordinate with other agents — all without leaving your editor.

The plugin's value isn't limited to code. The same MCP tools and the always-on memory layer power incident response, security triage, customer-impact analysis, on-call runbook recall, and research workflows. See Real-world use cases below.

The repo is open source at oxagenai/claude-code-plugin (MIT). Every tool call is workspace-scoped, credit-tracked, and returns the canonical SPEC §7.9 envelope (results, evidence, tokens_used_estimate, counterfactual_estimate_tokens, counterfactual_method, cursor, tenant_scoped_at).

Quick start

# Add the Oxagen marketplace + install the plugin
/plugin marketplace add oxagenai/claude-code-plugin
/plugin install oxagen@oxagen

# Wire your workspace — opens the browser wizard
/oxagen:setup

# Ask a question about your workspace
/oxagen:ask "what are the most-called functions in the billing module?"

# Resolve a name to a graph node
/oxagen:find-symbol charge_credits

# Get a blast-radius report before a refactor
/oxagen:impact UserService.authenticate

# Search the knowledge graph
/oxagen:search "functions that write to the billing ledger"

Always-on guarantees

When the plugin is enabled, the SessionStart hook injects an <EXTREMELY_IMPORTANT> preamble on every session start (and after /clear and /compact) that pins three guarantees the agent honours on every turn:

1. Graph first, guess second. Before any non-trivial action — code edit, research synthesis, incident triage, ops change, customer-impact analysis, policy lookup — the agent queries the Oxagen graph (ontology.*, code.*, incident.*, security.*, workspace.*) instead of reasoning from name matches or its own prior context.
2. Memory always recalled. At the start of any task, the agent calls memory.recall (or memory.context_inject on target node IDs). If a procedure or episode matches, it uses it. After meaningful work, it persists what it learned via memory.remember and agent.record_finding.
3. Coordination respected. Other Oxagen-connected agents may be operating against the same workspace. The agent uses agent.list_active_claims before editing shared scope and agent.claim_work while it holds it.

The full routing policy lives in the oxagen:using-oxagen skill, also auto-loaded by the hook. The exhaustive tool catalog and write-back conventions live in oxagen:oxagen-tool-reference and oxagen:dogfooding, loaded on demand.

Installation

Step 1: Create or open a workspace

Sign in at app.oxagen.ai. A default workspace is provisioned on signup.

Step 2: Add the plugin

/plugin marketplace add oxagenai/claude-code-plugin
/plugin install oxagen@oxagen

Step 3: Run setup

/oxagen:setup

The command opens the browser wizard at https://app.oxagen.ai/setup/claude-code, walks you through workspace + GitHub repo selection, and hands back a one-line install string. Settings are written to ~/.claude/oxagen.local.json. The plugin polls until the initial repo ingest completes, then confirms the live tool list.

Step 4: Export the token

Add the following to your shell profile so the MCP connection works across restarts:

export OXAGEN_MCP_TOKEN="$(jq -r .token ~/.claude/oxagen.local.json)"

Then restart your shell (or source ~/.zshrc) and reopen Claude Code.

Step 5: Verify

/mcp

You should see the oxagen server listed with its full tool set.

Real-world use cases

Coding is the most obvious surface. It is not the only one. Anything Oxagen ingests becomes queryable and groundable.

Engineering — refactor with confidence

/oxagen:impact UserService.authenticate returns callers, dependents, PageRank, reach paths, and active claims — before you ship a signature change. Stops the "I didn't realize ten things called this" class of regression.

/oxagen:impact UserService.authenticate
/oxagen:cochange UserService.authenticate
/oxagen:tests-for UserService.authenticate

Engineering — onboarding

The new hire gets a cartography of the system in five minutes:

/oxagen:repo-overview
/oxagen:module-tree services/api/app
/oxagen:who-knows BillingLedger.charge
/oxagen:expert @alice

Incident response & SRE — blast-radius from a stack trace

Within seconds of a page firing:

/oxagen:find-symbol process_chunk
/oxagen:impact process_chunk
/oxagen:pr-history process_chunk
/oxagen:procedure-for "redis OOM during ingest"

The procedure recall pulls back what the last on-call engineer did the last time this happened — no wiki hunting at 3 a.m. After resolution:

/oxagen:incident resolve INC-2941
/oxagen:remember "OOM root-caused to chunk size 16k; mitigated by bounded queue at packages/oxagen/oxagen/ingest/queue.py:142" --outcome=succeeded

The next session that hits a similar trace gets that episode injected as context.

Security & compliance — triage with reach

/oxagen:security-alerts --severity=high
/oxagen:alert GHSA-xxxx-yyyy-zzzz

Alerts come back joined to the call graph so the agent can immediately answer "what is actually affected?" without grep-hunting. For audit workflows, ingest controls + evidence + owners into a workspace ontology and let the agent traverse CONTROLS → IMPLEMENTED_BY → OWNED_BY instead of stitching together spreadsheets.

Customer success & support — escalation graphs

/oxagen:ask "which customers depend on the feature gated by payments.charge?"
/oxagen:expert payments
/oxagen:procedure-for "stripe webhook retry storm"

For workspaces that ingest a customer ontology layer, the same code.*

• ontology.* tools answer "who's affected, who knows, what did we do last time" with typed certainty instead of guesswork.

Research, R&D, internal knowledge

Ingest a corpus (papers, internal docs, design memos) into a workspace. The agent answers "how does concept A relate to concept B" via ontology.traverse instead of vector-search guessing. Memory turns the agent into a research notebook that gets smarter every run:

/oxagen:recall "approaches to vector compression we've ruled out"
/oxagen:remember "Product-quantization variant X failed on our high-dim dataset; recall improved by 3pt but latency 4x" --outcome=failed

Failed approaches show up as warnings before the next agent retries them.

Multi-agent fleets

/oxagen:claim packages/oxagen/.../service.py:50-120
# … edit …
/oxagen:remember "extracted retry policy into shared helper at packages/oxagen/oxagen/util/retry.py:8" --outcome=succeeded
/oxagen:release-claim

agent.record_finding persists typed observations on affected nodes; agent.get_findings retrieves them at the start of the next task. Use /oxagen:go --p0 "investigate auth regression" to dispatch the Oxagen swarm; each agent inherits the same graph + memory + claim coordination.

Slash commands

All commands use the /oxagen: prefix. Run any command with no arguments to get interactive prompts.

Setup and Q&A

Discovery and structure

Traversal

History, ownership, issues

Tests and CI

Security

Memory

Coordination and ops

Response envelope

Every code-graph tool returns the same canonical envelope so the agent parses one shape regardless of which tool emitted it.

{
  "results": [...],
  "evidence": [
    {"node_id": "…", "kind": "code.function", "url": "https://github.com/…"}
  ],
  "tokens_used_estimate": 142,
  "counterfactual_estimate_tokens": 8400,
  "counterfactual_method": "grep_plus_read_n_files",
  "cursor": null,
  "tenant_scoped_at": {
    "tenant_id": "…",
    "workspace_id": "…",
    "project_id": null
  }
}

• results — the typed records the tool was asked for.
• evidence — node IDs the agent can cite back. Every record in results is reachable from at least one evidence entry.
• tokens_used_estimate — tokens spent on this tool's reply, computed from the assembled payload.
• counterfactual_estimate_tokens — what the same answer would have cost a vanilla file-search agent. The receipt for the "fewer LLM calls, smaller models, lower bills" claim.
• counterfactual_method — stable method-id naming the estimator (e.g. grep_plus_read_n_files, lockfile_transitive_parse_plus_manifests).
• cursor — opaque pagination token, or null for unpaginated results.
• tenant_scoped_at — the workspace the tool resolved to. Always populated.

The envelope is enforced — malformed responses are rejected before they reach the agent.

MCP tool reference

All tools follow the naming convention mcp__oxagen__<group>_<action>.

ontology.* — knowledge graph

code.* — discovery and structure

code.* — traversal

code.* — history, ownership, issues

code.* — tests and CI

code.* — dependencies

agent.* — multi-agent coordination

memory.* — agent memory

security.* — security alerts

workspace.* — workspace management

incident.* — incident tracking

Agent memory

Once enabled with /oxagen:memory-enable, capture is automatic. Claude Code does not need to call any memory tools explicitly — the MCP server captures every tool invocation in the background. The plugin's SessionStart hook still tells the agent to recall memory before any non-trivial task; the capture half is server-managed.

The M8 memory module surfaces:

• Procedures — recipes promoted from repeated successful or recovered runs. Retrieve via /oxagen:procedure-for <trigger>.
• Episodes — single events the agent stored via /oxagen:remember <fact>. Retrieve via /oxagen:recall <intent>.

Patterns are detected and injected into context before each run. Inspect the injection by reviewing the conversation's system prompt — the oxagen plugin's preamble plus any pattern-driven warnings appear under <EXTREMELY_IMPORTANT> tags.

Troubleshooting

No tools listed after setup. Check that OXAGEN_MCP_TOKEN is exported in the shell that launched Claude Code. Run echo $OXAGEN_MCP_TOKEN to verify. Restart Claude Code from a shell that has the export, then run /mcp.

memory.* tools not returning results. Memory tools are always registered; capture activates only after /oxagen:memory-enable flips on the workspace.

401 on every call. Your MCP token has expired or been revoked. Generate a new token at Settings → MCP → Tokens and re-run /oxagen:setup with the new install string.

Ingest stuck / graph empty. Check Settings → Connections in the app. If the GitHub connection shows an error, reconnect it and trigger a manual re-ingest from the same page. Or ask the agent to call ontology.refresh_repo.

Stale claim blocking another session. Use /oxagen:ask "list active claims" to find it, then run:

/oxagen:claim <file:line> --force

to override it (records an audit event).

Low confidence from /oxagen:ask or /oxagen:search. The workspace graph may be sparse or the ingest incomplete. Trigger a re-ingest via Settings → Connections → Re-ingest and retry once the status is ready.

Open source

The plugin is MIT-licensed and developed in the open at oxagenai/claude-code-plugin. File bugs, request commands, or open PRs there. The platform monorepo mirrors the same tree at plugins/oxagen-claude-code/ for internal dogfooding; ejection is automated via scripts/eject-claude-code-plugin.sh.

Get started free · View on GitHub · Read the docs