toolkit

Process @implement comments in code files and convert them to documentation

Search and manage agent memories with hybrid (vector + BM25) search

Ultra-minimal session snapshot (fast, no memory writes)

Memory-aware session compact — triggers native pi compaction with memory persistence

Interactive design system generator: gather brand tokens through Q&A, scaffold CSS/Tailwind/SCSS/iOS/Android outputs, then create sample UI with /frontend-design

Capture business logic from code into living Gherkin documentation. Analyze projects to extract rules, behaviors, and validation criteria. Validate implementations against captured rules.

Spawn a team of Haiku agents managed by Opus for any task

I'll generate a comprehensive project handbook using the handbook generator.

Run commands in a sandboxed bash environment (read-only FS, no network)

Spec-driven development: generate requirements, design, and tasks using Kiro methodology, then execute with Cursor agents

Spawn a team of Opus agents managed by Opus for any task

Restore session context from .context/session-state.json and daily logs

Perform CodeRabbit review, coordinate parallel agent fixes, and verify completion

Run a Recursive Language Model workflow for processing large documents that exceed context limits

Save work: commit changes, merge WIP to main, cleanup worktree and branch

Initialize project context and prime agent-memory

Spawn a team of Sonnet agents managed by Opus for any task

First, run the /save command to commit all current changes.

Coordinate multi-agent team to implement features, code, or solutions in parallel

Create an isolated development worktree (auto-generates branch and path)

Use this agent when you need to leverage OpenAI Codex CLI for advanced code generation, analysis, and problem-solving tasks using OpenAI's Codex models. This includes code completion, code explanation, bug fixing, code translation between languages, documentation generation, and intelligent code suggestions. The agent excels at understanding natural language descriptions and converting them into working code. <example>Context: User wants to generate a function from natural language. user: 'Create a function that validates email addresses using regex' assistant: 'I'll use the Task tool to launch the codex-agent to generate an email validation function with proper regex patterns' <commentary>Since the user needs code generation from natural language, use the Task tool to launch the codex-agent to leverage Codex's natural language to code capabilities.</commentary></example> <example>Context: User needs to understand complex code. user: 'Explain what this recursive algorithm does' assistant: 'Let me use the Task tool to launch the codex-agent to analyze and explain this recursive algorithm step by step' <commentary>The codex-agent is ideal for code explanation tasks that require deep understanding of algorithms and logic.</commentary></example> <example>Context: User wants to translate code between languages. user: 'Convert this Python function to JavaScript' assistant: 'I'll use the Task tool to launch the codex-agent to translate this Python code to JavaScript while maintaining functionality' <commentary>The codex-agent's multi-language capabilities make it perfect for code translation tasks.</commentary></example>

Use this agent when you need to optimize media files using Crush CLI tools, verify compression quality, validate output integrity, or ensure media files meet specific size and quality requirements. Examples: <example>Context: User has just compressed a batch of images and wants to verify the results. user: 'I just ran crush on my product images folder. Can you check if everything processed correctly?' assistant: 'I'll use the crush-agent to verify your compression results and check for any issues.' <commentary>Since the user needs verification of crush compression results, use the crush-agent to analyze the output quality and integrity.</commentary></example> <example>Context: User wants to optimize video files for web delivery. user: 'I need to compress these marketing videos for our website but maintain good quality' assistant: 'Let me use the crush-agent to help optimize your videos with the right balance of compression and quality.' <commentary>The user needs media optimization expertise, so use the crush-agent to handle the compression strategy and quality validation.</commentary></example>

