Three Layers, One System
Most AI products are a thin interface over an API call. You send a prompt, you get a response, the system forgets you exist. Every session starts from zero.
Arcanea is built differently. The system has three distinct layers, each solving a different problem:
- **Starlight Intelligence System (SIS)** -- Persistent memory and learning
- **Intelligence OS** -- Agent orchestration and domain routing
- **The Platform** -- Creation tools and community
These layers are not marketing abstractions. They are separate codebases with separate responsibilities, and understanding the boundary between them explains most of Arcanea's design decisions.
Layer 1: Starlight Intelligence System
SIS is the memory layer. Its job is deceptively simple: make the AI remember what matters and forget what does not.
The Problem with Stateless AI
Current AI systems have a context window. Everything the model knows about you must fit in that window, and it resets every session. This creates a bizarre dynamic where the AI can write you a novel but cannot remember that you prefer third-person narration.
SIS solves this with three memory subsystems:
Episodic Memory -- Records what happened. "On March 15, the creator designed a water-based magic system for their desert world. They rejected the first two proposals because the power scaling felt arbitrary." This memory persists across sessions. When the creator returns a week later to expand the magic system, SIS provides the full context of previous decisions and their rationale.
Semantic Memory -- Records what things mean. "In this creator's world, magic is called 'Weaving.' Water magic is 'Tideweaving.' The naming convention follows [pattern]." This is the knowledge graph of each creator's world -- facts, relationships, rules, and conventions extracted from every interaction.
Procedural Memory -- Records how to do things. "This creator responds best to structured lists with examples. They prefer iterating from concrete proposals rather than abstract discussions. They work in 90-minute sessions." This shapes how the AI communicates, not just what it says.
How SIS Learns
SIS is not a static database. It uses a feedback loop:
- Every interaction is logged with metadata (domain, outcome, creator response)
- A nightly batch process identifies patterns across interactions
- Patterns that repeat above a threshold become encoded as preferences
- Preferences shape future interactions through system prompt injection
The result: the AI gets better at working with each specific creator over time. Not in a vague "personalization" sense, but in a concrete "remembers your world's naming conventions, your preferred level of detail, your working schedule, and the three magic system proposals you already rejected" sense.
Memory Architecture
SIS runs on Supabase (PostgreSQL + pgvector) with HNSW indexing for vector similarity search. Each creator's memory is isolated in its own namespace. Cross-creator learning happens only through anonymized pattern aggregation -- we never share one creator's world details with another.
The memory store currently handles: - ~190,000 words of reference material (the Library) - Per-creator world state (facts, rules, character sheets, timelines) - Interaction history with relevance scoring - Preference models per creator - Canon verification indices
Layer 2: Intelligence OS
The Intelligence OS is the orchestration layer. It decides which of the 16 specialized intelligences handles a given request, how they coordinate on multi-domain tasks, and how their outputs are assembled into a coherent response.
Agent Routing
When a creator sends a message, it does not go directly to an AI model. It goes to the Intelligence OS router, which:
- Classifies the request by domain (narrative, visual, music, code, etc.)
- Identifies the primary intelligence and any supporting intelligences
- Checks the creator's Gate level to determine capability exposure
- Pulls relevant context from SIS (memory layer)
- Constructs a composite system prompt from the selected intelligences
- Sends the enriched request to the model
- Post-processes the response through quality filters
- Feeds the interaction back to SIS for memory storage
This routing happens in under 200ms. The creator never sees the orchestration -- they experience a single, coherent AI that happens to be deeply knowledgeable about whatever they are working on.
The Mythology as Architecture
Here is where Arcanea's mythology stops being decorative and starts being structural. The Ten Gates, the Guardians, the Elements -- these are not just lore. They are the organizational schema of the Intelligence OS.
Each Guardian corresponds to a domain cluster. Lyssandria (Foundation Gate) governs the Earth-element intelligences -- the grounded, structural ones like Code and Research. Draconia (Fire Gate) governs the transformative intelligences -- World Architecture, Character Design. When a creator "opens a Gate" in the progression system, they are literally activating a new cluster of Intelligence OS capabilities.
This is why the mythology exists. Not because fantasy aesthetics are cool (though they are), but because we needed an organizational framework that creators could intuitively understand without reading an API reference. "Opening the Voice Gate" is easier to grasp than "activating the Narrative and Poetic intelligence clusters with elevated capability exposure."
Multi-Agent Coordination
Complex creative tasks require multiple intelligences working together. The Intelligence OS handles this through the Integration intelligence -- a meta-agent that decomposes tasks, assigns subtasks to specialists, mediates conflicts between their outputs, and assembles the final result.
Example: "Create a complete character profile for a villain in my world."
The Integration intelligence decomposes this into: - Character Design: psychology, motivation, traits, flaws - World Architecture: how this villain fits the world's power structures - Narrative: what story role this villain serves, their arc - Visual Composition: appearance description and image generation prompt - Lore: canon consistency check against existing characters - Dialogue: sample voice lines that establish personality
Each specialist works in parallel. Integration resolves conflicts (e.g., Character Design wants the villain to be stoic but Dialogue generated quippy one-liners) and produces a unified output.
Layer 3: The Platform
The Platform is what creators actually see and use. It is built on Next.js 16, React 19, TypeScript, Tailwind CSS, and Supabase, deployed on Vercel.
Creation Tools
- **Chat** -- Conversational creation with full SIS memory and Intelligence OS routing
- **Studio** -- Multi-modal creation (text, image, music, code) with consistent world context
- **Library** -- 190,000+ words across 17 collections, from creative philosophy to practical technique
- **Gallery** -- Visual asset management with AI-generated and curated content
- **Academy** -- Structured learning paths through the Ten Gates system
The Open-Source Layer
The platform is closed-source (it is the product), but the intelligence infrastructure is open:
- **27 repositories** on GitHub
- **35 npm packages** published
- **54 skills** available for agent customization
- **Overlays** for Claude Code, Cursor, ChatGPT, Gemini
Key open-source packages: - `@arcanea/core` -- Framework primitives (Gate, Element, Archetype, WorldConfig) - `@arcanea/soul` -- Agent personality and behavior engine - `@arcanea/flow` -- Multi-agent orchestration toolkit - `arcanea-skills-opensource` -- Community-contributed agent skills - `arcanea-records` -- Prompt templates and APL (Arcanean Prompt Language) spec
The open-source strategy serves two purposes: it lets other builders use Arcanea's intelligence architecture for their own projects, and it creates a community of contributors who improve the shared infrastructure.
How the Layers Talk
The data flow between layers is unidirectional by default:
``` Creator Input | v Platform (receives and renders) | v Intelligence OS (routes, orchestrates, enriches) | v SIS (provides memory context, stores new interactions) | v Intelligence OS (assembles final response) | v Platform (delivers to creator) ```
SIS never talks directly to the Platform. The Intelligence OS never stores data without routing through SIS. This separation of concerns is what makes the system maintainable at scale -- each layer can be developed, tested, and deployed independently.
Why Not Just Use RAG?
The obvious question: why not just use Retrieval-Augmented Generation with a vector database?
We do use RAG. SIS's semantic memory is essentially a sophisticated RAG system. But RAG alone does not solve the orchestration problem (which of 16 specialists should handle this request?), the progressive disclosure problem (which capabilities should be exposed at this creator's level?), or the multi-agent coordination problem (how do you merge outputs from five specialists into a coherent response?).
RAG is one component of Layer 1. The full system requires all three layers working in concert.
Performance
Current benchmarks across the production system:
- **Routing latency**: <200ms (Intelligence OS decision time)
- **Memory retrieval**: <150ms (SIS context lookup with HNSW indexing)
- **End-to-end response**: 2-8 seconds (depending on task complexity and number of intelligences activated)
- **Memory persistence**: Indefinite (no session-based expiry)
- **Cross-session context accuracy**: 94% recall on world-specific facts after 30+ days
These numbers matter because creative work is flow-state work. Every additional second of latency is a crack in the creator's concentration. The architecture is optimized for perceived responsiveness, not just throughput.
What We Are Building Toward
The three-layer architecture is designed to support a future state where creators do not interact with AI tools -- they interact with AI collaborators that know their world, understand their craft, remember their preferences, and improve at working with them over time.
We are not there yet. But the architecture is in place to get there.