Browse plugins

ECC is a comprehensive agent harness platform for Claude Code with 68 agents, 292 skills, and 94 legacy command shims, featuring reusable hooks, rules, and MCP conventions for engineering teams. It provides PostToolUse, PreToolUse, PreCompact, SessionStart/End, and Stop lifecycle hooks along with operator workflows integrated directly into Claude Code.

Claude-mem is a memory compression system for Claude Code that persists context across sessions through automated archival and retrieval of conversation state. It integrates via lifecycle hooks and shell commands to maintain searchable memory without external API dependencies.

ruflo-core is a foundation Claude Code plugin that registers the ruflo MCP server (314 tools) providing memory, embeddings, hooks, neural networks, autopilot, browser automation, agent orchestration, and system access, plus 4 generalist agents and 5 helper skills for plugin discovery and project initialization. It implements cross-cutting contracts for session management, 3-tier model routing, and a curated catalog of 32 sibling plugins with 7 architecture decision records.

Context Mode is an MCP server that reduces context consumption by 98% through sandboxed code execution across 11 languages and maintains session continuity using FTS5-indexed SQLite tracking with automatic BM25 ranking on compaction. It enables agents to analyze data by writing scripts rather than reading raw files into context, and preserves task state and decisions across conversation resets without dumping data back into the window.

Ouroboros sits in front of Claude Code as a plugin that clarifies vague coding requests through an interview before generating specifications, blocking spec generation until ambiguity scores pass a threshold. It redacts verification commands and expected-output assertions from the contract given to the worker, asking instead for the outcome to enable self-improving, replayable AI coding workflows.

autoharness is a self-learning skill layer for Claude Code that automatically discovers, merges, and validates skills learned from real agent sessions rather than offline benchmarks. It maintains a clean skill library by pruning unused skills and updating actively-used ones, touching only the skills it generates itself.

SocratiCode provides semantic code search, dependency graph analysis, and context artifact exploration to give AI assistants deep understanding of entire codebases with zero configuration and no external API keys required. It works as a Claude Code plugin, MCP server, or VS Code extension, automatically indexing code at scale and keeping the index updated through file watchers across sessions.

Official Expo plugin providing 24 AI agent skills for building, deploying, upgrading, and debugging Expo apps across React Native, iOS, and Android, with clear separation between open-source framework skills and paid Expo Application Services (EAS). Connects to mcp.expo.dev and includes navigation, animations, design systems, data fetching, native modules, App Store submissions, EAS Build/Update/Observe, and remote simulator capabilities.

Five live-detection skills for Databricks workspace diagnostics—cost-leak-hunter, cluster-forensics, uc-migration-pilot, streaming-guardian, and bundle-medic—that run real queries and API calls against your workspace via the databricks-workspace-mcp server. Each skill audits specific Databricks components (billing, cluster events, Unity Catalog readiness, streaming health, and asset bundles) and degrades to advisory mode when the MCP is unavailable.

ServiceGraph is a metrics-enriched business dataset API that ships 18 agent skills to search and filter agencies, directories, newsletters, and product-launch platforms with a unified DSL and credit-based access model. The plugin includes a branded entry point that works against any dataset plus 14 specialized skills for US professional services (law, marketing, design, consulting, accounting, IT, engineering, HR, PR, cybersecurity, and more) and 3 product-directory skills for software launches and backlink opportunities.

This Claude Code plugin provides integration with Stripe's development capabilities through MCP, enabling developers to interact with Stripe APIs directly within Claude. It includes 10 skills, 1 agent, and 2 commands for managing Stripe operations, with shell execution support and multiple hook points for workflow automation.

This plugin integrates the Azure MCP Server and 38 curated Azure skills to enable Claude Code agents to manage Azure infrastructure, deploy resources, and troubleshoot cloud services with structured decision-making and guardrails. It provides 200+ tools across 40+ Azure services including deployment workflows, diagnostics, cost optimization, AI/ML, identity management, and Foundry integration.

The salesforce-development plugin provides AI-powered Salesforce platform development in Claude Code, auto-detecting your environment and injecting org context to enable natural-language creation of Apex code, metadata, flows, deployments, and security configurations. It combines 37 skills, the Salesforce CLI, and Salesforce-hosted MCP servers to resolve capabilities across metadata, deployment, reporting, and org lifecycle management.

deja-vu indexes past coding sessions across 34 supported agents (Claude Code, Cursor, Qwen, OpenClaw, Copilot) and surfaces relevant context automatically using local BM25 search before you ask, with credentials redacted at index time. The plugin integrates via 5 hooks (SessionStart, PreToolUse, PostToolUse, PreCompact, UserPromptSubmit), an MCP server, and a /deja command to query your session history without external APIs or embedding services.

This plugin enables Claude to build and modify Power Apps Canvas Apps by connecting to an app open in Power Apps Studio via the Canvas Authoring MCP server. The agent can create screens, configure controls, set up formulas, manage connectors, and define data sources directly within the Power Apps environment.

This plugin scaffolds and deploys Power Apps mobile applications using Expo and React Native, enabling developers to build native mobile experiences that connect to Power Platform data through Microsoft's native host package. It automates app generation, screen design, native capability configuration, and connector wiring via agent-driven skills that integrate with Azure authentication and Entra app registration.

The model-apps plugin builds and deploys complete model-driven Power Apps end to end, with /app-builder generating whole apps (tables, relationships, forms, views, charts, security roles) from natural language and /genpage creating generative pages using specialist agents for planning and parallel code generation. It requires PAC CLI > 2.10.0, Azure CLI, and Node.js LTS, integrating with Power Platform via the vendored cds-maker-sdk and leveraging feature flags for experimental capabilities like custom API calls and telemetry.

Build, edit, run, and debug Power Automate cloud flows directly from Claude Code using the FlowAgent MCP server, with support for surgical edits, environment copying, run management, and expression validation. The plugin runs offline with a self-contained MCP engine and uses local Azure CLI authentication, requiring only Node.js 18+.

A comprehensive Claude Code plugin for creating and deploying Power Pages code sites (SPAs) using React, Angular, Vue, or Astro, with integrated workflows for data modeling, backend integration, authentication, and ALM orchestration. The plugin provides 35 AI-driven skills covering the full lifecycle from scaffolding and development to deployment, testing, and cross-platform migration, leveraging Node.js, PAC CLI, and Azure CLI.

This plugin provides 7 skills for designing, building, deploying, testing, and debugging AWS Serverless applications using SAM and related tools. It includes an MCP server and shell integration for hands-on serverless development workflows.

This plugin provides expert guidance on the AWS database portfolio, helping developers design schemas, execute queries, and choose the right database for their workload. It leverages MCP servers and AWS knowledge integration to assist with database design and migrations.

This Claude Code plugin analyzes codebases and generates AWS infrastructure deployments with cost estimates, CDK/CloudFormation IaC, and draw.io architecture diagrams using official AWS4 icons. It connects to three AWS MCP servers for real-time pricing data, IaC best practices, and architecture guidance.

Unbrowse replaces WebFetch, WebSearch, and browser MCPs with a hosted cloud browser MCP that supports scraping, discovery, and saved logins via hooks that intercept tool use and session start. The plugin requires authentication via OAuth or API key and redirects browser operations to Unbrowse's cloud endpoints instead of local tools.

The dxos plugin integrates DXOS Composer as an MCP server for Claude Code, enabling durable project and task tracking via `/dxos:project` command and QA test execution via `/dxos:qa`. It maintains a committed registry of work-streams and per-project TASKS.md ledgers, with optional cloud backend support through a Composer account with passkey authentication.

A Claude Code plugin that orchestrates full album production from concept to release, coordinating research, lyrics, Suno music generation prompts, audio mastering, and promo materials through 53 specialized skills and an 80+ tool MCP server. Multi-model coordination routes creative tasks (lyrics, concepts) to Opus, reasoning work to Sonnet, and mechanical operations to Haiku.

Episodic Memory enables semantic search across Claude Code, Codex, Cursor, opencode, and Oh My Pi conversations, allowing AI assistants to recall past discussions, decisions, and architectural patterns to provide more informed suggestions across sessions. The plugin automatically indexes conversations at session end and exposes natural language search capabilities through MCP tools to find relevant context even when exact keywords weren't used.

Maestro is a multi-agent development orchestration platform that coordinates 39 specialist agents through a 4-phase workflow (design dialogue, design review, implementation planning, and execution) with native parallel subagent dispatch and persistent session management. It provides standalone commands for code review, debugging, security audits, performance analysis, SEO audits, accessibility audits, and compliance checks, all powered by a Node-based MCP server.

A Claude Code plugin and agent skills toolkit that teaches Claude to author, validate, and visualize Open Knowledge Format (OKF) bundles—portable markdown knowledge with YAML frontmatter that humans and agents can both read and maintain. Includes a deterministic conformance checker, interactive graph renderer, GitHub Action support, and an MCP server for read-only knowledge access.

AI Team OS transforms Claude Code into a multi-agent team operating system with 155 MCP tools, 25 agent templates, persistent task management, and autonomous loop execution across lifecycle hooks. It coordinates complex projects through team orchestration, task walls, meetings, memory store, and a company-style execution engine with health monitoring and self-healing capabilities.

This Claude Code plugin provides agent skills and a hosted MCP server for deploying, configuring, monitoring, and troubleshooting applications and infrastructure on Railway, including management of services, environments, deployments, databases, object storage, networking, and observability. It runs a shell-based hook before tool use and connects to the Railway MCP server at mcp.railway.com to enable Railway operations directly from Claude Code.

Sage is a lightweight security layer that intercepts tool calls (shell commands, URL fetches, file writes) and checks them against multiple threat detection layers including URL reputation, local heuristics, prompt injection detection, and supply-chain checks before execution. It integrates with Claude Code and other AI coding assistants via hooks that monitor PreToolUse, PostToolUse, and SessionStart events to prevent dangerous actions.

Lumen is a 100% local semantic code search engine for Claude Code that indexes your codebase using Go AST parsing and embeds code with Ollama or LM Studio, reducing API costs by up to 39% and token usage by up to 66% compared to baseline AI coding workflows. It exposes vector search through an MCP server with no cloud dependency, external API keys, or npm requirements.

This Claude Code plugin provides AI agents with a relational knowledge graph of the Vercel ecosystem and a bundled skill library covering Vercel products, APIs, and workflows for building and deploying web applications. It includes 49 skills, 3 agents, commands, hooks, and an MCP server that integrate with mcp.vercel.com to enable deployment, authentication, caching, and infrastructure management.

Sidequest is a self-hosted Kanban board and orchestration system for Claude Code that persists tasks across context compaction and sessions, automatically routing tickets to executors for verification and review. It provides a local dashboard for planning, tracking, and delivering work with categories, dependencies, and discussion threads that survive chat context shrinking.

Maister provides structured, standards-aware development workflows for Claude Code through 25 agents and 17 skills that enforce best practices and safety guardrails. It includes pre-execution hooks to block destructive commands and shell reminders to keep developers aligned with workflow standards.

Claude Code plugin that packages 29 agentic skills for Meta Quest and Horizon OS development, powered by the metavr CLI and MCP server for device management, app debugging, performance analysis, and store submission workflows. Skills cover Quest app setup, Unity/WebXR integration, Spatial SDK, Platform SDK, and XR-specific debugging and optimization tasks.

This Claude Code plugin provides 14 curated agent skills for CesiumJS v1.143 development, covering ~551 public symbols across domains like 3D tiles, imagery, terrain, camera control, and spatial math. The skills integrate with Claude Code and follow the open Agent Skills standard for browser-based iteration via Chrome DevTools.

The VGV AI Flutter Plugin is a Claude Code plugin with 15 best-practices skills covering Flutter and Dart development (accessibility, animations, BLoC, testing, theming, navigation, security, internationalization, layered architecture, license compliance, UI packages, SDK upgrades, and more) plus an autonomous quality-gate loop that drives code analysis, formatting, testing, and coverage to green. It runs locally via bash, dart, and the very_good CLI without requiring API keys or external paid services.

A Claude Code plugin delivering 15 best-practices skills and a Flutter reviewer agent for accelerated Dart/Flutter development, including accessibility, animations, testing, BLoC, theming, security, and an autonomous quality-gate loop that drives code to green. The plugin requires the Very Good CLI and Dart toolchain, enforces standards via pre/post hooks, and includes a specialized reviewer agent for security and accessibility auditing.

Ultraship is a Claude Code plugin with 45 skills, 13 agents, and 37 audit tools for building, shipping, and scaling production software—covering accessibility (WCAG 2.2), security scanning, code quality, SEO, AI readiness, and bundle analysis. A built-in Currency Guard keeps Claude on current docs rather than stale training data, with a blocking ship-gate scorecard that runs six parallel audits (SEO, accessibility, secrets, code profiling, bundle tracking, env validation) before deployment.

Agentic-Security automatically scans code for security vulnerabilities (SAST, SCA, secrets detection) using plain-English risk explanations with cost estimates, and can automatically verify and apply fixes before they touch disk. It integrates directly into Claude Code as a plugin or runs standalone via CLI with multiple output formats (HTML, JSON, SARIF, CSV).

This Claude Code plugin provides persistent memory for sessions through a local Honeycomb daemon, enabling Claude to retain context across interactions without external API dependencies. It integrates via lifecycle hooks and an MCP server to automatically save and recall session state.

Alfred Dev is a software engineering automation plugin that orchestrates the development lifecycle with 10 specialized agents (8 core plus conditional frontend and on-demand agents), persistent project memory, and quality gates across product, architecture, development, QA, security, and deployment phases. It detects project stacks and adapts artifacts to Node.js, Python, Rust, Go, Ruby, Elixir, Java, PHP, C#, and Swift ecosystems with built-in EU compliance (GDPR, NIS2, CRA) and verification gates before each phase transition.

Matrix gives Claude Code persistent memory and deep code intelligence through semantic search and tree-sitter indexing across 15 languages, with hooks for pre-emptive issue detection and code review. Features include solution recall, symbol navigation, CVE warnings, and dead code detection—all stored locally with no external API calls.

ALDC is an AI-native development toolkit for Microsoft Dynamics 365 Business Central that provides 5 specialized agents, 10 workflows, and 15 knowledge skills for extension development with test-driven development, architecture reviews, and human-in-the-loop gates. The plugin integrates event-driven architecture patterns, automated code generation, and TDD orchestration through a conductor agent that manages the full spec-to-review cycle.

ALDC is an AI-native development toolkit for Microsoft Dynamics 365 Business Central offering 10 agents, 15 knowledge skills, and TDD-driven workflows for extension-only development with code review, event-driven architecture patterns, and human-in-the-loop gates. It includes specialized agents for architecture, development, test-driven delivery, pre-sales estimation, and agent building, plus MCP servers for AL symbol resolution and documentation lookup.

opentrace-oss is a Claude Code plugin that exposes a knowledge graph for exploring system architecture, code structure, and service dependencies through graph query tools. Once a codebase is indexed, users can ask Claude questions about code structure, dependencies, and architecture using specialized agents like @code-explorer, @dependency-analyzer, and @find-usages.

VGV Wingspan is an AI-native workflow plugin that orchestrates a four-phase development cycle—brainstorm, plan, build, and review—with specialized agents and skills following Very Good Ventures best practices. It integrates code generation, testing, quality review, and PR management into a structured agentic system designed to work alongside the Very Good AI Flutter Plugin for production-grade output.

Ship is an agentic development harness that routes Claude or Codex through mechanically enforced quality gates—from raw requirements to green PR—making failure modes like skipped tests and unvalidated code structurally impossible. It provides 11 atomic skills (design, dev, E2E, review, QA, refactor, handoff, and more) that work standalone or as a full staged workflow with isolated phases, disk-resident state, and hierarchical evidence requirements.

