Archon Manager Skill

Master Archon MCP for strategic project management and knowledge operations.

Overview

The Archon Manager skill teaches you how to use Archon MCP effectively as the strategic layer in your development workflow. Archon manages WHAT to build and WHEN, while Skills guide HOW to build it well.

What You'll Learn

Project Management: Create hierarchical projects with features and tasks
Task Tracking: Priority-based workflow (P0/P1/P2), status management
Knowledge Management: RAG queries, web crawling, document processing
Two-Layer Architecture: Archon (strategic) + Skills (tactical) pattern
Progress Tracking: Metrics, velocity, burndown charts
Team Coordination: Multi-AI-assistant collaboration

When to Use

Starting a new project that needs structured task management
Building a knowledge base for AI-assisted development
Implementing priority-based workflows
Coordinating multiple AI coding assistants
Maintaining context across long-running projects
Tracking progress and velocity

Key Features

Strategic Layer (WHAT/WHEN)

Task Management: Get next priority task automatically
Project Structure: Hierarchical organization (projects → features → tasks)
Priority System: P0/P1/P2 for effective prioritization
Status Tracking: todo → doing → review → done

Knowledge Layer (Context)

RAG Queries: Semantic search across documentation
Web Crawling: Automatic sitemap detection and scraping
Document Processing: PDFs with intelligent chunking
Code Examples: Extract and search example code
Version Control: Track project documentation versions

Integration Layer (Coordination)

Multi-Client Support: Claude Code, Cursor, Windsurf
Real-Time Updates: Socket.IO for live collaboration
Unified Context: Same knowledge base across all AI assistants

Quick Start

1. Install Archon

# Clone repository
git clone https://github.com/coleam00/Archon.git
cd Archon

# Configure
cp .env.example .env
# Edit .env with Supabase credentials

# Start services
docker compose up --build -d

# Access UI: http://localhost:3737

2. Connect to Claude Code

Add to .claude/mcp-settings.json:

{
  "mcpServers": {
    "archon": {
      "command": "node",
      "args": ["/path/to/archon/mcp-server/dist/index.js"],
      "env": {
        "ARCHON_API_URL": "http://localhost:8181"
      }
    }
  }
}

3. Create Project

archon: create_project({
  name: 'My Application',
  description: 'Full-stack web app',
  status: 'active'
})

4. Add Knowledge

// Crawl documentation
archon: crawl_website({
  url: 'https://nextjs.org/docs',
  follow_sitemap: true,
  tags: ['nextjs', 'documentation']
})

5. Use Two-Layer Workflow

// Strategic (Archon): Get task
const task = archon:get_next_task({project_id: "uuid"})

// Strategic (Archon): Research
const research = archon:perform_rag_query({
  query: task.title,
  match_count: 5
})

// Tactical (Skills): Implement
// AI invokes relevant skills for implementation

// Strategic (Archon): Complete
archon:update_task({task_id: task.id, status: "done"})

The Two-Layer Architecture

ARCHON (Strategic)              SKILLS (Tactical)
    ↓                               ↓
WHAT to build, WHEN          HOW to build well
Task management              Domain expertise
Priority queue               Best practices
Knowledge queries            Implementation patterns
Context preservation         Quality standards

Together: Strategic coherence + Tactical excellence = Optimal outcomes

Common Use Cases

Solo Developer

// Morning: Get priority task
const task = archon:get_next_task({project_id: "uuid"})

// Research before starting
const research = archon:perform_rag_query({
  query: task.title + " implementation",
  match_count: 5
})

// Work on task (Skills guide implementation)

// Evening: Mark complete
archon:update_task({task_id: task.id, status: "done"})

Team Collaboration

// Lead creates structure
archon: create_project({ name: 'Team Project' })
archon: create_feature({ name: 'Backend', assigned_to: 'dev-1' })
archon: create_feature({ name: 'Frontend', assigned_to: 'dev-2' })

// Everyone queries same knowledge base
// Real-time sync across team

Knowledge-Intensive Work

// Build comprehensive knowledge base
archon: crawl_website({ url: 'https://docs.framework.com' })
archon: add_document({ file_path: 'architecture-spec.pdf' })
archon: extract_code_examples({ source_url: 'https://github.com/...' })

// Query for any implementation question
archon: perform_rag_query({ query: 'How to implement X' })

Archon MCP Tools

Project Management

create_project, list_projects, get_project, update_project
create_feature, list_features, update_feature
create_task, get_next_task, update_task, list_tasks
generate_tasks (AI-assisted)

Knowledge Management

perform_rag_query - Semantic search
search_code_examples - Find code snippets
crawl_website - Ingest web documentation
add_document - Upload PDFs
extract_code_examples - Pull from repos

Metrics

get_project_metrics - Overview stats
get_velocity - Tasks per week
get_burndown - Sprint progress

Best Practices

1. Clear Project Structure

Project
├── Feature (P0): Core functionality
│   ├── Task (P0): Must-have
│   └── Task (P1): Important
├── Feature (P1): Enhancement
│   └── Task (P1): High value
└── Feature (P2): Nice-to-have
    └── Task (P2): Polish

2. Effective Prioritization

P0: Core value prop, blocks everything
P1: Important, high impact
P2: Enhancement, can wait

3. Status Discipline

todo → doing → review → done

Update immediately when changing state.

4. Rich Knowledge Base

Crawl all relevant documentation
Add architecture documents
Extract code examples
Tag consistently

5. Strategic Queries

// Before task: research
archon: perform_rag_query({ query: 'How to implement ' + task.title })

// During task: specific questions
archon: perform_rag_query({ query: 'Edge case handling for X' })

// Architecture: decision support
archon: perform_rag_query({ query: 'Pattern A vs Pattern B for...' })

Related Skills

rag-implementer: Building RAG systems (Archon uses RAG internally)
knowledge-base-manager: KB design patterns
mvp-builder: Feature prioritization (P0/P1/P2 logic)
product-strategist: Product planning and validation
multi-agent-architect: Coordinating multiple AI agents

MCP Support

Works with Archon MCP (official, external):

Installation: https://github.com/coleam00/Archon
Port: http://localhost:8051
Services: API (8181), UI (3737), Agents (8052)

Integration Examples

Next.js Project: Project management + knowledge base from Next.js docs
Team Development: Multiple developers coordinated through Archon
RAG Application: Using Archon's own RAG for building RAG systems
Multi-AI Setup: Claude Code + Cursor + Windsurf on same project

Architecture

Archon uses microservices:

Frontend: React dashboard (port 3737)
API: FastAPI business logic (port 8181)
MCP Server: Protocol interface (port 8051)
Agents: PydanticAI for ML (port 8052)

All communicate via HTTP with Socket.IO for real-time updates.

Success Criteria

You're using Archon effectively when:

Project structure is hierarchical and organized
Always know what's next (get_next_task guides work)
RAG queries return relevant, useful results
Tasks flow smoothly: todo → doing → review → done
Progress is visible through metrics
Context preserved across sessions
Skills invoked for implementation guidance

Resources

Full implementation guide: SKILL.md
Integration patterns: DOCS/ARCHON-INTEGRATION.md
Complete example: EXAMPLES/archon-workflow-example.md
Official repository: https://github.com/coleam00/Archon
Official docs: https://archon-ai.com

Version: 1.0.0 Category: Project Management Estimated Time: 1-2 hours setup, ongoing use

archon-manager