Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Working Mode

    2

    Switch Claude Code between five working modes (A-E), from solo work to up to 14 role subagents, with per-mode review, approval and model rules.

    Free

    3 uses5.0 (2 reviews)
    Working Mode

    Working Mode

    Example session with this skill installed

    /working-mode C sonnet --once

    • Read your context and instructions
    • Compiled the working mode

    Mode changed for this session only (written to the session scratchpad; .claude/mode is untouched).

    Mode change

    BeforeAfter
    ModeB - SelectiveC - Full team
    Subagentsanalyst, test-writer, doc-writer9 role subagents: product-manager, analyst, architect, designer, developer, test-writer, qa, devops, doc-writer
    Reviewmain sessionqa subagent first pass, then the main session verifies critical findings
    Approvaldefault = approvalchoosing C = approval for these 9 subagents
    Expected cost1.15-1.35x2.5-4x (estimate)

    Model line

    Opus-defined subagents now run on

    Sonnet. Subagents already defined on another model keep it. Every Agent call to an Opus subagent passes model: "sonnet", and the model that actually ran is reported.

    Next steps

    1. Give me the task. I will list which subagents I am starting and why before starting them.
    2. At the end of the turn you get the number of subagents that ran and the estimated cost.
    3. /working-mode C (without --once) makes C the project default; /working-mode C with no model word goes back to the defined models.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Managing token usage and subagent orchestration across a complex project requires granular control over who works on what. This skill manages project-wide operating modes to balance speed, cost and depth of review. It gives you a structured way to move between solo execution and delegating to specialised Claude Code subagents, and to override the model those subagents run on.

    Built on Claude Code subagents (the Agent tool, plus the Workflow tool in mode E). It does not use the experimental Agent Teams feature; the old team-based modes are archived and never offered.

    The five modes

    ModeSubagentsReview
    A - Skillnone, everything in the main conversationthe main session
    B - Selective (default)analyst, test-writer, doc-writerthe main session
    C - Full team9 role subagents (B plus product-manager, architect, designer, developer, qa, devops)qa subagent, then the main session
    D - Wide14 role subagents (C plus security, data, coverage-auditor, observability, e2e-writer)qa + security/coverage-auditor, then the main session
    E - Fan-outD's 14 roles run in parallel through Workflowqa subagent, then the main session

    The main session is always the orchestrator; there is no separate orchestrator subagent.

    What it does

    • Switch modes between five levels (A-E) that decide which subagents may be started and who reviews their output.
    • Model overrides run every Opus-defined subagent on Sonnet or Haiku (/working-mode C sonnet) to control token spend.
    • Session persistence: --once stores the mode in the session scratchpad (survives context compaction); without it the mode is written to .claude/mode and shared through the repo.
    • Subagent gating: choosing a mode is the approval for its subagent set; at the end of each turn the number of subagents that ran and the estimated cost are reported.
    • Role handoffs follow role-selection.md: who does what, ordering, audits and when to stop.

    What's inside

    • SKILL.md and modes/ (A-E definitions, role selection, autonomous runs)
    • agents/: the 14 subagent definitions

    How it works

    1. At session start it asks for the mode and the model override (applied for this session only).
    2. /working-mode shows the current mode, its subagent set, reviewer and cost multiplier.
    3. /working-mode <A-E> [model] [--once] changes the mode for the project or just this session.
    4. The main session then follows that mode's rules for every subagent call.

    Why this beats prompting it yourself

    Instructions given in chat are lost after context compaction. This skill keeps the mode in a file, so the session never silently drifts back to a more expensive or less reviewed way of working.

    Use cases

    • Run routine work on Sonnet subagents instead of Opus.
    • Bring in 14 role subagents (mode D) for a large cross-cutting change.
    • Stay in mode A (no subagents) when you want to control every change yourself.

    Known limitations

    • Modes B-E need the bundled subagent definitions copied into .claude/agents/ (or ~/.claude/agents/).
    • Model words are limited to sonnet, haiku, fable and opus.
    • Cost multipliers are estimates.
    • A mode change is not retroactive.

    Model overrides are restricted to sonnet, haiku, fable, and opus. The skill requires a git repository or scratchpad directory to save state. Mode changes are not retroactive.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    5.0
    2 reviews
    5
    2
    4
    0
    3
    0
    2
    0
    1
    0

    This skill has been used 3 times.

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Permissions

    Terminal / Shell
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill solves the problem of 'token sprawl' and agent drift by providing a structured framework to toggle between high-depth multi-agent teams and low-cost solo execution modes. It ensures your agents adhere to specific review policies and budget constraints even during long, complex development sessions.

    The skill is compatible with orchestration frameworks that support model overrides, specifically targeting Opus, Sonnet, and Haiku models. It works by managing state files within your environment, making it versatile across different coding agents and terminal-based AI tools.

    Upon purchase, you receive the core logic for the five orchestration levels (A-E), the state management scripts, and the configuration templates for your project's `.claude/` directory. It also includes the documentation for integrating the mode-switching commands into your existing workflow.

    Setup is straightforward: you initialize the session via a startup prompt which creates a session-scoped scratchpad or a permanent configuration file in your project root. From there, the agent uses standard shell commands to reference these files as the source of truth for its current operating constraints.

    Yes, the mode settings can be stored in a permanent project-level configuration file, ensuring that every time you or a teammate opens the project, the agents respect the predefined review gates and model preferences. This provides consistency across team members and different development environments.

    New in Agents & Orchestration