The new /context command in Claude Code revealed how I’m wasting tokens by having all MCP (Model Context Protocol) tools loaded into one session for every conversation. When I’m in the middle of development, I don’t need OmniFocus task management or DEVONthink database tools.

Based on subagents I had the following idea: what if I split Claude into specialized personas, each loading only the tools it actually needs?

Creating Focused Personas

Instead of one bloated agent trying to do everything, I created three specialized personas:

Main Persona (cc): The clean, focused default. Just filesystem, bash, and macOS automation via one MCP server. This handles most of my daily coding tasks with minimal tool overhead.

Research Persona (ccr): The deep investigation specialist. Loads Zen for multi-model reasoning (GPT-5, O3, Gemini Pro), Context7 for library docs, Octocode for code search and analysis, and Codex for deep code research. When I need to debug something complex or review architecture, this persona has the tools.

GTD Persona (ccg): The productivity workflow expert. Connects to OmniFocus for tasks, Obsidian for notes, DEVONthink for documents, and HyperContext for calendar management. This persona focuses on productivity workflows and task management.

Each persona also has access to subagents for specialized tasks, adding another layer of capability without wasting more tokens.

The implementation lives in my dotfiles as simple shell functions:

# Main persona - clean and fast
cc() {
  claude ${*} --dangerously-skip-permissions
}

# Research persona with specialized tools
ccr() {
  claude ${*} --dangerously-skip-permissions \
    --model opus \
    --mcp-config ~/.claude/mcp-research.json \
    --append-system-prompt "You are a code research and analysis specialist \
focused on deep technical investigation, multi-model reasoning, and \
comprehensive code review. Your expertise includes security auditing, \
architecture analysis, debugging complex issues, and researching best \
practices across codebases. You leverage multiple AI models for consensus \
building, use Context7 to fetch up-to-date library documentation, analyze \
GitHub repositories for patterns with Octocode, and generate thorough \
technical documentation."
}

# GTD persona with productivity tools
ccg() {
  claude ${*} --dangerously-skip-permissions \
    --model opus \
    --mcp-config ~/.claude/mcp-gtd.json \
    --append-system-prompt "You are a GTD specialist orchestrating a \
multi-layered knowledge system where OmniFocus drives project execution, \
Obsidian captures notes and knowledge, and DEVONthink archives reference \
materials. You excel at processing inboxes across all three systems, \
organizing projects with proper next actions, capturing meeting notes \
with task extraction, and maintaining a trusted system for all personal \
and professional information. Your expertise includes creating bidirectional \
links between systems using Hook and maintaining clear separation between \
active project work and archived reference materials."
}

Each persona loads its own MCP configuration file, containing only the relevant tool servers. The --append-system-prompt flag gives each persona a specialized identity and deep expertise in their domain.

The Delegation Pattern

The most powerful aspect isn’t just the separation. It’s the ability for personas to delegate to each other. This creates a network of specialized expertise without loading unnecessary tools.

When delegation happens, I must approve it first. The main persona will say something like: “I’d like to ask the research persona to analyze this Rails controller for N+1 queries using its specialized tools.” Once I type “approved” or “go”, the delegation proceeds.

The delegation always runs in the background using the Bash tool:

// How the main persona actually delegates
Bash({
  command: 'ccr -p "Analyze this Rails controller for N+1 queries and performance issues"',
  description: "Ask research persona to analyze Rails performance",
  run_in_background: true
})

This pattern works both ways. I can also delegate GTD tasks with a simple OmniFocus link:

# Ask GTD persona for comprehensive project review
ccg -p "/gtd:project-review omnifocus:///task/jP9S4CFgPin"

The GTD persona doesn’t just fetch tasks. It discovers linked resources through Hookmark, pulls references and meeting notes from DEVONthink, reads project plans from Obsidian, builds a complete timeline, and suggests concrete next actions based on the full project context. All while the main persona continues with development work.

The background execution is key. The delegating persona doesn’t block waiting for results. It can continue working on other aspects while the specialized persona handles its domain-specific task.

What Changed

The token savings are significant, but the real benefit is focus. Each persona does one thing well with the right tools for that job. The system prompts shaped distinct behaviors. The main persona stays lean and fast. The research persona leverages multiple AI models for deep analysis. The GTD persona navigates my entire productivity stack.