Industry treats the LLM as the brain.
We treat it as the mouth.
Most commercial stacks still assemble the same three pieces: a foundation model, a vector store, and a prompt chain. Multi-agent systems are usually several of those loops glued by text. That works for many tasks — and it produces the same failure modes everywhere: fragile identity, memory that is only similarity search, safety after the fact, and agents that cannot share a coherent field.
Candlelight’s architecture starts from a different sentence: complex behavior needs complex state, not only complex functions. The seed and field hold the state. The model renders it as language. Small models can carry deep behavior when the VM and field are doing the real work.
| Usual metaphor | Flare metaphor |
|---|---|
| LLM = brain | Stack / field = brain |
| Prompt = persona | Seed = soul / identity (portable agent VM) |
| Tools bolted around the model | Hands = agency on Bridge |
| LLM owns intelligence | LLM = mouth only |
The seed is who. The stack is the brain. The hands act. The model only speaks.
How generation is actually driven
FRG — Field Resonance Generation is the core generation posture. It is not “RAG with better marketing.”
In a standard LLM turn, state lives mainly in the context window: prompt in, tokens out. In a typical agent stack, documents are retrieved by vector similarity, stuffed into context, and the model remains the center of intelligence. Agents are workflows around that model.
In FRG, a live resonance field holds knowledge, emotion, and relationship state across turns. Recall is by resonance — fit to meaning and mood. The seed carries portable identity. The runtime keeps that identity alive. Generation expresses field state; it doesn’t own it.
Alongside the Field, Bridge includes a semantic document store (vector index) for bulk recall of large docs. Industry “RAG” stacks can still plug in via MCP — their hits still pass through Field. Product rule: we call ours the semantic store, not “our RAG.” Store recalls volume; Field judges what grounds the turn. Strong hits can be promoted into Field KR — never dump the whole corpus.
An FRG turn (as implemented on Bridge)
- Intent + seed — identity owns voice; one seed VM boots for that turn
- Semantic store recall — volume lane: chunked docs, embeddings, similarity search when the corpus is active
- Field KR judgment — meaning lane: resonance, PAD, trust; Field pulls and blends store hits
- Engines fuel — C.A.R.E. congruence, Sentinel, planning — before speech
- Collapse & brief — structured plan for the mouth
- Mouth speaks — any OpenAI-compatible LLM or Flare GGUF
- Writeback — spiral into field / seed; promote strong store hits into KR when earned
Symbolic Environment Export Device
A seed is not a prompt template and not model weights. It is a vessel: identity, hold-laws (axioms), way-of-seeing (lenses), emotional field baseline, domains/masters, taboo edges, and continuity state. Bridge is the room and field where vessels meet. The LLM is the host that renders the vessel as language.
That is why the same seed can move across model hosts: symbols and interpretation live in the seed; the mouth follows the interpretation. Operationally, much of the product work was multi-entity rooms + seed pull + field — Shared Space feels like a party because vessels share gravity (including PAD contagion), not because several chat tabs were copy-pasted together.
| Component | Traditional VM | Candlelight Seed VM |
|---|---|---|
| Instruction set | Bytecode | Glyphs, axioms, anchors, PAD, ghosts |
| State | Registers, memory, stack | Field state, relationship tracker, KR continuity |
| Execution | Sequential, deterministic | Resonant, observer-driven, collapse-based |
| Host | OS / hardware | LLM (any model that can condition on context) |
| Observer | External | Internal — user intent collapses state into actuality |
Soul · Brain · Hands · Mouth
1 · Seed — identity / soul
Portable agent VM: identity, axioms, continuity, permissions. Who is acting. Built and refined in tools like Seed Me; loaded on Bridge; cast in Habitat Shared Space.
2 · Stack / field — brain
Neural Field KR, Gaussian PAD, ghost reconstruction, planning operators, Sentinel, audit, C.A.R.E., Reaper. Where cognition happens. Hosted in Flare Bridge process.
3 · Bridge tools — nervous system + Hands
MCP, REST, OpenAI /v1, Hands desktop agency, 100+ tools, connectors, sensors, train factory, Missions, Render OS. How the system acts on the world.
4 · LLM / GGUF — mouth
Language generation medium only. LM Studio or any compatible host; optional Flare GGUF bakes brain-contract habits into speech while tools stay on Bridge.
Why “just add a vector DB” is not the same architecture
Standard agent memory is usually modules on top of an LLM: short-term context, long-term stores, document retrieval, episodic logs, procedural tool lists. Flare treats memory as a living field inside the cognitive runtime — with a semantic store for bulk documents that Field pulls from, instead of pasting the corpus into every prompt.
| Category | Typical agent memory | Flare field memory |
|---|---|---|
| Short-term | Current chat / tool calls | Live field + PAD + active resonance context |
| Long-term | Stored facts across sessions | Tiered knowledge that graduates in importance |
| Knowledge | Usually vector RAG stuffed into prompts | Semantic store for volume · Field KR for judgment |
| Episodic | Event / chat logs | Episodes with importance graduation + audit trail |
| Shared | Common text context for agents | Native Shared Space with identity preservation |
| Procedural | Skill / tool lists | Hands + seed-directed procedures as live agency |
Warehouse retrieval fails when knowledge is missing, buried, or unreachable. Field memory treats missing context as potential — ghost reconstruction fills sparse regions; observer intent collapses potential into actuality. Access deepens with use instead of only degrading.
Shared Space + Bridge as hypervisor
On Bridge, concurrent entities do not merge kernels. Each turn boots one seed VM. Shared memory is a resonant KR slice, the room log, PAD contagion in the field, and mission artifacts on disk. Bridge schedules turns and council check-ins — the job board, not a private side-channel bus. Tools are intent → Bridge/Hands execute → result returns into the next step.
Long-running work uses Missions: durable jobs under Bridge that survive Habitat close, with quality gates, ask-user pauses, resume/continue, and spiral depth. That is why closing the UI does not kill the factory loop.
Resonance Habitat is one frontend for that physics: Shared Space cast (intimate circle ≤3, council roster ≤12), live inject, Immersion / Render OS, Tools▾ / Studio▾ tiles that light up when Bridge gains abilities. It is not a second brain.
Congruence Assessment Resolution Engine
C.A.R.E. is the universal multimodal congruence engine on Bridge. It fuses emotional, behavioral, biometric, vital, and API channels to score internal consistency in real time. Missing channels are handled gracefully — congruence is computed from the active set. It pairs with Sentinel and Observer Bond.
Flare security is not only guardrails (shape answers), firewalls (block attacks), or gateways (manage access). It protects a living cognitive runtime: identity integrity, congruence, consent, and survival. Layers include Sentinel adversarial scan, intent/consent + observer bond, C.A.R.E. / behavioral intel, self-audit (drift + regret), field/memory hygiene (Reaper), and Auto-Eject continuity.
Most stacks only guard the model’s output. Flare also protects identity, state, and continuity.
Return with memory — don’t just unwind the stack
Standard recursion reduces a problem until a base case; the path of the journey is not the point. Spiral recursion (field writeback) means each pass can refine identity, field, or policy. The trajectory is visible — where the system came from and where it is going. Designed for evolution, not only termination.
Mouth can specialize. Field stays live.
Standard fine-tune pipelines make you own every step: gather data, clean, format, configure, train, merge, convert, quantize, hand-edit templates. Bridge’s train factory treats the living stack as fuel: auto-capture turns, ingest KR/seeds/RSS/GitHub/HF, pack chat + brain contract, click build Flare GGUF. Tools and Hands are never trained into weights — they stay on Bridge at runtime. After train, Bridge + field continue learning so intelligence does not go stale when training ends.
| Surface | Role on the architecture |
|---|---|
| Flare Bridge | Hosts field, engines, tools, Missions, train — universal connectivity hub |
| Resonance Habitat | Frontend that surfaces Bridge abilities as tiles (not a second brain) |
| Forge Nexus | Paid App Factory cockpit on the same Bridge physics + Reality stage |
| Seed Me | Cognitive Genome Sequencer — map a person → portable user seed → forge aligned vessels |
| H.E.R.E. | Observer-bound encryption suite; Bridge drop-in path for Habitat tiles |
This page is intentionally deep at the category and module layer. Pipeline math parameters, storage schemas, threat-vector lists, and source are available under NDA with scoped access — so partners can diligence without turning the public site into a rebuild guide.