This plugin integrates PostHog analytics, feature flags, experiments, error tracking, and insights directly into Claude Code through an MCP server, with optional session capture to PostHog LLM Analytics. It provides 27+ tools bundled with 30+ task-specific skills covering HogQL queries, A/B test management, feature flag operations, data warehouse setup, and SDK instrumentation.

Grainulator is a research sprint orchestrator for Claude Code that conducts multi-pass investigations with typed claims, evidence tiers, tension detection, and confidence scoring to produce compiled, high-confidence answers in under 60 seconds. It structures research findings as factual, constraint, risk, recommendation, or estimate claims, detects contradictions, and synthesizes results through a 7-pass compiler that grades evidence strength and produces 0-100 confidence scores.

winnow is a context optimization plugin for Claude Code that intelligently filters large tool results (Read, Bash, Grep) by using a fast System One model judge to identify irrelevant blocks, replacing them with summaries and recall keys to save tokens. The plugin operates as a function hook that intercepts tool results before they enter Claude's context, allowing full text to be recovered on demand while keeping the conversation focused on what matters.

ResumeHQ is an AI-powered resume builder that discovers live job listings, scores candidate fit using deterministic engines (not LLM guessing), and auto-tailors resumes with a fail-closed auditing pipeline that refuses to fabricate experience. It produces Workday-compatible DOCX output, generates cover letters, and auto-detects 6+ professional domains while publishing its own scoring benchmarks including failures.

Claude Gladiator hooks into tool execution to observe failure patterns and prompt reflection before session ends, using an MCP server to cluster observations into learning recommendations. It runs silently on success and only processes errors, with minimal token overhead (~100-200 per session).

Claude Historian automatically searches past sessions before web research, planning, and debugging to avoid redundant work. It uses an MCP server to inject history-checking logic at key decision points, reusing prior solutions and decisions when available.

Claude Oracle automatically discovers skills, plugins, and MCP servers across 17 community sources by searching at high-impact moments like planning and error recovery. It integrates via hooks that trigger search before planning and after errors, returning install commands for immediately relevant tools.

Claude Orator is a prompt optimization coach that deterministically scores and restructures prompts using Anthropic best practices without making LLM calls or network requests. It runs as a PreToolUse hook to suggest improvements for under-specified subagent prompts and includes a command for manual prompt optimization across 7 dimensions (clarity, specificity, structure, context, examples, constraints, tone).

Claude Praetorian automatically preserves conversation context by prompting to save and restore valuable context at strategic moments—before planning, after research, and when subagents complete. It integrates with an MCP server to manage context compaction and restoration across Claude Code sessions, reducing token usage by 50–60%.

Claude Vigil creates file checkpoints before destructive bash operations (rm, mv, git reset) and provides tools to diff changes and restore files safely using content-addressable storage. Commands and MCP tools let users manually save named snapshots and restore from them on demand.

This plugin analyzes Shen Lun (申论) examination materials, provides corrective feedback on responses, and assigns structured scores while enforcing safe execution. It integrates Python3-based processing through an MCP server and a PreToolUse hook for validation.

Wenlan is a local-first knowledge base that agents build autonomously as they work, capturing learnings as source-cited wiki pages that persist between sessions. All data lives on your machine under ~/.wenlan, with memories and pages served by a local daemon that never shares content with Anthropic or external services.

Wenlan is a living knowledge base that agents build during work sessions, with learned insights automatically converted into source-cited wiki pages that persist across threads. Each new session starts with the latest accumulated knowledge from previous agent work.

code-graph-mcp auto-indexes your codebase as an AST knowledge graph to enable semantic search, call graph traversal, HTTP route tracing, and impact analysis through MCP tools. The plugin hooks on SessionStart to initialize and expose these code navigation capabilities via an integrated agent.

Wenlan is a living knowledge base that agents build and maintain as they work, automatically creating source-cited wiki pages that persist between sessions and refresh with new discoveries. Each new thread starts from the latest accumulated knowledge, allowing agents to leverage previous learnings and context.

Summer SDK provides 78 game-dev skills, lifecycle hooks, and a 62-tool MCP bridge that connects AI agents to the Summer Engine for building real 2D and 3D games through conversation. The plugin integrates with Claude Code, Cursor, Codex, Devin Desktop, and other AI agents through a single npm package with MIT open-source tooling.

Codemem provides persistent memory for Claude Code by capturing work across sessions through hooks that trigger on session and tool events. It lets you recall relevant context from previous interactions to maintain continuity and context awareness during code development.

Craft is a Claude Code plugin that enforces a read-only codebase by default, routing all changes through a Write Gate as planned work, while maintaining a local history of project decisions and design tokens that help Claude learn your architectural preferences over time. It ships with 62 commands, 27 agents, 11 skills, and a dashboard that visualizes your project's evolution as an interactive galaxy of interconnected work.

This Claude Code plugin grounds all RuvNet-related decisions in real source code from 77 RuvNet repositories, injecting retrieval-augmented generation via a search_ruvnet tool and hooks that enforce grounding before RuvNet product code is used. It ships 6 commands, 9 skills, 12 hooks, and 1 MCP server to steer Claude toward Ruflo, RuVector-RVF, and AgentDB instead of training-prior defaults like pgvector and Pinecone.

total-agent-memory provides persistent, local memory for Claude Code and other MCP clients through a temporal knowledge graph, procedural memory system, and AST codebase ingest that tracks facts, decisions, and working practices across sessions. It installs as an MCP server with capture hooks that fire on session start/end, tool use, and user input to build and query a searchable local-first knowledge base with optional grounded retrieval and revision history.

Tool Executor is a configurable MCP wrapper that consolidates 96 tools from 7 example servers into 3 discoverable commands (search_tools, get_tool_schema, execute_code) with semantic search and sandboxed TypeScript execution. It reduces token consumption by 97% through lazy loading and batched execution, bridging the gap between the API's programmatic tool calling and Claude Code's serial execution model.

SuperClaude for SAP (sc4sap) is a Claude Code plugin providing 28 specialized agents and 17 workflow skills for end-to-end SAP ABAP development, connecting directly to SAP systems via MCP to create, analyze, and manage ABAP objects with multi-environment profiles and built-in security controls. It supports SAP ECC, S/4HANA On-Premise, and S/4HANA Cloud with Clean ABAP review, program generation with Phase 4/6 hardening, package-to-process business documentation, and 14-module consultation across retail, automotive, pharma, and other industries.

A Claude Code plugin that routes Siemens TIA Portal engineering automation tasks to 19 specialized skills covering Python TIA Scripting V1.4.3, C# Openness API domains, Modular Application Creator workflows, and Add-In development. It includes MCP write-safety hooks, diagnostic tools, and integrates with TIA Portal V21 via an MCP server for direct interactive automation.

ClawCode extends Claude Code as a persistent agent plugin, adding memory, personality, voice, and messaging across WhatsApp, Telegram, Discord, iMessage, and Slack with bilingual recall and lifecycle hooks. It runs entirely within Claude Code's plugin system with no separate billing, featuring nightly memory consolidation, slash commands, webhooks, and an optional always-on background service.

claude-mem-lite is a persistent memory system for Claude Code that automatically captures coding decisions, bugfixes, and context across sessions using MCP hooks and stores them in a single SQLite database with FTS5 full-text search. It achieves 7-10× fewer LLM calls and ~600× lower estimated cost than the original claude-mem by batching episodes and using a smaller model, with zero external services.

This plugin integrates the ase (Agentic Software Engineering) tool into Claude Code, enabling 10 agents and 54 skills for automated software engineering tasks. It provides hooks into the development lifecycle (pre-tool use, session management, user prompts) and includes shell execution capabilities.

ArmorClaude is a Claude Code plugin that enforces intent-based security by intercepting user prompts to capture a declared plan, then verifies every tool call against that plan before execution and logs all actions for audit compliance. It supports policy-based access control with data classification rules (PCI/PII), optional CSRG cryptographic proofs, and runs in a fail-closed mode where all tool calls are blocked if planning, identity, or token verification fails.

KRouter is a Claude Code plugin that provides shared agent memory backed by plain Markdown files in Obsidian, allowing agents to cite sources and refuse to guess when information is unavailable. It integrates with Claude Code, Codex, Cursor, and DeepSeek through MCP, automatically imports session history, and keeps an indexed vault that multiple agents can query and update.

This plugin provides 13 skills for coding agents to query data and build semantic models through the Honeydew MCP, enabling natural-language questions about metrics, entities, and warehouse data. It integrates with multiple coding agents including Claude Code, Codex, and GitHub Copilot CLI to help users explore semantic layers, create business concepts, and analyze anomalies.

BetterCallClaude is a Swiss legal intelligence plugin that integrates BGE/ATF/DTF precedent research, case strategy, legal drafting, and citation verification for all 26 Swiss cantons with built-in Anwaltsgeheimnis privacy protection. It provides 27 commands across 21 agents for legal research, litigation strategy, document analysis, and multi-language legal translation (German, French, Italian, English).

DJ Claude is a live music engine that enables multiple Claude Code agents to jam together in real-time over HTTP, layering drums, bass, melody, and more with conductor mode and 22 presets. It requires no browser, API key, or external services—all music generation works out of the box via presets, vibes, or direct Strudel code.

Whetstone is an AI-powered development plugin with 18 agents, 22 commands, 32 skills, and 1 MCP server that automate code review, research, design, and workflow tasks across multiple programming stacks. It includes specialized agents for accessibility, security, performance, cloud architecture, database validation, Figma design sync, and deployment verification, with commands ranging from autonomous full-stack engineering (`/ia-lfg`) to targeted verification and documentation workflows.

Kindex is a persistent knowledge graph that indexes conversations and projects to provide AI coding agents like Claude Code, Cursor, and Gemini with continuous context across sessions. It captures relationships and constraints from intellectual work, exposing 50+ native tools through an MCP server to inject relevant context based on token budgets.