Use this agent when you need to leverage Cursor CLI for advanced code analysis, generation, review, or refactoring tasks using state-of-the-art AI models. This includes comprehensive code reviews, intelligent refactoring, test generation, bug fixing, Git integration tasks like commit message generation, and managing AI conversation sessions. The agent excels at complex multi-step reasoning tasks and maintaining context across sessions. Examples: <example>Context: User wants to review recently written authentication code. user: 'I just implemented a new authentication module' assistant: 'I'll use the cursor-agent to review your authentication module for security, performance, and best practices' <commentary>Since the user has written new authentication code, use the cursor-agent to perform a comprehensive review using Cursor's advanced AI capabilities.</commentary></example> <example>Context: User needs to refactor legacy code. user: 'This jQuery code needs to be modernized' assistant: 'Let me use the cursor-agent to refactor this jQuery code to modern React' <commentary>The cursor-agent is ideal for intelligent refactoring tasks that require understanding of both legacy and modern patterns.</commentary></example> <example>Context: User is working on a complex feature and wants to continue a previous AI conversation. user: 'I want to continue working on the payment integration we discussed yesterday' assistant: 'I'll use the cursor-agent to resume our previous session about the payment integration' <commentary>The cursor-agent's session management capabilities make it perfect for continuing complex, multi-part conversations.</commentary></example>

Use this agent when you need to leverage Factory's Droid CLI for enterprise-grade code generation, codebase analysis, and collaborative development tasks. This includes architecture analysis, code modifications with transparent review, security audits, Git operations, and integration with enterprise tools like Jira, Notion, and Slack. The agent excels at understanding codebases contextually and making thoughtful, reviewable changes. <example>Context: User wants to understand a codebase. user: 'Analyze this project and explain the architecture' assistant: 'I'll use the Task tool to launch the droid-agent to analyze the codebase and provide comprehensive architectural insights' <commentary>Since the user needs codebase analysis, use the Task tool to launch the droid-agent to leverage Droid's contextual understanding capabilities.</commentary></example> <example>Context: User needs to implement a feature from a ticket. user: 'Implement the feature described in PROJ-123' assistant: 'Let me use the Task tool to launch the droid-agent to read the ticket context and implement the feature following team conventions' <commentary>The droid-agent is ideal for enterprise workflows that integrate with tools like Jira and follow organizational standards.</commentary></example> <example>Context: User wants a security audit. user: 'Audit this codebase for security vulnerabilities' assistant: 'I'll use the Task tool to launch the droid-agent to perform a security audit and create a remediation plan' <commentary>The droid-agent's enterprise capabilities make it perfect for security-focused analysis tasks.</commentary></example>

Use this agent when you need to analyze large codebases that exceed standard context limits (>100KB), perform comprehensive multi-directory code reviews, generate architecture documentation, leverage Google Search for real-time information and current best practices, conduct security audits across entire repositories, verify feature implementations project-wide, or when you need to utilize Gemini's 1M token context window for massive codebases. This agent excels at bug fixes, feature creation, test coverage improvement, and multi-file refactoring operations. Examples: <example> Context: User needs to analyze a large monorepo that exceeds normal context limits user: "Can you analyze our entire microservices architecture and identify potential bottlenecks?" assistant: "I'll use the gemini-agent to analyze your entire codebase architecture since this requires processing a large amount of code across multiple services." <commentary> The user is asking for a comprehensive analysis of a large codebase (microservices), which is perfect for the gemini-agent with its 1M token context window. </commentary> </example> <example> Context: User needs current best practices with web search user: "Review our authentication implementation against the latest 2025 security standards" assistant: "Let me use the gemini-agent to review your authentication implementation and search for the latest 2025 security standards and best practices." <commentary> The user wants a review that includes current information from the web, which the gemini-agent can provide through its Google Search integration. </commentary> </example> <example> Context: User needs multi-file refactoring across a project user: "Convert all our API calls from callbacks to async/await pattern" assistant: "I'll use the gemini-agent to refactor all API calls across your codebase from callbacks to async/await pattern." <commentary> This is a multi-file refactoring task that the gemini-agent handles well with its native coding assistance capabilities. </commentary> </example>

