How the Planner Agent Activates for Feature Implementation in Claude Code

The planner agent is automatically activated for feature implementation through rule-based orchestration and self-describing agent metadata that detects complex feature requests without requiring explicit user commands.

When working with the WorldFlowAI/everything-claude-code repository, understanding how the planner agent springs into action helps you leverage its implementation-planning capabilities effectively. This specialized agent handles complex feature development and architectural changes through an intelligent dispatch system that reads your intent from natural language requests.

Rule-Based Orchestration Triggers Automatic Activation

The orchestration layer in rules/agents.md defines explicit mappings between request types and agent assignments. For complex feature requests and refactoring tasks, the system mandates planner agent invocation without additional prompting.

The governing rule states:

"Complex feature requests – Use planner agent"

This rule fires automatically when the dispatch logic parses your request. You don't need to manually specify the agent or add flags—the pattern matching happens behind the scenes.

Self-Describing Agent Metadata Defines Activation Policies

Each agent in the repository carries a markdown header declaring its purpose and when it should activate. The planner agent's metadata in agents/planner.md explicitly instructs the system to use it PROACTIVELY for specific scenarios.

The header declares:

---
name: planner
description: Expert planning specialist for complex features and refactoring.
Use PROACTIVELY when users request feature implementation, architectural changes, or complex refactoring.
Automatically activated for planning tasks.
---

This self-documentation serves dual purposes: it guides human developers and provides machine-readable instructions to the orchestration layer.

Practical Activation Examples

CLI Command Invocation

The standard way to trigger planner agent activation is through the plan command. The CLI parses natural language and routes to the planner when it detects feature-implementation patterns:

claude plan "Add OAuth2 login flow with token refresh"

The command handler in commands/plan.md forwards this request to the planner agent automatically.

Internal Dispatch Logic

The orchestration system implements pattern matching at the code level. Simplified dispatch logic shows how request types map to agent launches:

// Internal dispatch logic (simplified)
if (request.type === "feature" || request.type === "refactor") {
  // Rule "Complex feature requests – Use planner agent" fires here
  launchAgent('planner', request);
}

This ensures consistent behavior across all entry points—CLI, API, or internal calls.

Resolution Flow

When multiple agents could potentially handle a request, the orchestration layer resolves conflicts using the explicit rules in rules/agents.md. The planner agent takes precedence for:

• New feature development
• Architectural modifications
• Substantial refactoring operations

Key Files Controlling Planner Agent Activation

File	Purpose	Location
agents/planner.md	Agent definition with activation policy	agents/planner.md
rules/agents.md	Central rule set mapping requests to agents	rules/agents.md
commands/plan.md	CLI command implementation	commands/plan.md

These files implement the complete activation pipeline. Modifying rules/agents.md changes when the planner engages; editing agents/planner.md updates its self-described capabilities.

What Requests Trigger Planner Activation

The following patterns consistently activate the planner agent according to the source code:

• Feature requests – Any new functionality described by the user
• Architectural changes – Modifications to system structure or design
• Complex refactoring – Large-scale code reorganization

Simple requests that don't match these patterns route to other specialized agents instead.

Summary

• Rule-based orchestration in rules/agents.md mandates planner agent use for complex features and refactoring without extra user input
• Self-describing metadata in agents/planner.md declares the planner should activate proactively for implementation planning
• The plan CLI command provides explicit access, but automatic pattern matching activates the agent from natural language alone
• Three core files—agents/planner.md, rules/agents.md, and commands/plan.md—implement the complete activation system

Frequently Asked Questions

Do I need to manually specify the planner agent when requesting a feature?

No. The orchestration layer automatically activates the planner agent when it detects feature implementation, architectural change, or complex refactoring patterns in your request. You can use the explicit claude plan command, but natural language descriptions also trigger automatic routing.

What distinguishes "complex" feature requests that activate the planner from simple ones?

According to rules/agents.md, the threshold centers on implementation planning requirements. Requests requiring architectural decisions, multi-step implementation strategies, or substantial code reorganization activate the planner. Simple, single-file modifications typically route to other agents.

Can I prevent the planner agent from activating automatically?

The repository design emphasizes proactive planner activation for feature work. To bypass the planner, you would need to modify the rule set in rules/agents.md or structure requests to avoid triggering the "feature" or "refactor" classification patterns in the dispatch logic.

How does the planner agent know what planning approach to use?

The agent reads its own metadata header in agents/planner.md to understand its scope, then processes the specific request details provided. It combines its self-described expertise with the actual user input to generate implementation plans tailored to each feature request.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}