Arcanea Architect Skill Skill

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:

Vision - Clear understanding of what we're building
Discipline - Following architecture, not shortcuts
Craft - Attention to every detail
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.

Agent Skills: Arcanea Architect Skill

Install this agent skill to your local

Skill Files