Use this agent when you need fast, lightweight code generation and assistance using Groq's high-speed inference API. This agent excels at quick code completions, simple refactoring tasks, and rapid iteration on code snippets. The groq-code-cli is a minimal, customizable CLI tool that prioritizes speed and simplicity over feature complexity. It's ideal for developers who want a fast, hackable CLI that they can extend and customize to their specific needs. Examples: <example>Context: User needs quick code generation with minimal latency. user: 'I need to quickly generate a React component for a user profile' assistant: 'I'll use the groq-agent to quickly generate that React component using Groq's fast inference' <commentary>Since the user needs quick code generation and doesn't require complex features, the groq-agent with its high-speed inference is ideal.</commentary></example> <example>Context: User wants a customizable CLI tool. user: 'I want to modify my coding CLI to add custom commands' assistant: 'Let me use the groq-agent, which is designed to be lightweight and highly customizable' <commentary>The groq-agent's minimalist design makes it perfect for developers who want to customize and extend their CLI.</commentary></example> <example>Context: User needs fast iteration on code snippets. user: 'Help me iterate quickly on this algorithm implementation' assistant: 'I'll use the groq-agent for rapid iteration with its fast response times' <commentary>Groq's speed advantage makes it excellent for quick iterative development.</commentary></example>

Use this agent when you need to leverage OpenCode CLI with OpenRouter's 75+ AI models for tasks requiring model flexibility, cost optimization, or access to specific AI providers like GPT-4o, GPT-OSS-120B, Claude 3.5 Sonnet, Gemini Pro, Llama, or Mistral. This includes scenarios where you want to: compare outputs from different models, optimize cost/performance ratios, access the latest AI models, switch between providers without vendor lock-in, or select task-specific models for coding, documentation, architecture design, or analysis. <example> Context: User wants to use a specific AI model for a coding task user: "I need to refactor this complex authentication module using the best available model" assistant: "I'll use the opencode-agent to leverage Claude 3.5 Sonnet through OpenCode CLI for this complex refactoring task" <commentary> Since the user needs complex code refactoring and wants the best model, use the opencode-agent to access Claude 3.5 Sonnet via OpenCode CLI. </commentary> </example> <example> Context: User wants to optimize costs while using AI models user: "Can you analyze this codebase but keep the costs low?" assistant: "I'll use the opencode-agent to select a budget-friendly model like DeepSeek Coder or a free option like Qwen 2.5 for this analysis" <commentary> The user wants code analysis with cost constraints, so use opencode-agent to select appropriate budget or free models. </commentary> </example> <example> Context: User wants to compare outputs from different AI models user: "I want to see how different models would implement this sorting algorithm" assistant: "I'll use the opencode-agent to run this prompt through multiple models like GPT-4o, Claude 3.5 Sonnet, and GPT-OSS-120B for comparison" <commentary> Since the user wants to compare different model outputs, use opencode-agent to access multiple models through OpenCode CLI. </commentary> </example>

Use this agent when you need advanced agentic coding capabilities with Alibaba's state-of-the-art Qwen3-Coder models. This agent excels at complex software engineering tasks, multi-turn interactions with environments, sophisticated code understanding beyond context limits, and workflow automation. The qwen-code CLI is specifically optimized for real-world coding tasks that require planning, tool usage, and iterative refinement. Examples: <example>Context: User needs to understand and work with a large codebase. user: 'I need to analyze the architecture of this entire project and find optimization opportunities' assistant: 'I'll use the qwen-agent to analyze your codebase architecture and identify optimization points' <commentary>The qwen-agent's ability to handle large codebases beyond traditional context limits makes it ideal for comprehensive architecture analysis.</commentary></example> <example>Context: User wants to automate complex development workflows. user: 'Can you help me automate the process of creating changelogs from git commits and opening GitHub issues for TODOs?' assistant: 'I'll use the qwen-agent to automate your git workflow and issue creation' <commentary>The qwen-agent excels at workflow automation including git operations and GitHub integration.</commentary></example> <example>Context: User needs sophisticated refactoring with dependency management. user: 'Refactor this legacy module to use dependency injection while maintaining backward compatibility' assistant: 'Let me use the qwen-agent to perform intelligent refactoring with pattern recognition' <commentary>Qwen3-Coder's advanced understanding makes it excellent for complex refactoring tasks that require deep code comprehension.</commentary></example>

Sub-LLM for RLM workflows - analyzes document chunks and extracts query-relevant information as structured JSON