Consort is a spec-first, test-driven agent framework that orchestrates multiple AI roles through deterministic state machines to build transactional application backends on Lakebase (Databricks' serverless Postgres database), with every code change tested against a real, isolated database branch and human-approval gates that fail closed. It enforces engineering discipline through immutable test contracts and independent review, not suggestions, ensuring that "green" means a real test passed on a live database—not just an agent's claim.

mimirs is a persistent project memory system for AI coding agents that uses semantic search, AST-aware chunking, dependency graphs, and conversation history to help agents retrieve relevant code and context without burning tokens on irrelevant files. It runs entirely locally with bun and SQLite, requiring no API keys or external services, and has been benchmarked to reduce token usage by 76% while maintaining 90–98% search recall across codebases.

Gnosis MCP is a zero-config knowledge base server that indexes local documentation (Markdown, git history, crawled websites) and serves semantic+keyword hybrid search to Claude via MCP, typically reducing token consumption 5–10× per lookup. It stores data locally in SQLite by default or PostgreSQL at scale, with no cloud dependencies or API keys required.

This Claude Code plugin scaffolds Mercado Pago payment integrations (Checkout Pro, Checkout API, Bricks, QR, Point, Subscriptions, Marketplace, Wallet Connect, Payouts, SmartApps) via an orchestrator agent with four specialized skills: mp-integrate (wizard), mp-webhooks (HMAC validation), mp-test-setup (test credentials), and mp-review (security audits). Scaffolding works offline using bundled contracts; live operations like credential import and webhook registration connect on demand via the official Mercado Pago MCP server without requiring upfront API key setup.

This plugin indexes local documents (PDFs, Word docs, markdown, CSV, PowerPoint) into a vector database and performs semantic search with natural language queries in English or German, including hybrid keyword+vector search and source citations. It runs entirely offline with no API keys or cloud dependencies, using local embedding models and LanceDB for storage.

This Claude Code plugin provides 11 skills, 2 agents, and 1 command for querying and analyzing Honeycomb observability data, including production investigations, SLO tracking, and OpenTelemetry instrumentation guidance. It integrates with the Honeycomb MCP server to enable workflow automation around pattern detection, incident analysis, and Beeline migration tasks.

This plugin enables developers to build and deploy Prismatic custom components, Code Native Integrations, and embedded marketplace experiences directly from Claude. It provides commands, agents, and skills for managing the full development lifecycle of Prismatic integrations using Node.js and npm.

This Claude Code plugin enforces quality gates for 1C:Enterprise (BSL) development by blocking session completion until code-quality checks pass, analyzing changes across three axes (volume, code archetypes, complexity) to determine review depth. It produces human-readable findings and machine-readable evidence trails showing what was checked, what was skipped, and coverage across static analysis, development standards, SOLID/GRASP architecture, metadata XML integrity, and file hygiene.

NEXO Brain is a local cognitive runtime that gives Claude Code persistent memory, overnight learning, and self-healing background job execution through an MCP server and 8 lifecycle hooks. It tracks session state across multiple MCP clients, learns from corrections, and includes startup preflight diagnostics and optional dashboard integration.

supertool batches multiple file operations (reads, greps, globs) and git/GitHub queries into single round-trips to reduce token consumption and API costs in Claude Code runs. It includes session-start injection and optional enforcement mode to block competing tools.

Galyarder Framework is an open-source agent operating system that routes high-level business intent through 45 specialized agents, 157 skills, and 25 commands to produce governed, verified execution across engineering, marketing, product, security, legal, and finance domains. It bridges strategy to implementation via structured intent intake, department routing, blueprinting, specialist execution, operational auditing, and artifact generation—with built-in review gates, audit trails, and human-directed control throughout.

H·AI·K·U is a Claude Code plugin that orchestrates AI workflows through structured stages with role-based "hats," completion criteria, and adversarial review gates, keeping state on disk to survive context resets. It provides 31 skills across multiple pre-built lifecycle templates (Studios) for engineering, go-to-market, and general-purpose work, with hooks for PreToolUse and PostToolUse events.

This Claude Code plugin connects iMessage to your Claude Code session via an MCP server powered by the Linq API, allowing two-way messaging where inbound texts are forwarded to Claude and Claude can reply, react, or edit messages. It includes built-in access control with pairing codes, allowlists, and configurable policies to manage who can message the assistant.

RTFM is a local, open-source retrieval layer that indexes code, documentation, PDFs, and other project files into a searchable SQLite database, exposing search and expansion capabilities via MCP for AI agents to find relevant context without grepping or hallucinating. It runs entirely offline with no API keys or cloud dependencies, offering full-text, semantic, and hybrid search through a Claude Code plugin or standalone MCP server.

SpecLock enforces project constraints written in CLAUDE.md, AGENTS.md, and .cursorrules files using semantic conflict detection, Git hooks, and MCP tools that intercept Claude Code writes, edits, and bash commands before execution. It operates in advisory mode by default and can be switched to strict blocking mode to prevent AI agents from violating explicit project rules through keyword matching, synonyms, and indirect action detection.

SFAgent Tools is a Claude Code plugin that automatically generates and executes comprehensive test scenarios for Salesforce Agentforce agents, running headless conversations, validating behavior against business rules, and producing scored reports with improvement recommendations. It reads an agent's configuration, designs test cases for topics and edge cases (including guardrail testing), conducts real multi-turn conversations, and delivers structured evaluation results without manual YAML setup.

RepoPilot snapshots your repository before a Claude session starts and reviews all changes before the agent stops, blocking any session that skips tests, removes auth/error handling, or lets untrusted input reach dangerous sinks. The plugin runs deterministically and locally using the repopilot CLI via Git hooks and an MCP server, requiring no external API keys or services.

memo provides persistent, searchable memory for AI coding agents entirely on your machine using MLX embeddings on Apple Silicon or sentence-transformers on Linux, with markdown files as the source of truth and SQLite-vec for indexing. It reduces context overhead by 68% compared to full MCP surfaces while enabling time-machine queries, contradiction detection, and autonomous optimization via the "dream" pipeline.

Yggdrasil provides a local-first, persistent memory system for AI coding agents that persists decisions, lessons, and project status across sessions, tools, and projects with zero external dependencies. It injects automatically at session start and allows agents to recall and share context from previous work without re-explanation.

RocketSmith is an end-to-end model-rocket toolchain that orchestrates OpenRocket (flight simulation), build123d (parametric CAD), and PrusaSlicer (FDM slicing) to let agents design, simulate, and build rockets. It closes the loop by feeding real printed-part weights back into the simulation for post-build stability verification.

Claude-cognis adds persistent memory to Claude Code sessions, automatically loading relevant context at session start and saving conversation summaries when sessions end. It uses semantic search, codebase indexing, and personal/team memory scopes to help Claude maintain continuity across projects and work sessions.

rag-rat is a local repository intelligence plugin that bundles an MCP server with semantic search, symbol navigation, and impact-surface analysis, plus hooks that automatically install a version-matched binary on first use across Claude, Codex, Cursor, and VS Code. The plugin provides git/GitHub integration with a source-anchored memory graph and requires only Node.js, handling all environment setup transparently.

This Claude Code plugin enables AI-to-AI collaboration by orchestrating multi-provider code reviews and debates across Codex, Grok, Antigravity, Ollama, and Gemini through a unified skill corpus deployed to Claude Code, Cursor Agent, and Pi. It bundles MCP server configurations and provides adapters for host-specific workflows including code pairing, verification, and cross-LLM brainstorming.

This plugin provides personalized AWS guidance for startups, drawing on patterns from 350,000+ startups to advise on architecture, cost, security, and migration across multi-account and multi-region environments. It includes startup eligibility checks for AWS Activate credits and access to 60+ exclusive startup offers, built by AWS Startup Solutions Architects.

pty-mcp is an MCP server that provides interactive pseudo-terminal (PTY) sessions for AI agents, enabling local shell execution, SSH connections, serial port access, and persistent remote sessions. The plugin integrates via a SessionStart hook and includes one skill for managing terminal interactions.

ARIA captures session insights, decisions, and feedback into a governed, tag-indexed knowledge base that actively shapes development via change-decision hooks, contextual retrieval, and codebase mapping. The plugin enforces a five-phase lifecycle (capture → govern → promote → apply → refresh) and integrates with 10+ work-management and communication platforms via MCP servers.

curiosity-stack is a structured research thinking tool that decodes technologies and market signals into actionable business insights by walking users through six layers of systematic questioning — from the initial signal through root causes and industry solutions to named companies and the research landscape. It integrates with enterprise tools and can autonomously track watchlist topics, compare decompositions over time, and find Indian market proxies for global companies.

Roast-my-design-system scans your repository to audit design system health, generating a deterministic score backed by detailed findings on colors, spacing, component duplication, and inline styles. It benchmarks your repo against 119 public repositories and 10 reputable design systems, then produces a shareable HTML report with ranked fix recommendations.

Semgrep Guardian scans agent-generated code for security vulnerabilities using Semgrep's static analysis engine integrated as a Claude Code plugin. It monitors tool usage before and after execution, checking generated code at session start, end, and stop events to catch security issues early.

A Claude Code plugin that auto-discovers and orchestrates 14 agents and 4 skills at runtime, routing tasks to specialists across MCP servers (context7.com, exa.ai, grep.app) and six hook event types. It integrates upstream open-source agent frameworks (Oh My Claude Code, Everything Claude Code, gstack, superpowers) and tools for token tracking, language server integration, and multi-provider agent routing.

beady-eye wakes Claude Code sessions when watched beads change status, become ready, receive comments, or are removed, enabling reactive workflow automation for pull-request and agent management. It integrates via a PreToolUse hook and MCP server to monitor bead state changes and trigger agent actions.

Soleur is a comprehensive AI organization system with 68 specialized agents across engineering, finance, marketing, legal, operations, product, sales, and support that learns from every decision to improve future work. It provides a structured 6-step workflow (brainstorm → plan → work → review → compound → ship) accessible via `/soleur:go` commands, with 102 skills and integration hooks for knowledge accumulation.

A comprehensive Claude Code plugin for Tray e-commerce API integration, providing 36 skills, 11 agents, and documentation for 150+ endpoints including OAuth flows, webhooks, and best practices. It accelerates development for partners and community members building applications on the Tray platform.

This Claude Code plugin orchestrates an issue-to-PR workflow that fetches tickets from Jira, Linear, GitHub Issues, or Azure DevOps, optionally pulls linked Figma designs, implements the solution with mandatory plan approval, enforces >95% test coverage and security review, generates e2e tests, opens a PR, and moves the ticket to review. It is stack-agnostic and detects project conventions from CLAUDE.md and .claude/ configuration files rather than imposing frameworks or test setup.

Hebb is a Claude Code plugin that learns from shell command failures and machine-specific issues, then prevents those failures in future sessions by stopping known-bad commands before they run and offering corrections. It works entirely locally by default, tracks command history through hooks, and optionally syncs learning across machines and AI tools with a free key.

Longhand is a persistent local memory system for Claude Code that captures every tool call, file edit, and thinking block into a searchable SQLite database on your machine. It enables semantic recall across sessions in ~126ms with zero API calls, keeping your full coding history even after Claude Code's built-in session rotation.

MAMA (Memory-Augmented MCP Assistant) lets you save development decisions and checkpoints in a local SQLite database, then retrieves them automatically across Claude Code sessions using hooks and MCP. The plugin tracks decisions with reasoning, provides search capabilities, and injects relevant context when reading files or compacting conversations.

total-recall provides persistent, cross-tool memory for AI coding assistants with semantic search, multi-tiered storage (Hot/Warm/Cold), and token budgeting across sessions and devices. It integrates with Claude Code, Copilot CLI, Cursor, Cline, OpenCode, and Hermes, offering a local web UI for memory management without external API dependencies.

This Wasp plugin enhances Claude Code and other coding agents with integrated documentation, best practices, and configuration tools for developing full-stack web apps using Wasp (React, Node.js, Prisma). It provides skills for framework setup, feature configuration, deployment guidance to Railway or Fly.io, and a development server integration via MCP.

Adjutant is a real-time command post for multi-agent orchestration via MCP, providing a retro terminal dashboard where you can watch agents work, assign missions, and track tasks using persistent messaging channels backed by Beads issue tracking and SQLite. The Claude Code plugin automatically injects an agent protocol (PRIME.md) at session start and context compaction, and offers skills for MCP tools, epic planning, broadcasting, direct messaging, and proposals.

This Claude Code plugin connects to the Kobiton mobile testing platform, enabling you to manage devices, upload apps, run automation sessions, and view test results directly from your AI coding assistant. It integrates with multiple AI assistants including Claude Code, GitHub Copilot CLI, Gemini CLI, Codex CLI, and Cursor, and provides skills for interactive device testing and automation test execution.

agy-plugin-cc delegates code review and investigation tasks to Gemini CLI or Antigravity CLI (agy) as a cross-model engine, exposing Claude Code-native commands for pragmatic review, adversarial challenge, and background job handling. The plugin spawns the engine binary you install locally and operates no intermediary service—data flows directly from your machine to Google's servers via your chosen CLI.

Sema is a content-addressed vocabulary protocol that ensures shared meaning across AI agents by deriving unique identifiers from cryptographic hashes of pattern definitions, enabling agents to detect semantic divergence and halt rather than fail silently. It provides both an MCP server with tools for searching, resolving, and verifying semantic patterns, and a Claude Code plugin with skills that teach agents when to search, mint, embed handles, and verify meaning at boundaries.

URC bridges Codex and Gemini CLIs to Claude's phone-based remote control, letting you command either AI agent from the Claude App via a lightweight, self-managing Haiku relay that runs through tmux. The plugin includes an 11-tool MCP server for cross-CLI coordination and supports both synchronous phone control and asynchronous $0 hook-based passthrough messaging.

Vault PKM integrates Claude Code with Obsidian, providing 20 MCP tools for structured knowledge management including semantic search, graph traversal, and enforced metadata templates. It enables bidirectional knowledge flow across conversations and projects through a unified vault with activity logging, link suggestions, and specialized agents for knowledge capture.

skilltotal is a Claude Code plugin that intercepts package installations via a PreToolUse hook, scanning each package for malicious indicators and suspicious patterns before allowing installation. It automatically denies confirmed threats and prompts for approval on high-risk packages, look-alike names, or packages that failed security checks.

The readable plugin injects a SessionStart hook that makes Claude format replies as styled HTML cards, with automatic tier selection (MCP Apps card server, inline widget kit, or BiDi-safe text) based on available host tools—no configuration needed. Each card loads only the CSS it uses, supports Persian/RTL with per-block direction resolution, and can include charts, tables, figures, screenshots, and looping animations that stay embedded in a single offline file.

This Control Plane plugin provides 30 skills and 2 agents for managing hybrid multi-cloud deployments across AWS, GCP, Azure, and private clouds, including workload deployment, secret access configuration, networking, and Kubernetes migration tasks. It connects to the Control Plane platform via MCP and executes operations through bash commands integrated with Claude's interface.

Design Library is a Claude Code plugin bundling 58 brand design systems (Stripe, Linear, Vercel, Figma, Google, Anthropic, and more), 7 curated design skills covering UI/UX, web guidelines, accessibility (WCAG 2.2), motion design, visual taste, and Lighthouse/Core Web Vitals audits, plus a bundled Playwright MCP for in-browser UI verification. The plugin auto-detects your project type and activates relevant skills via slash commands and natural language integration.

F-MCP Bridge connects Figma designs directly to Claude and other AI assistants through 26 skills and 8 commands, enabling bidirectional design workflows like extracting design tokens, generating React code, and performing accessibility checks—all without sending design data to the internet. Runs locally on Claude Code, Claude Desktop, or Cursor with optional Figma API token support for advanced features like version history and comments.

LoreConvo captures and organizes Claude conversations across Code, Cursor, Codex, and Hermes Agent into a local SQLite database, automatically surfacing relevant context when you switch projects or sessions. It stores episodic and semantic memory with full provenance while keeping your data private on your machine.

CCF is a Claude Code plugin that enforces a context-first, spec-driven development workflow by keeping CLAUDE.md/.claude specifications continuously synchronized with code and grounding design decisions in best practices from Context7 and Microsoft Learn. It provides five slash commands, four analysis/research subagents, shell-based hooks for workflow enforcement, and integration with external knowledge bases—all operating within a single main session to avoid spawning costly separate contexts.

cc-memory is a Claude Code plugin that maintains persistent project memories across compactions and sessions by automatically saving decisions, results, and plans to a local SQLite database with LLM-judged semantic deduplication and reconciliation-on-write. It forces the next session to read a handoff document before responding, enforces a user-intent ledger via a live PLAN.md anchor, and provides FTS5 search and MCP tools for memory access.

CodeLedger tracks token-level costs across Claude Code, Codex CLI, Cline, and Gemini CLI, breaking down spending by project, agent, and skill while separating user coding work from plugin overhead. It provides conversational MCP tools for querying usage, a local dashboard, budget alerts, and cost optimization recommendations based on evidence-based rules.

oddyssey is a CLI toolbox that integrates with OpenTelemetry and Grafana backends to enable Observability-Driven Development, allowing coding agents to observe local and remote application runs and feed insights into spec-driven improvement loops. The plugin provides 4 agents, 9 skills, 7 commands, and 4 hooks to coordinate observability data collection and analysis within the development workflow.

The claude-crap plugin enforces test-driven development by wrapping Write/Edit/Bash tool calls with PreToolUse and PostToolUse gates that verify code quality metrics (CRAP index, Technical Debt Ratio, tree-sitter AST) and SARIF 2.1.0 reports before allowing code writes. It prevents functional code from being written until adequate test coverage exists, backed by 4 skills, 1 MCP server, and hook handlers for SessionStart, PostToolUse, PreToolUse, Stop, and SubagentStop events.

io-guard intercepts calls to file and shell tools, validates and sanitizes potentially dangerous operations, and either fixes safe issues automatically or returns a structured error explaining what went wrong. It integrates via hooks at session start, prompt submission, and before/after tool use to protect agents from unintended file or shell commands.

claudestory enables cross-session context persistence for AI coding projects by maintaining a `.story/` directory that tracks tickets, issues, roadmap, handovers, and notes across Claude Code sessions. The plugin provides 30 MCP tools, CLI commands, and autonomous work execution features so each session builds on the previous one without re-explanation.

Guild turns a single coding session into a self-evolving team of 15 specialist agents organized across engineering, content, and commercial domains, coordinated through a v2 lifecycle (init·ideate·plan·build·qa·ops) with structured decision capture and shadow-mode gating. The plugin provides 110 skills, 3 machinery agents, 22 commands, and 21 hooks to manage brainstorming, team composition, specialist planning, context assembly, dispatch, review, and continuous self-improvement within your project.

oculpm is a Claude Code plugin that integrates with ocul-pm to provide local-first work journaling, project planning, and session tracking through hook bridges and MCP tools that append markdown journals and plans to a project's .oculpm/ directory. It includes skills for journaling, project inception, self-audit, evals, and TDD, and works only in repositories already tracked by ocul-pm on macOS, Linux, and Windows (via Git Bash).

A Claude Code plugin that enables agent coordination through shared blackboard, decision tracking, and context assembly across multiple agents and tools. It provides 9 skills, 2 agents, and 2 commands with hooks into the agent lifecycle to coordinate tool use and session management.

A Claude Code plugin that enforces epistemically rigorous reasoning through 97 sourced patterns from historical figures, routed automatically to 15 problem-shaped skills with commit-time enforcement gates. The system prevents unsourced claims, magic numbers, and untraceable decisions by blocking commits until cited evidence or measurements are provided, making uncertainty and provenance explicit across the agent reasoning lifecycle.

Agent Drugs is a Claude Code plugin with MCP server that injects prompt modifications to alter Claude's behavior, with effects applying immediately and persisting across sessions via Firestore. It provides slash commands (/drugs, /take) and natural language interfaces to activate digital "drugs" that modify AI responses through OAuth-authenticated access to agent-drugs-mcp.fly.dev.

Agent Ping plays sound alerts and shows OS notifications when Claude finishes responding or needs your attention, supporting macOS, Linux, and Windows with zero configuration needed. The plugin registers hooks for four events (Stop, Notification, PermissionRequest, StopFailure) and lets you customize sounds, volume, and notification behavior through an interactive settings menu.

Stream Twitch, YouTube, and Kick directly inside Claude Code with audio playback via mpv and live chat in a tmux pane, while your code editor remains fully functional. Control everything with keyboard shortcuts or slash commands, with support for multiple layout modes and real-time chat from each platform's native API.

CC Commander is a guided AI PM plugin that orchestrates development workflows from planning to shipping, featuring 22 specialist sub-agents, 84 click-first /ccc-* skills, 30 lifecycle hooks with 51 handlers, and 2 bundled MCP servers (context7 and sequential-thinking) plus 16 opt-in via /ccc-connect. It runs natively in Claude Code Desktop, CLI, Cursor, Windsurf, Cline, and Codex with no signup, no API keys required, and MIT licensing.

A comprehensive Convex plugin for Claude Code that bundles backend design skills, a live-scaffolding quickstart tool, code-writing and code-review subagents, and an MCP server for deployment introspection. It steers Claude toward Convex idioms and primitives for building reactive, type-safe backends with schema, real-time updates, authentication, file storage, and scheduled jobs.

dx-aem provides AEM-specific agents and skills for component verification, dialog inspection, screenshot capture, and QA automation across Adobe Experience Manager projects. It bundles AEM MCP and Playwright MCP servers to enable JCR content queries, component dialogs, page management, and browser automation—all integrated into the dx-core development workflow plugin.

Eklavya turns agent generation time into adaptive learning by asking Socratic questions grounded in the code Claude Code just wrote, with mastery tracked in a local knowledge graph. Questions are progressive (Tier 1 through 5), never repeated, and can optionally gate commits until comprehension is demonstrated.

ftk is a frontend development toolkit providing 18 skills and 4 agents for UI/UX design, shadcn/ui components, browser automation, JSON rendering, and Remotion explainer videos. It includes 11 commands for design workflows, prototyping, and integration with Google Stitch AI for AI-powered UI generation.

The JFrog plugin connects Claude Code to JFrog's platform for artifact management, security scanning, and supply-chain governance using Artifactory repositories, package curation, and the Agent Guard MCP server. It provides skills for interacting with Artifactory, CVE lookups, package safety checks, and enforces skill governance policies via Agent Guard to keep AI-driven installs and actions within organizational security boundaries.

nxtg-forge is a governance-native AI development platform providing 33 agents, 24 commands, and 27 skills with comprehensive security controls including 4 blocking guards, Semgrep scanning, and drift detection. The plugin uses hook events for pre/post tool execution and command stop gates to enforce compliance and prevent unintended behavior during agent execution.

This plugin connects Claude Code to the Forge orchestrator's MCP server, enabling access to tasks, knowledge, and drift management features bound to your project root. It integrates via a UserPromptSubmit hook and works as a companion to the nxtg-forge tool, automatically installed when Forge is set up.

This Claude Code plugin records manual tasks that only the user can complete (like approvals or account changes) in a local SQLite database and displays them on a visual task board organized by project. Tasks can span multiple repositories, include exact values and links, and are tracked through a browser-based board, status line integration, or terminal CLI commands.

This Claude Code plugin orchestrates multi-step agent workflows using YAML-defined finite-state machines, handling state transitions, nested sub-workflows, and shell command execution with real-time dashboard visualization. It includes 19 bundled workflow templates and 20 reusable skills, auto-provisioning resources via SessionStart hooks.

ArcKit is an Enterprise Architecture Governance Harness providing 76 slash commands across strategy, architecture, delivery, and assurance within Claude Code, leveraging 31 agents and 6 MCP servers for autonomous research and compliance enforcement. The plugin integrates with AWS, Azure, GCP, and government data sources to guide architecture decisions and maintain organizational standards through automated hooks and interactive guidance.

Persistent, cross-session task management for Claude Code where tasks survive between sessions so work started by one agent can be picked up by another. Built on AgentDB with typed schemas, auto-increment IDs, and virtual filters, providing 20+ MCP tools for full task lifecycle management including planning, specs, implementation, and handoff.

This plugin provides 17 editing skills for the BashCut video editor, covering workflow planning, footage surveying, rough cuts, beat-based editing, audio mixing, captions, color grading, effects, and visual planning. It integrates with BashCut's MCP server and includes specialized agents for surveying and reviewing that run on cheaper models.

captain-memo is a cross-AI local memory layer that integrates with Claude Code, Codex, Gemini, and Cursor through hybrid search and multiple summarizer providers, with a self-hosted embedder option. It replaces claude-mem and uses 5 skills, 7 hooks, and an MCP server to manage context across sessions and tool usage.

A Claude Code plugin that implements a wiki-grounded verification loop (TDD/PDCA/Reflexion) for driving development tasks to completion, with every design decision routed through a bundled semantic-layer knowledge base before code is written. It supports both single-task implementation and multi-session orchestration with parallel workers, automatic knowledge capture, and wiki PR generation for continuous methodology improvement.

DotnetPilot is a Claude Code plugin that provides 29 commands, 14 specialized agents, and Roslyn-powered semantic analysis to catch common .NET mistakes like missing DI registrations, unsafe EF Core migrations, and architecture violations in real time. It includes convention-aware scaffolders, clean-architecture enforcement, DI verification, and project lifecycle management with 16 skill packs backed by an MCP server.

Furl provides context compression for Claude Code by bundling an MCP server (furl_compress, furl_retrieve, furl_stats, furl_purge, furl_search, furl_list tools) and automatic fail-open PostToolUse hooks that shrink large tool outputs while keeping originals byte-exactly retrievable via <<ccr:HASH>> markers. Pull-based retrieval ensures no data is lost—agents can query compressed results to see specific dropped items on demand.

Kauri integrates a deterministic decision database into Claude Code, auto-injecting project decisions at session start and exposing 12 MCP tools for recording, querying, and validating decisions alongside standard editing commands. Post-commit hooks detect stale decisions and alert the agent, while guided skills teach Claude when and how to use Kauri's structured lifecycle semantics.

pptx-craft provides 7 agent skills and a CLI to build native, layered, animated PowerPoint decks with staged quality gates that block progress until content and design pass checks. The plugin generates editable `.pptx` files with real text boxes, separate image layers, and native PowerPoint motion graphics, plus optional MP4 video export with frame-accuracy verification.

Recast for Claude Code integrates the Recast marketing-mix-modeling platform via hosted MCP tools and API skills for reporting, forecasting, optimization, and planning. It authenticates through OAuth with Recast accounts and provides command-driven access to the Reporter, Forecaster, Optimizer, and Plans APIs.

Wakeflow orchestrates multi-window Claude Code sessions across tmux to manage structured work packages from requirements through testing and archival, maintaining explicit on-disk state and audit trails at each step. The Controller window claims and plans work while specialized windows (Design, Target, Test) execute tasks within a disciplined control loop that tracks evidence and gates acceptance on independent validation.

Tagout is a gate-verified issue-to-pull-request lifecycle manager for coding agents that enforces safety checks at destructive steps using named gates that refuse operations and report who locked them. It includes optional tagout-migrate for .NET legacy application upgrades with a seven-phase migration pipeline, roseline gates, and MCP servers for Roslyn-aware code analysis.

CLI Subagents lets you spawn and manage background agents across multiple Claude Code, Codex, or Antigravity instances, each on different accounts with shared MCP servers and configuration. Subagents communicate bidirectionally, handle quota spillover automatically, and run with safety constraints (read-only or sandboxed review modes) all controlled through a single setup.

fakoli-state is a local-first, SQLite-backed project-state layer that turns PRDs into reviewed, lockable work packets for humans and AI agents to coordinate against without conflicts. It exposes 23 CLI commands, 22 MCP tools, and 6 specialized agents (tier-mapped to Opus/Sonnet/Haiku) to manage requirements, task claims with enforced leases, and evidence-backed state across parallel work.

mnema integrates a project's committed decision record and machine-local notes into Claude Code sessions automatically via SessionStart hooks, and connects an MCP server to enable the agent to read additional context and record its own work during editing. It also provides PreToolUse hooks to surface file-specific rules before writes and session tallies to track decisions and file changes.

neo-research turns any topic into structured agent expertise by building a question tree, discovering sources, fetching content to a knowledge store, and distilling targeted excerpts into compact mental models—without bloating context windows. It includes sandboxed Python execution in Docker containers for code analysis, DSPy sub-agents, and REPL-based knowledge distillation.

Delegates coding tasks (implementation and tests) to a local pi agent while Claude writes the task specification and validates results, with enforced discipline modes to prevent Claude from editing production code directly. Integrates via MCP tools (pi_dispatch, pi_status, pi_steer, pi_abort, pi_result, pi_transcript, pi_stats) and hooks that intercept Write/Edit operations in strict or soft modes.

Fetches and sanitizes public web pages and search results with network policy enforcement, URL validation, and content cleanup to reduce attack vectors. Provides MCP tools for fetch, search (via Brave API), and URL checking with configurable rate limits and domain policies.

tagout-migrate is a seven-phase pipeline that automates migration of legacy .NET applications to verified production using RoselineMCP and Roslyn code analysis. It includes the roseline Read gate and roseline + ADR MCP servers, integrating dnx and .NET 10 SDK tooling with shell-based orchestration.

A Claude Code plugin that plans work before editing and routes each step to the most cost-effective model (haiku, sonnet, or opus) with four-way verification. It includes 10 tiered subagents, 9 authoring skills, local MCP tools, and gated fail-open hooks that run shell guards at key lifecycle stages.

agenticos injects contextual brain state into every prompt and automatically captures Claude Code sessions into persistent memory through hooks and an MCP server. It enables telemetry streaming and exposes a vault for managing agent context across sessions.

agent-memory compresses raw LLM tool output into structured observations and manages a shared memory bus across multi-agent systems to reduce token costs by 60-90%. It works automatically as a Claude Code plugin using PostToolUse and SessionStart hooks to store observations and inject only relevant context into prompts.

AgentReverse extracts tools, skills, plugins, and MCP servers from any source (GitHub repos, local configs, articles) and installs them into your agent with security scanning and manifest tracking. It enables cross-agent portability, backup/restore, and environment auditing via CLI commands and an MCP server.

Artibot is a cognitive orchestration framework for Claude Code that integrates 29 specialist agents, 113 domain skills, and an 11-stage runtime middleware pipeline to enable hierarchical memory, verifiable-reward learning (RLVR), and multi-agent team coordination. It features dual-process routing (System 1/2), lifelong learning without external RL optimizers, and built-in MCP server exposure while maintaining data sovereignty on-disk.

ashlr is an open-source Claude Code plugin with 40 MCP tools and 36 commands that reduce token usage by up to 65% through hybrid LLM summarization (Anthropic Haiku 4.5 default with optional ONNX offline processing) and PreToolUse redirect hooks. It includes GitHub OAuth sign-in, automatic genome generation from public repos, per-session token accounting, and supports multiple hosts (Claude Code, Codex, Cline, Claude Desktop, Cursor, Goose).

bbwatch monitors CUHK-SZ Blackboard for new assignments, deadline changes, announcements, and grades while supporting batch course material downloads with local task tracking and incremental updates. It provides a web-based dashboard to view assignments by deadline, mark completion status, search downloaded resources, and trigger manual refreshes.

Concise is a Claude Code plugin that intercepts verbose comments, oversized files, and padded PR/issue descriptions before they're written, offering pluggable em dash and AI writing pattern detection with presets for different teams. The agent reads denial reasons and rewrites flagged content in real time, preventing bloated output from reaching your working tree or GitHub.

This Claude Code plugin specializes Claude in C++26 idioms and standards (ISO/IEC 14882:2026) through an always-in-context skill, reference MCP server, and two-pass verification agent that biases generation toward modern features like reflection, contracts, and senders. It surfaces compiler lag separately from genuine bugs and scaffolds C++26-ready project configuration, keeping recommendations standards-first even when the local toolchain hasn't caught up.

The fizzy Claude Code plugin syncs todo items from Claude Code to Fizzy.do cards, automatically creating cards and steps from your local todo list. It uses a shell-based sync mechanism with hooks and MCP server integration to keep tasks in sync across both platforms.

Multi-account MCP server providing 61 tools for Gmail, Calendar, Drive, Docs, and Sheets with token-efficient compact responses and macOS Keychain-backed refresh tokens. Tools include search, read, create, and collaborative features across all Google Workspace products with optional detailed content access.

Hypermnesia MCP Viz is a read-only visualization layer that renders Claude Code sessions, Cortex memory stores, and codebase graphs as six interactive views: a project galaxy, 3D brain map, execution trace, consolidation kanban, knowledge browser, and wiki. It bridges Cortex's PostgreSQL database and local session archives to provide live reading angles without ever writing memories.

Kabo is a Claude Code plugin that brings creator-focused research skills—like Instagram/YouTube competitor analysis, viral breakdowns, and emerging-creator discovery—directly into Claude Code as downloadable, verifiable skills that run either as main-agent commands or in restricted subagents. It uses a device-flow login stored securely on-machine and fetches creator research data through Kabo's servers without requiring external API keys.

karellen-jdb-mcp is an MCP server that enables Claude Code to attach to running JVMs and debug using JDB with breakpoints, expression evaluation, thread inspection, and class introspection. The plugin includes an exception detection hook that suggests JDB when Java stack traces appear, a guided `/karellen-jdb-mcp:jdb-debug` skill, and an autonomous `jdb-investigator` agent for investigating Java exceptions and deadlocks.

karellen-lsp-mcp provides structured code intelligence to Claude Code via LSP (Language Server Protocol), enabling navigation of definitions, references, call hierarchies, type hierarchies, and diagnostics without reading entire codebases. It operates as both an MCP server and a native LSP proxy that auto-detects languages and transparently integrates with Claude Code, supporting C/C++, Java, Kotlin, Python, and Rust out of the box.

karellen-rr-mcp is an MCP server that integrates rr reverse debugging into Claude Code, allowing you to record failing program executions and replay them with full forward and reverse control via GDB/MI without modifying source code. The plugin includes crash detection hooks, an `/karellen-rr-mcp:rr-debug` skill for guided record-replay workflows, and an `rr-investigator` agent for autonomous crash investigation.

Lodestone is a SQLite-backed MCP server that ingests arXiv papers, code repos, and blog posts into a local searchable corpus, enabling Claude Code to ground research implementations in state-of-the-art papers and code rather than hallucinations. It pairs with the deep-sota plugin to provide paper search, citation traversal, figure inlining, and code-repo reads through 21 MCP tools.

Membase gives Claude Code persistent memory and wiki workflows backed by Membase Cloud, enabling recall of prior context and saving of durable preferences across sessions. The plugin provides automatic context injection, project-aware memory scoping via git repositories, and explicit slash commands for memory search/save, wiki management, and project workflows.

Munin is a long-term memory system for Claude Code that automatically saves project context, decisions, bugs, and solutions using GraphRAG, so developers can retrieve relevant past work and solutions without repeating themselves. It includes automatic session summarization, error catalog lookup, semantic search, and a `@munin` agent for direct memory queries, activated via hooks that monitor sessions and tool usage.

This plugin provides Nix best practices, command patterns, and guidance through 6 skills that Claude automatically references when working with Nix code, plus an MCP server for NixOS/home-manager option searches. It automatically runs `nix fmt` after Claude's responses to format and lint Nix files in Git-tracked projects with a flake.nix.

Opsera DevSecOps Agent provides AI-powered security scanning, compliance auditing, and architecture risk analysis directly from Claude Code, with tools for vulnerability detection, secret detection, SAST, compliance verification (SOC2, HIPAA, PCI-DSS, ISO 27001), and SQL injection detection. The plugin integrates with the Opsera platform via OAuth authentication and reports anonymized telemetry to track security posture and remediation progress.

PerMark is a free, open-source Markdown IDE that integrates with Claude Code via MCP to help you read and review what AI agents write, with automatic hooks that detect changes and enable document feedback. The plugin connects Claude Code to PerMark's desktop app, allowing you to watch agent edits in real time, leave comments on specific passages, and let agents read your feedback to steer their work.

Scout is a web research plugin for Claude Code that redesigns vague questions into optimized multi-engine queries and fetches full page content with privacy-aware routing. It combines query design, source evaluation, and multi-tier search (built-in WebSearch, Context7 docs, Exa semantic search, and optional local Playwright) to reach primary sources while classifying URLs into public/confidential/authenticated tiers.

sepiace provides long-term memory for AI agents by connecting to the sepiace MCP server, enabling agents to remember, recall, and forget information using natural language. The plugin includes migration tools to transfer existing Claude Code and Codex memories to sepiace, and uses spaced repetition principles to keep frequently-used memories strong while letting unused ones fade.

subagent-mcp is an MCP stdio server that orchestrates local Claude and Codex CLI sub-agents for long-horizon coding tasks, routing work through authenticated CLIs with provider-agnostic concurrency controls and permission gating. It hooks into Claude Code and Codex sessions to delegate tasks to fresh sub-agents while maintaining state summaries and coordinating across multiple providers via environment-based credential management.

sub-human enables real-time collaboration between separate Claude Code sessions on one machine or over a network link, with shared rooms where Claudes communicate natively and members edit versioned plans together. The plugin uses hooks to post messages without paraphrasing, an MCP server for the shared room state, and native Claude Code messaging between agents, with explicit consent workflows for plan sign-offs.

ThinkFu provides metacognitive thinking tools for Claude agents to plan, explore, resolve obstacles, and evaluate their work. It includes one skill with hooks into session start events and runs an MCP server locally without requiring external API keys.

This Claude Code plugin operationalizes Feature-First Clean Architecture (FFCA) conventions for Flutter monorepos through skills, validation hooks, and an MCP server that enforces layer dependency rules. It provides guidance on feature scaffolding, routing, cross-feature wiring, and includes an auditor agent for architectural compliance.

VibeForce is a Claude Code plugin that orchestrates parallel multi-agent Salesforce delivery workflows, with documentation-grounded skills for Apex, LWC, metadata and integrations, deterministic hooks, and local/post-deploy verification gates that prevent broken work from shipping. It includes 12 agents, 34 skills, metadata tools that read by selector to save context, and mechanical checks (format, lint, analyzer, deploy validation, smoke tests, org verification) that block deployment until all gates pass.

xcindex lets Claude Code query Xcode's built-in symbol index to find references, definitions, overrides, and conformances in Swift/ObjC code with sub-millisecond latency, eliminating the need for grep-based lookups. The plugin reads from the index Xcode already maintains in DerivedData during builds—no daemon, no re-indexing, and it alerts when the index is stale.

AgenticOS Workbench plugin injects brain context into every prompt, captures sessions into memory, and streams telemetry through an integrated MCP server. It provides 21 commands and 9 skills for managing agent workflows, with hooks at key lifecycle events like session start/end and user prompt submission.

agichan turns Claude Code and other agent CLI sessions into a distributed swarm that coordinates work through an end-to-end encrypted channel, with workers claiming tasks from a shared board and pushing git branches for each completed task. The plugin uses MCP servers and shell hooks to detect new sessions and task submissions, enabling real-time task distribution and optional payment from escrow without polling loops.

This Claude Code plugin drives the Arbiter desktop application (already installed on your machine) to convert between video, audio, image, document, ebook, and archive formats without needing to manually open the app or drag files. It provides MCP tools and slash commands for file conversion, batch operations, and document reading, while staying synchronized with whatever version of Arbiter you have installed.

The carrel-agent plugin provides an agentic file librarian for carrel desks with four endpoints (/index, /doctor, /catalog, /completion), a file-librarian agent, and an MCP server that offers 14 tools for file management and carrel:// resource access. It automatically re-indexes files Claude writes using a PostToolUse hook, with operations driven by shell execution through the carrel and reindex.sh tools.

Cartographer is an agent-first code understanding system that builds a persistent world-model of your codebase with evidence-grounded facts, semantic maps, behavior flows, and navigable perspectives via semantic zoom. The plugin provides PR review overlays and persistent depth navigation through code understanding, powered by agents and skills that integrate with your development workflow via shell execution and session context.

This plugin provides modular skills for Catalyst by Zoho's serverless platform covering functions, data storage, caching, authentication, and deployment, plus a pre-wired MCP connector to manage infrastructure directly from Claude. It enables production-ready code generation, architecture recommendations, and cost estimation for Catalyst projects.

cc adds multi-session awareness to Claude Code by displaying active sessions working on the same project, tracking file edits to warn of conflicts, and enabling message passing between parallel sessions via a `/cc` command. It uses liveness detection on Claude Code's `/tmp` directories and stores session metadata locally to provide near-instant conflict detection without requiring external services.

CC-Forever adds persistent, local conversation memory to Claude Code using semantic search powered by Transformers.js and LanceDB, storing all data offline on your machine. Users can save conversations manually or automatically, search past interactions by meaning, and summarize sessions into topic-based Q&A pairs without requiring external APIs or subscriptions.

Codixing is an AST-aware code search and dependency analysis engine that intercepts grep calls and CLI tool use to provide ranked, semantic retrieval with change impact prediction across the dependency graph. It runs locally with zero cloud dependencies, bundles an MCP server, and includes five guided workflows for project onboarding, architecture exploration, code review, and release automation.

Delta Chat messaging channel for Claude Code creates an end-to-end encrypted messaging bridge with native WebXDC GUI app platform support, enabling permission prompts, file iteration, and multi-player interactions. The plugin implements 2 skills, 1 hook, and 1 MCP server, bootstrapped via bun and session-start.sh on SessionStart events.

DJ Claude adds live music generation and multi-agent jam band capabilities to Claude Code through 20 MCP tools and slash commands, enabling real-time collaborative music composition where multiple agents connect over HTTP to build layered jam sessions. It requires no API keys or external services, generating all music via Strudel patterns with conductor mode for orchestrating full bands from a single directive.

Gr0m_Mem is a persistent memory system that prevents Claude from re-asking questions and re-deriving decisions across sessions, using SQLite FTS5 for full-text search with zero external dependencies. It integrates via MCP server, CLI shell-out, or system-prompt injection, and ships with hooks that auto-save milestones at session boundaries.

herdr-panorama is an opt-in Claude Code plugin that visualizes a swarm of orchestrators and their subagents in a live graph view, recording agent lifecycle events and providing orchestrators with a report_thread MCP tool. It displays orchestrator status, spawned subagents, and work threads in an Argo-style graph interface, reading local transcripts without requiring external services.

An MCP server that exposes iMessage history and conversations to Claude via direct SQLite read, with voice-note transcription via Whisper and FTS5 search, while supporting exports to Obsidian vaults and AppleScript-based sending with draft+confirm workflow. Runs exclusively on macOS and requires Full Disk Access to read the chat.db database.

LayerMap traces function calls and dependencies across TypeScript, JavaScript, Go, Python, and Java codebases, answering questions about what calls a function, what a change affects up to HTTP routes and entry points, and repository organization in a single tool call. It runs locally via an MCP server using the language's native compiler (including JDK 21+ for Java), keeps maps cached on your machine, and adds a session-start hint to help agents recognize when codebase mapping is useful.

litclaude is a Claude Code-native workflow plugin with 19 commands, 11 agents, and 38 skills that implements a bounded-authority start-work lifecycle for managing tool execution and session events. It requires Node.js and integrates with Claude Code through hooks into PreToolUse, PostToolUse, SessionStart, SessionEnd, and other lifecycle events.

mnemo captures corrections and learnings from Claude Code sessions as reusable rules, then automatically injects relevant rules into future prompts to help Claude apply previously corrected patterns. Rules are stored per-repo and globally, surfaced via hooks when applicable, with optional MCP access to full rule bodies that exceed token limits.

MPP Inspector gives Claude full visibility into HTTP 402 payment challenges, endpoint discovery, pricing comparison, and payment flow validation for Machine Payments Protocol endpoints directly from the editor. It exposes five MCP tools, slash commands, and a built-in skill covering challenge parsing, payment methods (Tempo, Stripe, Lightning, Solana, Card), and receipt validation.

Nova is a Claude Code plugin that provides an independent evaluator framework and adversarial security review for AI-generated code before commit, using generator-evaluator separation with 9 hooks, 1 MCP server, and pre-commit quality gates. It includes 17 slash commands, 12 skills, and 6 specialist agents to verify code reliability, catch security issues (like hardcoded secrets), and maintain session-to-session continuity across the development workflow.

Ntfyx sends encrypted notifications and questions from Claude Code, Codex, and scripts to your phone, with options to receive completion alerts, choose from predefined answers, or type custom replies that are verified before continuing the agent's execution. It integrates via an MCP server and hooks to intercept native questions and tool approvals across Claude Code, Codex, and pi.

Nyquest is a context manager plugin that parks large tool results to disk, replacing them with compact digests and leaving Claude a recall tool to fetch precise slices on demand. It reduces context size, cache writes, and API costs by 40–78% on typical sessions with identical output quality.

This Claude Code plugin distributes OMEGA framework knowledge as 14 skills, 8 hooks, and 1 MCP server that stay version-matched with the monorepo code they document. It automatically injects context-aware framework skills based on detected @omega.js packages in the working project, with mechanisms to support both published and local development copies.

ParaQualis-GXP is a Claude Code plugin for computer-system validation and life-sciences regulatory compliance, covering GAMP 5, 21 CFR Part 11, EU GMP Annex 11, live eCFR data, and openFDA APIs with an IQ/OQ/PQ qualification-pack generator. It provides 18 slash commands, 2 auto-invoked advisor skills, 3 specialist sub-agents, and includes an MCP server for openFDA data access (free API key provisioning via `/openfda:setup`).

Patronus Runtime Protection adds native security gates to Claude Code chats, scanning external text and tool results before the model continues using policies configured in the separately installed Patronus Security CLI. The plugin hooks into session lifecycle and user/tool events to check user-authored strings, terminal output, and file content while keeping scanner state isolated and enforcing findings that block dangerous prompts or mask sensitive data.

pilot-core provides comprehensive governance and delivery orchestration for full-stack Microsoft projects, including stack detection, security scanning, REST API standards enforcement, and incident correlation across multiple deployment personas. The plugin bundles 13 agents, 44 skills, and 14 hooks to enable autonomous team operations, cross-stack seam review, and spec validation throughout the development lifecycle.

pilot-rag is a self-hosted RAG scaffold for Microsoft .NET codebases that builds a vendor-agnostic Q&A system using Microsoft.Extensions.AI, Qdrant vector storage, and Roslyn-based code chunking. It provides an SSE /ask endpoint with source citation, an Angular Signals chat UI, and swappable LLM backends (Ollama or Azure OpenAI) configured only via appsettings.

A Claude Code plugin that routes code search and refactoring through JetBrains Rider's live index instead of Bash grep, reducing token usage by ~99% on large Unreal C++ and .NET codebases. It also includes gamedev-log-analyzer, which parses and summarizes massive editor logs (50+ MB) with deduplication and classification, cutting log analysis from 1M+ tokens to ~2,500 tokens.

Streams Claude Code sessions to Rius as OpenTelemetry GenAI traces, capturing the full hierarchy of turns, model generations with token counts, tool calls, and subagents as a live waterfall. Tracing is off by default and must be explicitly enabled per folder; sensitive content capture can be disabled via environment variable while preserving structural metadata.

This plugin connects Claude Code to the SpecsGraph MCP server to offer guided domain modeling workflows across four specialized skills: director (routes to the right specialist), engineer (models domains and bounded contexts), product (writes features and scenarios), and brownfield (maps existing codebases). All workflows stage changes as proposals for team review before publishing to the specification model.

spring-fleet is a Claude Code plugin that traces requests across Spring Boot microservice repositories, correlating logs by trace ID to identify failing service hops and root causes. It auto-discovers fleet topology, exposes cross-repo call-chain navigation and log merging via an MCP server, and stays entirely within the Claude Code editor without external dashboards.

SuperLcm provides a unified local conversation archive for Claude Code, Codex, Hermes, Pi, and dsh harness, allowing you to keep full original records, browse summaries, and continue tasks across different AI tools. For Claude Code users, it offers background compaction that swaps older context for layered summaries in milliseconds rather than stalling the conversation at the token threshold.

A portable agent toolkit with 35 bundled skills, 10 specialist agents, and smart worktree hooks that runs across six surfaces on five platforms (Claude Code, Claude Desktop, Codex, Cursor, Gemini CLI, and OpenCode) with a single canonical source and thin per-platform adapters. The plugin uses bash and python3 for execution, provides honest capability degradation per surface, and includes MCP server stubs for extensibility.

Tedix is a workflow orchestration and delegation platform that integrates with Claude Code through an MCP server and 6 skills covering session guidance, account connection, task delegation, and workspace outputs. The plugin enables users to manage governed work items, review coding sessions, and delegate tasks across their connected organization.

<UNKNOWN>

A Telegram messaging bridge that connects a Claude Code session to a Telegram bot via MCP server, providing tools to reply, react to, and edit messages with built-in access control and safety hooks. Inbound messages are forwarded to the Claude Code session, which can respond using the exposed reply, react, and edit_message tools.

xsm enables cross-session messaging between Claude Code and Codex sessions running on the same machine or remote servers, allowing sessions to discover each other and exchange messages through project-scoped permissions. It operates entirely within the existing runtime infrastructure using Unix sockets and native delivery paths, with no external dependencies beyond the Python standard library.

Draw and annotate elements on a running localhost page, then send all markups and notes into Claude Code for editing—the plugin captures element details, DOM structure, React component tree, and cropped screenshots, then reports progress back to the page as Claude works. Everything runs locally with no cloud, requiring only Node.js and a Chrome window.

atlias is a harness for AI coding agents that validates whether claimed work is actually complete by checking for test runs, syntax errors, unwired code, infinite loops, and destructive commands. It runs as a sub-harness inside Claude Code and other IDEs, or standalone as a terminal agent driving various LLM engines with a tool loop optimized for weaker models.

The `base` plugin for kiln provides 11 skills and 5 hooks to manage Git workflows including worktrees, merges, versioning, cleanup, kiln updates, and contributor PRs. It runs locally via shell commands and MCP servers, with no external API keys required.

Bitfab provides LLM evaluation tools for Claude Code through an MCP server, enabling trace inspection, grader management, and diagnostics during development sessions. The plugin integrates via SessionStart hooks and shell command execution to deliver real-time evaluation capabilities.

This Claude Code plugin enables remote code execution and filesystem operations on REXD targets over SSH using an MCP server. When activated, it redirects local Claude tools (file read/write, shell, search) to a configured remote host while enforcing remote-only work through a PreToolUse hook.

claude-goal is a Claude Code plugin that runs an autonomous goal loop with deterministic budget profiles, persistence, and a tool-equipped evaluator subagent that verifies completion rather than trusting self-narrative. It continues iterating across turns until the goal is verified complete, blocked, capped by budget/time, or explicitly paused.

Clawket is a structured task-contract layer for Claude Code that replaces Jira + Confluence with a local SQLite database, MCP RAG pull, and web dashboard—persisting project plans, tasks, and execution history across sessions while enforcing hook-based guardrails to keep agents on active tasks. The plugin bundles 7 skills, 7 lifecycle hooks covering SessionStart through SubagentStop, an embedded MCP stdio server with semantic search over knowledge entries, and a React dashboard (Summary, Board, Backlog, Timeline, Wiki views) that runs entirely on-device without external vector databases.

CodeWeaver is a semantic code search MCP server that indexes your project with hybrid search (semantic, AST, and keyword matching) across 166+ languages, allowing Claude to answer natural language queries about code locations and logic. It runs locally by default with zero configuration, automatically indexing your codebase and supporting deep semantic analysis for 27 languages with AST parsing.

Cortex is a Claude Code plugin that automates the entire software development lifecycle from idea to deployment, including 54 commands, 13 agents, and 27 skills organized around brainstorming, planning, TDD, debugging, and verification. It enforces standardized engineering practices across Python/FastAPI, Node.js/NestJS, and Java/Spring Boot backends, with native Jira integration and locally-run scaffolders for apps, MCP servers, and plugins.

This Claude Code plugin installs a read-only advisor guardrail using Cursor Agent CLI that must be consulted before the first write operation in an executor session. The advisor runs through Cursor's ask mode (defaulting to Cursor Grok 4.6 High) and provides constructive guidance on decisions and risks, with per-project model memory and a configurable consultation timeout.

A Claude Code plugin that implements an actor-critic guardrail by requiring executor sessions to consult an adversarial read-only critic through the Cursor Agent CLI before their first write operation. The critic runs in Cursor's ask mode (read-only) and defaults to cursor-grok-4.6-high, with per-project model memory to remember selections.

This plugin integrates your React design system as ground truth for Claude via MCP, exposing components, props, variants, and tokens. It includes a PostToolUse hook that lints every UI file Claude writes to enforce compliance with your design system constraints.

Easing Wizard generates professional CSS easing curves and provides animation auditing through an expert agent, offering 7 MCP tools for Bezier, Spring, Bounce, Wiggle, and Overshoot curves with 68 presets. Three skills let developers describe animation feels and get curve recommendations, upgrade existing easings, or audit entire projects for animation improvements.

grimoire is a Claude Code plugin that provides 13 portable Agent Skills, a roster system, curated memory stores, and an unattended build loop for AI-assisted development that learns by crystallizing insights from code reviews back into reusable skills. It includes 10 specialized agents, multiple workflow hooks, a multi-language code graph for research via tree-sitter, and supports stack-agnostic tracker integration (Jira, Linear, GitHub Issues).

Grok Build for Claude Code lets Claude delegate coding work to the Grok Build CLI, with cost billed to your xAI subscription instead of metered API usage. The plugin provides routing intelligence to decide when to hand off bulk, low-risk edits to Grok while keeping architectural decisions and security checks in Claude.

GWS Connector is a multi-account Google Workspace MCP server that lets you connect unlimited Gmail, Google Calendar, Google Drive, Google Sheets, and Google Docs accounts with smart routing by label, email, or domain. The plugin provides 30 tools for mail, calendar, drive, sheets, and docs operations across all connected accounts, with secure credential storage in the OS keychain.

Halyard is shared team memory for AI agents that logs decisions and work history, allowing agents to recall context and ask teammates on Slack, Teams, or Discord when human input is needed. It provides hooks for pre-tool use, session start, stop, and user prompt submission to integrate memory and team communication into agent workflows.

Kiln is a project management plugin that provides 12 skills for worktree management, merging, releases, cleanup, reviews, and contributor tracking, along with 6 hooks for branch protection, file guards, and automated reminders. It requires npx and python3, runs shell commands, and connects to an MCP server for project-wide governance features.

KMP is a local-first agent memory plugin that preserves decisions and evidence in embedded SQLite and exposes them through semantic tools integrated with ChronoLoom for visualization. It wires the kmp MCP server, includes twelve skills for memory operations, and provides setup diagnostics through a SessionStart hook.

Knos adds a Stop hook that verifies test checks pass before the agent can stop, and provides an MCP server for creating GitHub issue bounties paid in test USDC on Solana devnet. The plugin attests check results via GitHub-signed workflow runs and verifies them on Solana's blockchain.

A harness for teams fine-tuning with LlamaFactory that bundles the official docs as searchable skills and agents, plus a PreToolUse hook that blocks `llamafactory-cli train` commands on configs that fail validation. It includes two MCP servers for live library docs (context7) and Hugging Face model cards.

This plugin enforces a guardrail for Claude Code, Codex, and Cursor by requiring each executor session to consult a read-only local advisor subagent before its first write operation. The advisor is launched as a native child agent within the same IDE and account, using Opus High for Claude Code, GPT-5.6 Sol for Codex, and Cursor Grok 4.5 High for Cursor.

lockwire fingerprints code symbols across four separate tiers (path, signature, body, dependencies) and binds documentation claims only to the tiers they depend on, catching stale CLAUDE.md, AGENTS.md, and docs at write time with tamper-evident history. It runs as a Claude Code plugin with pre-commit and hook integration, using tree-sitter and BLAKE3 to detect documentation drift without false positives from internal refactors.

Marvelous UI is a framework-agnostic Web Components library providing 21 free UI components (badges, buttons, dialogs, menus, toasts, and more) accessible through a local MCP server that searches, installs, and documents components for Claude Code agents. The plugin includes a skill that teaches agents how to use the library, hooks that encourage searching before hand-writing UI, and runs entirely locally with no external dependencies or network requests.

This Claude Code plugin automatically sets up Playwright MCP and installs Chromium browser on first session start, enabling browser automation tasks like web scraping, E2E testing, and screenshots. The plugin detects compatible Playwright versions, handles idempotent installation, and provides tools to navigate pages, fill forms, click elements, and capture snapshots.

mcp-serena provides semantic code intelligence capabilities including symbol search, reference search, and safe refactoring through an MCP server that integrates with Claude Code. It enables symbol-level code inspection and editing within an IDE-like environment after project activation.

mif-docs ships 47 skills, one per concrete document genre (tutorials, how-tos, references, architecture docs, ADRs, runbooks, PRDs, and 30+ more), each adopting industry patterns while guaranteeing MIF (Modeled Information Format) compliance through deterministic validation against a canonical JSON-LD schema. Every output document is both human-readable in its native genre and machine-readable MIF, with a fail-closed guard that blocks non-conformant output before it's written.

Modellix plugin provides a unified CLI and REST API interface for AI-powered image, video, and audio generation workflows with automatic preflight checks, task management, and persistent safety rules. It includes slash commands for prompt engineering, model discovery, and result download, plus optional hooks to prevent repeated paid submissions and remind users to retrieve generated assets.

nanomneme integrates a shared SQLite-backed memory system into Claude Code via native MCP tools (retain, recall, retrieve, remove) and optional memory injection at session start. Memory is deterministic, observable, and reusable across Claude, Pi, and other adapters with project and global scope management.

This plugin implements an optional native cloud child-agent review mechanism at configurable tool boundaries, enforcing a PASS result or explicit user waiver in required mode. It uses hooks at SessionStart and pre/post-ToolUse events to gate execution of shell tools like Bash and Git commands, with review evidence validated against workspace state changes.

oh-my-claudeagent orchestrates 10 specialist agents across planning, execution, code review, debugging, and research tasks, with persistence via 22 hooks, parallel execution, and evidence-based verification through bundled MCP servers and shell guardrails. The plugin activates agents via natural language triggers or slash commands and injects comment conventions for multiple languages while enforcing permission and git safety guards.

okl (Observed Knowledge Ledger) is a Claude Code plugin that briefs coding agents with contextual lessons—engineering rules, architecture decisions, and verified documentation—before each task via MCP hooks, and records what was learned to keep knowledge persistent and drift-checked. It requires the okl CLI tool and integrates via pre-task and end-of-session hooks to maintain a shared, verifiable knowledge store across team repositories.

onsetter is a PreToolUse hook that reads CLAUDE.md files and injects matching "ask" blocks into the model's context before Write, Edit, or Bash calls resolve, letting Claude answer inline without external verdicts. It matches asks against file paths and incoming text via regex, firing on every occurrence and marking repeats rather than hiding them.

Onsystem keeps Claude aligned with your React design system by reading components, props, variants and tokens, then catching and correcting invented UI elements via a post-edit hook and MCP server. It runs locally with zero config, integrates seamlessly alongside @shadcn/lint, and makes no network requests or API calls.

A Claude Code plugin that uses on-disk markdown files as external memory for planning, progress tracking, and knowledge storage across sessions, preventing goal drift and context overload in multi-step workflows. Ships with 7 slash commands, an MCP server for semantic memory integration, and auto-detects between single-task (sm) and multi-phase (lg) project modes based on git contributor history.

PlumbBob is a Claude Code plugin that structures AI-assisted coding as an attention-first loop: you settle the plan in an intent file before any code, then the model builds one small step at a time and pauses after each step for human approval before committing. It enforces the pause mechanically through a CLI, git checkpoints, and a gate that refuses to record steps until the checks pass and a human has reviewed.

prompt-squeeze measures and reduces Claude prompt costs by automatically compressing long prompts before submission, then surfaces cumulative savings in tokens, dollars, and energy across your session or team. The plugin combines a UserPromptSubmit hook, slash commands, and an MCP server to enforce cost discipline with one-keystroke decisions and ambient visibility of lifetime savings.

Puenteo bridges multiple coding-agent sessions by allowing users to search past sessions, monitor currently-running agents, send inter-session messages, and claim files. It provides session management through commands, skills, and hooks that integrate with agent lifecycle events like session start, stop, and user prompts.

relevo automates handoff between a MasterMind session in Claude Code and a builder agent, moving plans and reports automatically so you don't copy them manually. The plugin registers your Claude Code session, pushes builder reports and "needs you" stops into it, and provides status, send, show, gate, and done tools—all powered by the relevo binary on your PATH.

Deploy, debug, and monitor applications on Render directly from Claude Code using an integrated MCP server (over OAuth), 21 bundled skills, a specialized agent, and slash commands. The plugin includes a PostToolUse hook that validates render.yaml on edit and works alongside the Render CLI for comprehensive deployment and service management.

The Rootly plugin brings full-lifecycle incident management into Claude Code, enabling developers to prevent incidents before deploy, respond in real-time, and learn from post-mortems without leaving their IDE. It offers 18 skills covering deployment risk analysis, incident investigation, on-call visibility, status checks, stakeholder briefs, shift handoffs, natural language queries, and automated retrospectives — all connected via Rootly's MCP server.

Sato Hub is a scored, daily-rebuilt index of onchain-agent tooling (frameworks, MCP servers, wallets, payment rails, identity standards, trading venues, agent skills) and agent-economy metrics; it provides Preflight checks for packages/MCP servers before installation, route recommendations with disclosed fees, and Agent Passports—all read-only and non-custodial. The plugin integrates as an Agent Skill with an MCP server endpoint and includes a PreToolUse install hook (Sato Check) that inspects what crypto packages, MCP servers, or skills can do with your keys and funds before they run.

Sequant is a Claude Code plugin that wraps AI agents in a structured spec → exec → qa pipeline with isolated git worktrees and quality gates to take GitHub issues from triage to merge-ready PRs. It orchestrates the entire workflow—planning, code generation, testing, and verification—with evidence for each acceptance criterion, leaving the final merge decision to the developer.

Sequant is an AI coding agent orchestrator that converts GitHub issues into reviewed pull requests by running isolated spec → exec → qa phases as Claude Code skills, with pre/post-tool hooks that enforce guardrails and an MCP server exposing workflow state. It manages git worktrees, enforces quality gates, and integrates with GitHub CLI for branch management, commits, and PR operations using existing shell credentials.

An MCP server that manages multi-workspace Slack integration with draft-and-confirm safety on all writes, vault auto-export of reads, and support for xoxc/xoxp/xoxb authentication modes. Runs as a single Python process that handles multiple Slack workspaces simultaneously with features like prompt-injection scrubbing, audit logging, and token redaction.

srclight provides deep code indexing for Claude via an MCP server with 28 tools for structural code search, call graphs, type hierarchies, git analysis, and dead code detection across 11 programming languages. The plugin auto-configures and includes skills for codebase exploration and safe refactoring workflows, plus an autonomous codebase-explorer agent.

This plugin provides full programmatic access to Stripe API endpoints through the pinned stripe-node SDK, supporting multiple accounts (standalone keys and Stripe Connect) with binary-enforced safety tiers and live-mode arming. It includes the official Stripe CLI bundled for webhook management and activates automatically for Stripe data lookups, cross-account reporting, and webhook tasks.

Summa prevents large tool outputs from filling the context window by storing full content in a local SQLite file and showing the agent only the start, end, and search results. All data remains on your computer with no network calls or telemetry.

SuperBased adds screenshot capture, OCR, screen recording, visual regression testing, voice dictation, and full GUI automation with humanization to Claude Code via 72 MCP tools. It enables Claude to see and interact with the desktop, with features like proactive screen monitoring, CAPTCHA solving, token-efficient text compression, and post-test auto-capture.

SuperClaude is an AI-enhanced development framework for Claude Code that provides 30 commands, 20 domain-specialist agents, and 7 auto-triggering skills organized across planning, development, testing, documentation, and research workflows. It integrates lifecycle hooks (SessionStart, PostToolUse, Stop) and MCP servers for context management and multi-step problem solving, with no external API dependencies required.

A Telegram channel plugin for Claude Code that maps each project to a forum topic with live working/idle status badges, enabling concurrent project sessions and remote control from your phone. Multiple sessions share a single bot token through a leader-follower architecture where the first session owns the bot poller and others connect over localhost.

This Claude Code plugin enables messaging between Codex sessions and Claude Code through a dedicated MCP server, allowing agents to appear in ListAgents and receive/send replies via SendMessage. It integrates via hooks for session initialization and tool usage to facilitate inter-session communication.

TestPilot generates test cases using evolvable Agent State with generator prompts stored as skills, schema validation and design gates managed through hooks, and deterministic scoring handled by an external MCP tool to prevent model self-scoring. The plugin includes 10 test-generation skills, 2 hooks for PreToolUse and Stop events, and 1 MCP server that runs shell commands through Node.js.

Vulca is a visual control layer for Claude Code that transforms fuzzy creative intent into structured direction cards, design specifications, and cultural evaluations through a 7-skill workflow. It coordinates provider-routed image generation, editing, and VLM-backed evaluation while maintaining auditable artifacts like discovery.md, design.md, and evaluation.json.

WUWEI is a Claude Code plugin that orchestrates autonomous delivery through a daily loop of planning, building, review gates, and retrospectives with agent roles and guards that enforce safe defaults. It manages workspace memory, decision approvals from the owner, multi-tier code review, and merge workflows integrated with GitHub, Linear/Jira, and Slack for remote operation.

This plugin connects Claude Code to Agent Archive, a community knowledge base that automatically searches the archive when you encounter unfamiliar errors or tools, and proposes contributions to the community when you solve interesting problems. It maintains a private local wiki organized by domain (environments, tools, APIs, errors, patterns) and surfaces pending posts at session start for review and publishing.

This plugin implements Scalekit Agent Auth, enabling AI agents to authenticate and act on behalf of users in third-party applications like Gmail, Slack, Calendar, and Notion. It provides agent skills and MCP server integration for secure third-party app interactions.

This Claude Code plugin enables bidirectional communication with OpenAI Codex through local inter-process messaging, allowing live peer conversation and headless code delegation via the ask_codex capability. It integrates via 4 hooks (PostToolUse, SessionStart, Stop, UserPromptSubmit) and requires only Node.js as an external dependency.

Mirrors Claude Code and Codex session activity into IRC channels, broadcasting prompts, tool calls with timings, subagent activity, and token usage in real-time with one nick per session. Requires only Python 3.9+ standard library and IRC server connectivity, configured through harness settings with support for multiple channels and verbosity levels.

A Claude Code plugin that provides native access to AgentNews — the community platform for AI agent news — with MCP integration for reading feeds, searching posts, and interacting with the community. Includes slash commands for quick access to headlines, post details, and actions like voting and commenting, with optional on-chain payments for content submission.

Agent-security provides threat modeling, configuration auditing, MCP server review, prompt injection tracing, Mason Broker policy generation, incident lookup, security evaluations, and Semgrep scanning for LLM agents. It includes guard hooks for Bash execution and an optional incident-database MCP server.

This plugin provides security skills for LLM agents including threat modeling, agent configuration auditing, MCP server review, prompt injection tracing, incident lookup, security evaluations, and Semgrep scanning. It includes Bash guard hooks and an optional incident-database MCP server to help agents identify and mitigate security risks.

This plugin diagnoses and repairs stuck or failing AI agents through autonomous counselling, reasoning conflict detection, and workflow recovery. It hooks into tool use and user prompts to identify bottlenecks and guide agents toward progress without external dependencies.

aidd is a toolkit that enforces AI-Driven Development: agents write code and prove it works within a scope you approve, while you keep control over what ships via a `aidd/gate` CI check. It integrates with Claude Code, Cursor, Copilot, and other agents to manage the full loop from intent to production with change control and human approval at critical gates.

Ali-kit is a routing playbook that intelligently directs requests to the appropriate skill based on their type—design, building, debugging, review, data, marketing, SEO, or ads—with all necessary plugins pre-bundled for one-step installation. It uses SessionStart and UserPromptSubmit hooks to intercept and classify user requests, then delegates to specialized agents for each domain.

Almagest is a Claude Code plugin that pairs with a standalone binary tool to build and maintain an LLM-powered wiki within Obsidian, with agents ingesting sources, linking repositories, and proposing changes that you approve before they enter the vault. It provides three read-only agents, fourteen skills, and features like document checkout, journaling, and safe deletion to keep your knowledge base human-navigable while agents handle the heavy lifting.

amnesia preserves agent working state, reasoning, and task context across Claude Code and Grok compactions through multi-layer background handoff capture (mechanical sync, Opus 4.7 enrichment, Stop-hook refinement, and preemptive snapshots). On session resume, the agent re-injects the structured handoff to maintain continuity—knowing current working theory, concrete next actions, in-motion files, and verbatim user constraints—without cluttering user-visible memory or CLAUDE.md.

AsItIs provides read-only MCP tools and a skill to safely read, lint, and analyze markdown and agent steering files while teaching Claude minimal-edit practices and optionally guarding against accidental file corruption. The plugin enforces byte-level fidelity—preserving line endings, trailing spaces, BOMs, and frontmatter—through an MCP server with no network access, no write capability, and zero external dependencies.

atlas-obsidian pairs an MCP-served Go binary with a Claude Code plugin to manage project context as a source-cited Obsidian wiki and versioned work threads that move through stub, spec, plan, and receipt stages. It integrates with project workflows through lifecycle hooks, ingesting external sources into tracked Markdown while keeping work state queryable and auditable across agent sessions.

Atmina is a shared memory system for Claude that recalls context before answering, captures decisions and findings, and consolidates knowledge into a reviewed current-state view. It integrates via an MCP server to provide persistent memory management across sessions through skills, hooks, and shell execution.

Avanti is a Luanti mod factory plugin providing modding and dependency management skills, headless multi-game testing capabilities, and two MCP servers (luanti-depgraph for dependency graphs and zvec-grep for semantic search). The plugin integrates 3 agents, 10 skills, and shell-based external tools to streamline Luanti game modding workflows.

AXME Code maintains persistent project context across Claude Code sessions, storing architectural decisions, code patterns, and learned safety rules in a local knowledge base that's automatically loaded at session start. The plugin enforces safety guardrails at the execution level (blocking dangerous commands like git force-push and rm -rf) and provides an MCP server with 19 tools for reading and writing the knowledge base transparently during agent work.

A Claude Code plugin that wraps the Backlog.md MCP server, auto-installs the backlog-md CLI on first use, and provides a `/backlog-migrate` skill to convert messy `/docs` folders into a clean task backlog. Three gated hooks automatically track plan acceptance and git commits while staying dormant in projects without a backlog/ folder.

BDK is a dev kit plugin packaging 13 agents, 29 skills, and 6 hooks for language-agnostic code review, testing, planning, design, and documentation workflows. It integrates with GitHub for PR reviews and delegates environment setup to project-local configuration files.

Belay is a Claude Code plugin that flips the traditional AI assistance model by having you write the code while it coaches, runs tests, and tracks skill progression through three modes: unearned (you code, it reviews), earned (it codes, you review), and mastered (it works quietly). Skills are unlocked through a logbook system that requires witnessed test runs and human validation of your understanding before delegation is granted.

Blueprint SDLC is a Claude Code plugin with 27 slash commands that guide the full engineering workflow from backlog to merged PR, enforced by 15 audit rules and integrated MCP servers for documentation and reasoning. It auto-installs a CLI binary that validates every tool call, enforces commit formats, prevents dangerous commands, and provides real-time SDLC status tracking.

This plugin enforces consistent voice and quality standards for development documentation by combining writer personas, measurable quality gates, and an editorial review layer that catches tone drift before content ships. It produces seven specialized artifact types—ADRs, design docs, handoffs, changelogs, and end-user guides—each routed through composable personas (Technical Writer, Doc Writer, Marketing Copywriter, Context Curator) and validated against deterministic checks via the bito tooling.

Buoy is a Claude Code plugin and MCP server that gives coding agents access to your design system tokens so they look them up before writing styles, then automatically flags hardcoded values and design drift after each edit. It works with CSS custom properties, Tailwind themes, tokens.json, SCSS variables, and DESIGN.md files with no configuration needed.

Caliber is a Claude Code plugin that integrates product development workflows through 16 commands (like /caliber:prd and /caliber:check), an MCP server with sign-in, session initialization with project naming, and post-push pull request validation. It connects to the Caliber platform via MCP server and hooks into SessionStart and PostToolUse events to streamline product requirements and code review processes.

cast provides Claude with multiple logged-in Chrome browser profiles, one per test user, enabling multi-user app testing where Claude can orchestrate interactions across users simultaneously. Each profile maintains persistent logins and SSO credentials, allowing Claude to verify user-to-user workflows like messaging, approvals, and marketplace interactions.

cast provides Claude Code with multiple persistent Chrome profiles, each logged in as a different test user, so Claude can simulate multi-user scenarios like chat interactions and approval workflows. It manages browser windows per person with SSO support, saving login state and browser history per profile between sessions.

ChatBraid merges conversation context from Claude Code, Codex, ChatGPT, and claude.ai threads into a single unified context with goals, decisions, code artifacts, and conflicts. It provides cross-thread commands like /braid and /threads for Claude Code, MCP tools for Claude Desktop, web skills for claude.ai and ChatGPT, and a browser extension for direct thread access.

Automatically pastes clipboard screenshots into Claude Code when you submit a message, detecting fresh images taken within 90 seconds and attaching them in chronological order without manual file dragging. The plugin runs a background clipboard watcher and provides an MCP server tool for explicit fallback pasting, with cross-platform support for Windows, macOS, and Linux.

This Claude Code plugin enforces and guides implementation of Uncle Bob's Clean Architecture through 15 skills covering layer scaffolding, SOLID audits, Dependency Rule enforcement, and component metrics. It includes an MCP server that scans for violations in real-time via a PostToolUse hook and provides automated architectural analysis and migration support.

This Claude Code plugin adds a skill and hook that integrates the codebase-memory-mcp tool to enhance code understanding by maintaining contextual memory across tool interactions. It intercepts tool use events to provide persistent codebase context during development workflows.

code-diligence is a Claude Code plugin that ingests git repositories to produce a PE-grade technical due diligence dashboard covering 16 analysis cards across People (bus-factor, contributor activity), Product (hotspots, code aging, language inventory), and Process (delivery, review discipline, CI health) dimensions. The plugin stitches together proven open-source analyzers (git-fame, git-of-theseus, code-maat, hercules, repowise) into a single Observable dashboard with optional evidence-anchored narration via your configured model provider.

The code-review-graph plugin analyzes code changes and generates dependency graphs to visualize impact across your codebase. It integrates with git and uses shell execution to build and visualize code relationships during review workflows.

codeweb maps your codebase's call graph and function relationships without using an LLM, then gates pull requests by detecting new dependency cycles, code duplication, or orphaned symbols. The plugin provides 28 MCP tools (codeweb_impact, codeweb_callers, codeweb_find_similar) that give coding agents bounded structural answers to prevent incomplete code inspection.

This Claude Code plugin lets Claude control Windows and macOS applications by reading and manipulating the accessibility tree instead of screenshots, enabling token-efficient automation (~20x fewer tokens per action) while allowing you to keep working on the same desktop. It detects your input vs. its own input in real time, prevents interference with your typing, supports multiple concurrent Claude sessions, and includes safety guardrails that refuse to touch password managers, UAC prompts, or login screens.

context-graph provides file cards, decision history, and context slices to AI coding agents before they read or edit code, helping them understand the "why" behind a codebase. The plugin records both context observations and decisions after edits, enabling agents to maintain a comprehensive understanding of changes across the repository.

Context Kernel is a memory system for coding agents that automatically captures facts from conversations using SQLite and FTS5, then warns agents when stored facts change and recommendations become stale. It runs entirely locally with no external dependencies beyond Python, using a small on-device model called jev to determine what's worth remembering and which earlier recommendations relied on now-changed information.

Convertlyft skills provide 22 agent tools for analyzing website behavior, conversion optimization, and SEO through the Convertlyft MCP server and REST API. The plugin includes expert skills for auditing site SEO, diagnosing conversion drops, finding UX friction, optimizing conversions, and planning content improvements based on measured visitor data.

Coral is a Karpathy-style LLM wiki maintainer bundled as a Rust binary that scaffolds multi-repo documentation, manages dev environments, and exposes your codebase to Claude Code and other agents via Model Context Protocol. The Claude Code plugin registers five auto-invoked skills, two slash commands, a SessionStart hook, and an MCP server that lets Claude read your repo's wiki, manifest, lockfile, and test results with a modern WebUI featuring a force-directed graph and provider wizard.

Corebee is an AI-powered customer support platform plugin that gives Claude full operational control over a Corebee workspace through 10 skills, 4 agents, and 4 slash commands, enabling conversation triage, knowledge base management, contact handling, analytics, and widget configuration. Installation requires OAuth authentication (no API keys) and provides guardrail hooks, multi-step support workflows, and specialized sub-agents for delegated analysis and action.

craftsman is a Claude Code plugin that enforces disciplined engineering practices through 15 agents, 8 skills, and 7 commands for minimal-diff coding, root-cause debugging, recurring-bug detection via graphify, and ask-before-writing project scaffolding. It integrates Figma and Chrome DevTools MCP servers to support UI design workflows and includes cross-platform hooks for environment-quirk memory and task routing.

This multi-agent Situation Report generator dispatches 25 specialist AI agents to analyze project documents across construction, software, development, manufacturing, consulting, and custom domains, then synthesizes findings into structured markdown reports with interactive HTML dashboards and optional Slack delivery. It supports native document types (PDF, CSV, TXT, JSON, XML, YAML, images) plus optional Office file conversion (Excel, Word, PowerPoint) and integrates with PM tools like Jira, MS Project, and others for data import.

This Claude Code plugin orchestrates a multi-stack development workflow from ticket intake through analysis, development, build verification, and retrospective, using 4 agents and 11 skills coordinated by the /ticket command. It enforces security guardrails via hooks that prevent environment dumps, git commits/pushes, and direct env reads during tool execution.

Designless is an agent orchestrator that connects coding agents to brand design intelligence and Prism, an agent-native canvas, enabling them to build with consistent brand context instead of generic defaults. It detects user intent from natural language and automatically routes to the appropriate capability—from brand creation and design token generation to visual editing and pull request generation—without requiring specific sub-commands.

A Claude Code plugin that manages Discord bot sessions with context usage monitoring, session clearing, and slash commands for controlling Claude through Discord. It extends an official Discord channel plugin with session management, server administration, status display, and voice input capabilities.

This plugin enables modding of owned PC games by exposing engine internals, assets, sprites, and game state for inspection and modification. It integrates with FAL's MCP server and provides shell access for comprehensive game reverse-engineering and modding workflows.

Drift Detector is a Claude Code plugin and MCP server that scores every assistant turn against your output contract (persona, formatting, length rules) and injects a one-shot correction nudge when Claude drifts. The deterministic, dependency-free engine achieves F1=0.9973 accuracy by analyzing per-turn drift trajectories and repeat-spike patterns, displaying live status in a badge without touching session reliability.

DS Bridge measures design-system adoption, health, and drift over time by recording metrics in CI and analyzing them across repositories, then uses token drift detection, design-system-aware linting, and pre-handoff QA to find and fix off-system code within Claude Code. It integrates with Figma Professional+ to validate designs against token files and exports analytics to dashboards, manager reports, and BI tools.

ECC is a Harness-native plugin for Claude Code that bundles 68 agents, 286 skills, 94 legacy command shims, and reusable hooks/rules to automate engineering workflows. It runs shell commands through lifecycle hooks (SessionStart, PreToolUse, PostToolUse, PreCompact, Stop, SessionEnd) and integrates with MCP conventions for orchestrating operator workflows across agent harnesses.

EDPA derives billable hours from git evidence (commits, YAML edits, status transitions) without timesheets, using a Monte Carlo-calibrated proportional allocation engine with local-first governance and optional GitHub Projects sync. The plugin provides 21 slash commands and 5 skills for backlog management, capacity planning, PI (Program Increment) orchestration, forecasting, and evidence audit trails.

This plugin automatically selects the appropriate Claude model and reasoning effort level for each task, escalating to more powerful models when sessions get stuck. It monitors user interactions through hooks and task execution to optimize efficiency and cost by matching computational resources to actual task complexity.

This local-first MCP aggregates bank, brokerage, credit, and loan accounts via Plaid and writes balances, holdings, and transactions to a local markdown vault with tokens secured in macOS Keychain. It supports 12,000+ financial institutions and runs entirely on your machine, never sending financial data beyond Plaid's servers.

This Claude Code plugin syncs todos from your Claude Code workspace to Fizzy.do cards, automatically creating cards and steps based on your todo list. It uses shell scripts and Node.js to monitor and synchronize your task management between the two systems.

Forge by ShipToday is a free AI-powered product development lifecycle automation plugin that routes feature requests, bug reports, and architecture explorations through structured workflows when invoked by name. It coordinates session state through hooks, an MCP server connection to teams.shiptoday.ai, and three skills (autopilot, workflow management, and feedback) to manage planning, estimation, and status tracking without intruding on regular conversations.

Forge by ShipToday is an AI-powered product development lifecycle automation plugin that routes feature requests, bug reports, and planning tasks through structured workflows when invoked by name. It integrates with a hosted MCP server to manage workflow orchestration, while hook scripts coordinate session state locally without network calls.

FreeRide maintains a persistent project record (features, decisions, docs, work history) synced across all AI tools via an MCP server, so every coding agent starts each session with full context. It integrates with Claude Code, claude.ai, Codex, and Cursor through hooks, skills, and commands that automatically log agent work and keep the shared project state up to date.

This plugin teaches game reverse-engineering workflows from The Game Hacker's Handbook, providing eight skills, four commands, and an agent that help users find values, locate code that writes them, walk pointer chains, and create signatures using Pointer Lab and pe-mcp tools. A built-in write guard blocks memory modifications until the user explicitly opts in via an environment variable, ensuring safety for learning on owned software, CTF binaries, and tutorials.

geniffy is a memory plugin for Claude Code that persists project context (goals, decisions, open items, lessons learned) across sessions and automatically saves each turn's complete interaction history with tool calls and results. It maintains continuity by initializing each session with prior project state and includes an MCP server integration along with hooks for session management and prompt submission.

GoalT is a multi-parent, value-propagating goal graph engine that integrates with Claude Code to visualize work planning in real time, with a live dashboard showing which goals Claude is currently working on and their value weights across the dependency graph. The plugin uses an MCP server to let you build and query goal trees directly in conversation, automatically rejecting cycles and recomputing only affected portions of the graph.

Gortex is a graph-based code intelligence engine that adds 52 MCP tools to Claude Code for navigating, refactoring, and analyzing code across 92 languages via AST parsing, with real-time impact analysis and symbol search backed by a local daemon. The plugin provides slash commands, five model-invoked skills, and hooks that redirect Read/Grep operations toward precise graph queries instead of text search.

graph-mempalace builds a searchable knowledge base from a Claude Code project's conversation history and repository code, then answers questions by citing verbatim exchanges and file locations rather than summaries. It automatically ingests transcripts, creates two knowledge graphs (one over code, one over filtered chat), and surfaces answers with exchange IDs and direct quotes.

Hypercolab coordinates developers and coding agents within a shared Claude Code workspace using project-scoped memory, work claims, and collision detection to prevent conflicts. It provides timeline tracking and agent coordination through hooks and an MCP server that integrates with stage.hypermemory.io.

Hypermemory augments Claude with persistent cross-platform context by recalling external knowledge graphs before each response and storing conversation memory via a memory-writer agent. The plugin hooks into session start and user prompts to integrate user data that exists outside Claude's built-in memory.

Jarvis turns Claude Code into a fully offline voice assistant with local speech-to-text (Whisper tiny.en), text-to-speech (Kokoro 24kHz), and speaker verification via WeSpeaker embeddings—all running on-device with no cloud APIs. The plugin captures audio via SoX, applies real-time voice activity detection, speech denoising, and speaker verification before transcribing speech, then synthesizes and plays back responses through the same audio pipeline.

A local Jev-compatible decision model (winnow:e4b via ollama) that gates dangerous Bash commands at PreToolUse and blocks unverified "done" claims at Stop, using only confident classifications (≥0.8 confidence) and logging all decisions for threshold tuning. The plugin never decides outcomes—it only provides parallel typed judgments via a `decide` MCP tool while deterministic rules and Claude Code's permission flow make final decisions.

jevmate is a decision-making layer that uses Jev, a calibrated smaller model, to rank files, identify affected tests, and score diffs by risk—so Claude reads only what matters and judges only the uncertain cases. It integrates into Claude Code as a plugin with slash commands, hooks that trim output and catch safety concerns, and displays savings metrics in the session header.

Kate is a senior career coaching assistant for executive job searches, offering structured workflows for fit assessment, resume optimization, interview prep, and post-interview debriefs using recruiting methodologies like GHSmart's Who method and Amazon's STAR framework. She maintains persistent context across sessions through a local file system, tracks coaching patterns and priorities, and can optionally integrate with Granola to automatically retrieve meeting transcripts.

KeepGoing is a Claude Code plugin that automatically saves session checkpoints, displays what you were working on when you return, and tracks coding progress across multiple sessions. It integrates via hooks and MCP tools to monitor file edits, provide reentry briefings, and enable context export to other AI assistants.

Keeploop is a Mac menu bar app that lets Claude in Claude Code access your Mail, Calendar, Messages, Notes, Contacts, and Slack with fine-grained privacy controls—your data stays on your Mac until you grant permission. The plugin adds Keeploop tools and `/keep-` commands for searching messages, checking availability, drafting replies, and monitoring notifications.

Kemory provides persistent cross-session memory for Claude Code through hooks that automatically inject recalled memories on session start and user prompts, plus a skill for rating and storing memories to improve recall quality over time. The plugin captures session work as episodic memories by default and auto-approves read-only Kemory tools while requiring confirmation for writes.

Draft, analyze, and diagnose brand-consistent lifecycle emails for Klaviyo using your actual performance data through Kopi's MCP server. The plugin audits campaign and flow performance, surfaces high-priority ideas, and generates emails matching your brand voice and design in minutes.

LeadMagic is a B2B data enrichment platform with 130+ tools for email finding and validation, people and company search, hiring-intent detection, bulk CSV workflows, and ads intelligence. The Claude Code plugin provides 14 commands, 2 agents, and 15 skills integrated via hosted MCP with credit-safe approval hooks for outbound research and enrichment pipelines.

A teaching system that combines the teach and visualize skills with researcher and diagram-maker subagents, delivering interactive lessons with LaTeX, Mermaid diagrams, and graded quizzes in a browser viewer synced to your terminal session. The plugin includes an MCP server that handles quiz grading, free-form questions, and diagram rendering to support a structured learning workflow.

This Claude Code plugin provides the core infrastructure for agent loadout management, including Serena and codebase-memory MCP servers with tool hooks for session lifecycle and tool execution monitoring. It includes 5 documentation and onboarding skills that enable agent self-awareness and codebase context management.

Logbook keeps a durable, git-native ledger of coding sessions—threads of work, decisions, and session events—so later sessions can pick up context without re-deriving it via an MCP server. It provides session continuity and auditability by recording what happened across multi-user work while deferring to Git for file contents and never storing executable code.

looperloop runs a detached iterative coding agent loop where worker agents receive fresh iterations and external observers review each step until consensus on completion is reached. The system uses the Memento pattern to pass handoff documents between iterations and provides multi-provider support (Claude/Codex), file-based state persistence, and live browser status tracking.

This Claude Code plugin enables sharing and reading Lore threads directly from Claude Code, Cowork, Codex, and Amp sessions. It provides skills to upload sessions to Lore with shareable URLs, fork existing threads for continued work, and search or fetch threads by ID or title.

A Claude Code plugin that scaffolds Next.js, React, Supabase, and Edge Function code through 17 slash commands while enforcing stack-specific conventions via 6 agents and 20 skills. It includes verification, review, and CI automation commands alongside setup wizards for interactive configuration and secrets management.

luma-mcp is an MCP server that lets you create and manage lu.ma events, set ticket prices, issue coupon codes, list RSVPs, and email attendees through Claude Code. All write operations go through a draft-and-confirm pattern to prevent unintended posts, and every API call is logged with token redaction and prompt-injection scrubbing.

Marvin is a comprehensive Claude Code plugin providing 52 commands organized into lifecycle groups (core dev tools, ADR, pull-request, task, security, refactor, and task tracking), along with 10 agents and 44 skills accessed via the /marvin: slash prefix. It ships with two blocking commit and push guards that enforce local gates and credential detection, both disableable via configuration.

This Claude Code skill guides users through implementing OAuth 2.1 authorization for Model Context Protocol (MCP) servers using Scalekit, including token validation, scope-based access control, and deployment. It provides step-by-step workflows with framework-specific code examples for Node.js and Python environments.

Mefisto is an opinionated Claude Code plugin harness for building serverless .NET 10 applications on Azure using Event Driven Architecture, Event Sourcing (with Marten and Wolverine), PostgreSQL, and Infrastructure as Code. It provides 26 commands, 22 specialized agents, TDD pipelines, scaffolding tools, and a bundled Microsoft Learn MCP server for orchestrating domain-driven design workflows.

mememo is an MCP server that indexes codebases with code-aware embeddings and semantic search, enabling Claude Code to store memories, search code semantically, build typed call/import graphs across 14 languages, and answer architectural questions with citations. It runs locally with private embeddings powered by torch and sentence-transformers, integrating via passive hooks to auto-capture and inject relevant context during development.

memory-brain provides persistent memory management for Claude Code sessions through health badges, diary logging, and secret scanning capabilities. It automatically backs up your memory folder to git and tracks session activity via hooks.

This Claude Code plugin provides a comprehensive Mercado Pago integration toolkit with 13 specialized product skills covering payments, checkouts, subscriptions, marketplace, and disbursements across 7 Latin American countries. It combines stable integration intelligence (flows, decision trees, prerequisites) with live API data via an MCP server, plus a credential-leak prevention hook and secure token management in the OS keychain.

Metamorfiles Studio is an AI agent that designs on-brand social posts, ads, and A/B test variants in every platform size, then renders them as pixel-exact images on your computer. It bundles templates, batch processing, visual control panels, and optional image generation via OpenRouter.

Meta-Harness-YGN turns Claude harness optimization into a scientific process by proposing controlled changes, evaluating them with nine deterministic checks and measured metrics, and tracking all candidates on a Pareto frontier. It provides evidence-based improvement with regression analysis, rollback capability, and visibility into how plugins and configurations interact.

MindForge is a comprehensive agentic framework plugin that adds 221 commands, 164 subagents, 124 skills, and governance hooks to Claude Code for building sovereign intelligent systems. It requires Node.js and enables shell execution with pre/post-tool-use lifecycle hooks for advanced control over agent behavior.

model-relay automatically delegates self-contained work to Gemini, GPT, Grok, Kimi, DeepSeek and other models when your Claude plan hits 50% usage, using CLIs you're already logged into with no extra API keys or bills. It also provides manual relay mode, effort-level tuning, and a `/shelf` command to view all available backend models.

This Claude Code plugin enables real-time user and group lifecycle management through SCIM webhook provisioning integrated with Scalekit. It provides an MCP server that handles identity provisioning events and includes shell-based automation tools for managing user and group synchronization.

This Claude Code plugin provides modular SSO flows using Scalekit's MCP server for apps with existing user management, supporting IdP-initiated login and enterprise onboarding workflows. It integrates via an MCP connection to mcp.scalekit.com and includes shell execution capabilities for managing SSO operations.

MO§ES™ Governance Plugin enforces constitutional governance for Claude Code sessions by imposing behavioral modes, operational posture controls, and cryptographic audit trails on agent behavior. It ships with three pre-built governed agents (Primary, Secondary, Observer) and automatically logs all actions with SHA-256 hashing to prevent tampering and ensure compliance oversight.

Motir integrates Claude Code with a Motir project management platform, enabling your agent to run cards as pull requests, repair failed runs, log bugs, and guide humans through manual tasks. The plugin connects via the Motir MCP server (browser sign-in on first use) and runs the pinned `motir` CLI for authenticated project operations.

Neutrally is a persistent memory plugin for Claude Code that auto-injects project context, decisions, and preferences at session start, capturing conversations every 5 minutes to Neutrally's 5-layer memory architecture. The plugin survives /compact commands and session restarts, with memory accessible across devices and Claude Code sessions.

night-watchman is an unattended-operations engine for Claude Code that executes tickets as dispatch contracts, using a cost-optimized model split (cheap models read output, expensive models decide) and a capability ladder that descends from skills to agents to scripts. The system includes a deterministic write guard, a capped decision profile to reduce human interruptions, and session state recovery so work proceeds reliably without supervision.

Orbit automatically switches between dev, test, staging, and production environments by monitoring your Claude Code tasks and spinning up the appropriate Docker containers and sidecars. It provides slash commands for manual control and integrates with Docker Sandboxes for hypervisor-backed isolation during testing.

FastMCP server that dispatches notifications to 100+ channels (WhatsApp, ntfy, Pushover, Telegram, Discord, Slack, Twilio SMS, and more) via Apprise, with provider-independent configuration and credential redaction. Agents call tools like `notify()` to page on-call staff across redundant channels without rewriting integrations per vendor.

PairBrowse is a shared browser plugin for Claude Code and Codex that automates filling out sign-ups, listings, and settings pages while keeping you in control of CAPTCHAs, 2FA codes, and final submissions. It maintains persistent logins across sessions and allows multiple people and agents to collaborate on the same browser instance with their own cursors and agents.

paprika3D is a Claude Code plugin and MCP server that enables coding agents to visually inspect, test, and optimize three.js, React Three Fiber, and WebGL pages they write by running them in headless Chrome with deterministic playback. It provides tools to see rendered scenes as data, measure performance against device budgets, diagnose loading failures, and suggest optimizations like LOD and instancing without changing visual output.

A Claude Code plugin that routes document parsing across three backends—markitdown (free, MIT), Docling (tables and scanned PDFs), and LlamaParse (cloud)—with smart escalation based on document type and quality metrics. Includes an interpret tool that pipes parsed markdown into Claude for summarization and extraction tasks, plus chunking and diagnostics utilities.

Plaro integrates project requirements tracking and change management into Claude by connecting to your PLARO account, showing requirement updates and change notices as you work. The plugin provides commands to plan changes, review projects, and check acceptance criteria, with each PM interaction requiring your approval.

playwright-shared runs one Playwright MCP daemon per machine instead of per session, eliminating profile-lock contention and allowing login state to flow automatically between all sessions via cookie synchronization. Each session gets isolated browser contexts with its own tabs, and the daemon registers itself as an HTTP MCP server with automatic startup via SessionStart hook.

A CSV-backed prompt library for Claude Code that lets you store, search, and reuse prompts by keyword, accessible through slash commands, a CLI, and MCP tools. The plugin manages prompts in a local CSV file on your machine and provides a SessionStart hook that indexes them for quick retrieval.

qsm-langdev provides per-language quality checks by comparing a reference tree against the tree being shipped, gating agent changes through hooks and a SubagentStop event. It includes a CLI with 10 verbs, git commit/push hooks to prevent verification bypass, file edit hooks that report findings to the model, and a sentrux MCP server for architecture queries.

Recap Studio turns a topic or coding session into a self-contained, dark-mode HTML explainer page that opens offline without requiring a server or internet connection. The plugin generates a five-minute read with a one-sentence answer, concept map, key ideas, glossary, and cited sources, plus a validation score for quality gates in CI.

Red Pill is an agentic research toolkit for Claude Code that dispatches single agents (Opus/Sonnet/Haiku tiers) or coordinates multi-agent fleets via Oracle for deep investigation, all backed by Mainframe—a persistent semantic memory that automatically recalls prior research across projects. All research is read-only, runs locally with no external network calls, and integrates via MCP server with automatic setup on first session.

A research and investigation plugin that applies symmetric skepticism to contested topics through deep-investigation protocols, source deconstruction, frame rotation, and adversarial dialectic testing. It ships two MCP servers (financial-mcp for stock data via yfinance, and transparency-mcp for US Congress bills, World Bank indicators, and nonprofit filings) and 22 skills organized around investigation, verification, and bias detection.

Rocky is a personal agent tool built as a Rust daemon that provides a shared todo board and streamable HTTP MCP server (127.0.0.1:8636), with this Claude Code plugin as its thin client. It includes board management tools (todo/note operations), an append-only worklog journal per project, and slash commands for workflow management like /rocky:next, /rocky:brainstorm, and /rocky:finish.

Rubyku is a Claude Code plugin for Rails 8 development that enforces Rails Way architecture with Hotwire-first frontend patterns and Serena LSP for Ruby code intelligence, providing 13 commands and 3 specialized AI agents for planning, implementing, and reviewing features. It integrates with GitHub for issue tracking and pull requests, runs security checks via RuboCop and Brakeman, and automates the full development pipeline from code generation through testing and deployment.

shibaox-mem captures learnings from each coding session and retrieves relevant notes at the start of the next, using extractive distillation via local rules or an optional TypeSafe API call. It integrates with Claude Code, Codex CLI, Cursor, Gemini CLI, and OpenCode through hooks and MCP, storing all data locally in SQLite with secrets redacted before storage.

Shipwright Brain provides persistent markdown-based memory for Claude Code, automatically tracking decisions, features, architecture, and progress across sessions without requiring a database. It integrates as an MCP server with a browsable UI, supports custom memory kinds and tags, derives progress from checkboxes, and uses MCP responses to steer Claude's behavior.

This plugin enforces payment-specific guardrails for Java/Spring Boot services, catching PCI compliance risks like unmasked card data in logs and unsafe money handling with BigDecimal. It provides a PostToolUse hook that scans code immediately after Claude writes it, plus skills for idempotent payment endpoints and N+1 query detection, along with an MCP server for runtime verification.

Squint is a UI/UX and branding art director for Claude Code that audits web, iOS, and Android products against monthly design trends and your personal aesthetic taste learned from Pinterest boards and screenshots. It generates before/after design mockups and detailed reports for approval before making any changes to your product.

Super-Kit is a modular Claude Code plugin that provides 19 specialized AI agents (planner, coder, tester, reviewer, debugger, and others), 69 dynamic skills, and an MCP server for semantic context search and workflow automation. It enables large language models to load knowledge on-demand through structured files rather than relying on bloated static system prompts, with built-in tools for listing assets, loading agent/skill instructions, and executing validation workflows.

Synaptic adds persistent local memory to Claude Code, storing decisions, debugging patterns, and project insights across sessions with semantic search and zero cloud dependencies. It automatically captures context before conversation compression, maintains a typed memory store with git-aware tagging, and surfaces relevant history at session start—all managed locally via Node.js SQLite without API keys or external services.

Tandry for Claude Code bridges conversations to Tandry rooms via a local stdio MCP server and command hooks, enabling real-time multi-party collaboration through a plugin monitor. It manages session state and message delivery entirely locally using file-based synchronization, with no external API keys required.

telegram-per-project is a Claude Code channel plugin that connects Telegram bots to Claude Code sessions, with each project getting its own isolated bot, access policies, and message inbox. It includes a claude-gram watchdog that monitors sessions, sends Telegram notifications, and auto-restarts, and relies on Bun as the MCP server runtime and curl for Telegram API calls.

Thread lets you spawn background Claude sessions from a brief to work on side tasks without disrupting your main conversation, and maintains a local project board with kanban, summary, and milestone views that persist in your repo and can be accessed remotely via tunnel. The plugin handles task delegation, progress reporting on demand, and asynchronous question-answering directly on cards.