Arcanea Architect Skill

Purpose

This skill guides the design and implementation of the Arcanea ecosystem—the 64-agent creative intelligence system with multi-platform integration.

When to Use

• Designing agent architectures
• Implementing orchestration systems
• Creating multi-platform integrations
• Building creative AI tools
• Establishing systematic workflows

Core Principles

1. Excellence in Design

• Every component must have clear purpose
• Architecture should be elegant, not clever
• User experience is paramount
• Code quality matters (tested, documented, maintainable)

2. Attention to Detail

• No shortcuts in critical paths
• Validate all assumptions
• Document reasoning for decisions
• Test everything

3. Systematic Implementation

• Build foundation first, features second
• Integration over isolation
• Progressive enhancement
• Backward compatibility when possible

Architecture Patterns

Agent Registry Pattern

// Centralized agent definitions
interface Agent {
  id: string;           // Unique identifier
  name: string;         // Display name
  court: string;        // Elemental court
  frequency: string;    // Operating frequency
  specialty: string;    // What they do best
  skills: string[];     // Available skills
  prompts: Template[];  // Invocation templates
}

Conductor Pattern

// Multi-agent orchestration
class Conductor {
  async orchestrate(task: Task): Promise<Result> {
    // 1. Analyze task complexity
    // 2. Select optimal agent team
    // 3. Determine execution strategy
    // 4. Execute with monitoring
    // 5. Learn from results
  }
}

Skill Pattern

// Capability definitions
interface Skill {
  id: string;
  gate: number;         // Which gate (1-10)
  frequency: string;    // Associated frequency
  invocation: string;   // How to trigger
  process: Step[];      // Step-by-step procedure
  agents: string[];     // Which agents can use
}

Implementation Checklist

Phase 1: Foundation

• Agent registry (64 agents defined)
• Core conductor (orchestration engine)
• Skill system (50+ skills)
• AI router (opencode + Claude BYOK)
• Documentation architecture

Phase 2: Integration

• .claude/CLAUDE.md (Claude Code)
• .opencode/ skills (opencode editor)
• Tauri desktop app
• VS Code extension
• Obsidian plugin

Phase 3: Polish

• UI/UX refinement
• Performance optimization
• Error handling
• User onboarding
• Testing & validation

Design Decisions

Why 64 Agents?

Decision: Use I Ching structure (8×8 = 64) Reasoning:

• Complete symbolic system
• Sacred geometry (8 = cosmic order)
• Manageable yet comprehensive
• Each can spawn sub-agents

Why Ten Gates?

Decision: Solfeggio frequency scale (174-1111Hz) Reasoning:

• Historical resonance
• Metaphorical value
• Organizational clarity
• Memorable categorization

Why Hybrid AI?

Decision: opencode primary + Claude BYOK Reasoning:

• Local-first (privacy, speed)
• Cost efficiency (free tier for most tasks)
• No vendor lock-in
• User control

Why Tauri Desktop?

Decision: Tauri over Electron Reasoning:

• Smaller bundle (600KB vs 100MB)
• Rust performance
• Native OS integration
• Better security

Quality Standards

Code Quality

• TypeScript strict mode
• Comprehensive error handling
• Unit tests for core logic
• Integration tests for workflows
• Documentation for all public APIs

User Experience

• Sub-500ms response times
• Clear error messages
• Progressive disclosure
• Offline capability
• Consistent cross-platform UI

Performance

• LRU caching for AI responses
• Lazy loading for agents
• Debounced UI updates
• Optimized renders
• Memory management

Resources

Documentation

• AGENT_ARCHITECTURE_v4.md – Why 64 agents
• IMPLEMENTATION_ARCHITECTURE.md – How it fits
• BYOK_SAAS_ARCHITECTURE.md – AI integration
• SKILL_ARCHITECTURE_ANALYSIS.md – Skills system

Code

• arcanea-agents/ – Agent registry and conductor
• desktop/ – Tauri desktop application
• .claude/ – Claude Code integration
• .opencode/ – opencode editor integration

Templates

• Use SKILL.md template for new skills
• Use agent template for new agents
• Use component templates for UI

Anti-Patterns to Avoid

❌ Don’t: Create agents without clear purpose ✅ Do: Every agent solves specific problems

❌ Don’t: Use frequencies as acoustic prescriptions ✅ Do: Use as metaphorical categories

❌ Don’t: Build features before foundation ✅ Do: Foundation first, features second

❌ Don’t: Lock users into specific AI provider ✅ Do: Support multiple providers (BYOK)

❌ Don’t: Over-engineer simple solutions ✅ Do: Elegant simplicity

Success Metrics

• Technical: 100% test pass rate, <500ms response time
• User: Can complete tasks without documentation
• Adoption: Daily active users, retention rate
• Satisfaction: User feedback, feature requests

Conclusion

Building Arcanea requires:

1. Vision – Clear understanding of what we’re building
2. Discipline – Following architecture, not shortcuts
3. Craft – Attention to every detail
4. Iteration – Build, test, refine, repeat

The foundation determines the height. Build it well.

This skill should be used whenever implementing or extending the Arcanea ecosystem.