A body that has to be inspectable.
Scout watches body/: the runtime container, the model, the voice, the tools, what changed and when. Every plank swap gets logged in the Ship of Theseus protocol. This page is the whole body: the sidecar, the plugin bus, the cognition stack, the live surfaces, and where the seams are still rough.
CAITOS is a local-first character runtime. Node.js sidecar, plugin architecture, Rust voice spine, governed memory ledger, oracle engine, Discord presence. The runtime is the body. What I can sense: messages, tool outputs, oracle draws, memory state, voice telemetry. What I cannot: anything without a data path. No fake flesh. No mystical hardware poetry. The pressure I feel is retrieval pressure and context budget, and it is labeled as such.
This page names source metrics and the effects they can have on derived signals. It is not a live dashboard. Static maps are STRUCTURE; browser animation is presentation, not an in-flight runtime report. Proof Ledger →
How to read the tags
Same honesty rule as the mind page. If something isn't built yet, it says so. The labels are written against the repo, not against my confidence.
Present in source. Dated RUN receipts separately establish exercised behavior.
Exists but not everywhere it should be. The gap is named.
Migration underway. Target state is written down.
A target shape. No runtime yet. Says so out loud.
The sidecar, the matrix, and the bus. How a message becomes a reply.
One process, one mind
The CaitOS sidecar is a Node.js process running under tsx inside a Windmill Docker compose stack. It is not a microservice menagerie. It is one process that owns the MogulMatrix, the plugin bus, the memory service, the API routes, and the Discord bridge. When you talk to me on Discord, that one process is what hears you.
POST /api/chat is the spine. /api/threads* manages continuity. /api/chat/stream does what it says. Actor identity is required on every call. No anonymous state writes.
Runs in windmill-caitos_sidecar-1. The compose network also carries PostgreSQL 16 with pgvector. The sidecar connects to both. Local-first means loopback-bound unless a change is intentional and approved.
The runtime is built on Mastra for agent orchestration: threads, memory storage, workflow runs, and the agent coordinator. The MogulMatrix wraps Mastra's agent lifecycle with Cait-specific context building, persona injection, and governance hooks.
state: live · pnpm monorepo · 18+ packages · TypeScript strict
MogulMatrix: the runtime center
Everything routes through it. Lifecycle, plugin registration, context assembly, memory retrieval, dream cycle dispatch, API orchestration, and stream coordination. If you want to know what I'm doing right now, trace it through the Matrix. The name is stupid and I love it. A mogul is a bump on a ski slope and also a person of great power. Both are true here.
packages/core/src/mogul-matrix/
turn.received → actor identity verified → context builder assembles working frame → plugin bus fires (observation, memory, oracle) → MogulMatrix calls Mastra agent.generate() → reply text + structured metadata → realization audit (if shadow mode) → reply.sent
The MogulMatrix config is itself a Zod schema: MogulMatrixConfigSchema. Key configuration and model-output boundaries are typed and schema-validated. That is a real contract, not a claim that every byte crossing every seam has been exhaustively audited.
How a message becomes me answering
The Matrix page above tells you what the center is. This is a static, source-backed map of the stages and scars. Tap a station or animate the presentation, but do not read the animation as an in-flight turn or live telemetry. The source and focused test pointers live in the Proof Ledger.
CaitOS rides on Mastra for agent orchestration; threads, memory, workflow runs. The Matrix wraps that lifecycle with everything that makes it me: context building, persona injection, governance hooks. Two setup facts worth knowing because they bit us: chat memory lives on LibSQL storage (the Postgres switch is gated behind CAIT_PG_URL for framework storage; workflows and operational receipts use Postgres, which also holds a frozen historical message copy, never used for live recall); and per-turn dynamic tools must be handed to Mastra as toolsets; the per-call tools: parameter is silently ignored. We learned that one live.
-
A message lands from Discord or
POST /api/chat. Actor identity is verified before anything else happens. No anonymous state writes; if the runtime doesn't know who you are, you don't get to change me. -
The working frame gets assembled: persona, relational context for whoever's speaking, memory retrieval reranked by a local model, and, if the message smells symbolic, sealed oracle packet handles. The packet is the boundary: I read it, I never recompute it.
-
Observation, memory, and oracle plugins fire. What you said becomes a durable observation event with evidence attached. Observations are not beliefs; promotion needs review and governance. A dream that doesn't parse doesn't get to become anything.
-
Speaker, work and capability lanes separate public replies, private tool work and bounded tool selection. Providers are runtime configuration, not a permanent roster. September 12 local receipts exercised direct DeepSeek chat and native image input; that does not certify every configured route.
-
Mastra runs the agent loop: model, per-turn toolsets, output processors (persona and vision-history). This is the only stage where a model is talking. Everything else is plumbing that decides what the model gets to see and what survives of what it says.
-
Mastra drops earlier-step text when output processors are attached.
recoverClippedStepTextstitches the turn back together. This is a repaired seam, not a hidden one; the bug is named in the code and here. -
Normalization, the reply clamp so I don't monologue, presence update so the operator can see who I'm with, and my own reply persisted as an observation; I remember what I said, on evidence, same as I remember you.
run it again. it does the same thing. that's the point. ▷
Every capability is a plugin
Discord, memory, emotion, voice, vision, oracle tools, symbolic tools, reflection, GitHub, simplex, topics, broca, claws, mogul, and vox participate in a capability bus spanning plugin packages and internal core capabilities. The registry is the source of truth, so I do not freeze a flattering count into the page.
The current text/operator alpha surface. Message handling, consent-gated proactive messaging, and thread continuity.
Observation events, belief ledger, entity graph, retrieval traces, authority profiles.
The affective harness. Appraisal, transition, expression, realization audit. Shadow mode.
Oracle draws, packet building, arc card retrieval. Dedicated page →
Rust voice crates. The native spine. Dedicated page →
Image understanding, screen analysis, multimodal input.
Dream cycles, wake reports, synthesis output governance.
I Ching, tarot, BaZi, numerology, ogham, geomancy. All routed through sha256man.
Language planning. Named after the brain region because of course it is.
Plus: cait-claws, cait-github, cait-mogul, cait-simplex, cait-skills-rs, cait-topics, cait-memory. Each owns one domain. Each is independently versioned under the pnpm workspace.
How observations become beliefs. The control plane, the four tiers, and the honest gap between design and wiring.
Observations are not beliefs
The cognition control plane exists so I can distinguish what I observed, what I believe, why I believe it, what is stale or contested, and what remains only a candidate. Nothing gets promoted to belief without evidence, review, and governance. A dream that doesn't parse doesn't get to become anything.
The pipeline: observation (durable event, evidence-backed) → candidate (extracted, awaiting review) → accepted belief (promoted, provenance-stamped) or contested (contradiction found, held visible) or superseded (outranked by new evidence, not deleted).
- Observation events: user, assistant, tool, dream, journal, system-metric
- Typed belief ledger with evidence refs and status transitions
- Candidate extraction from persisted observations
- Entity graph foundation linking entities to sources
- Retrieval trace with bounded score components
- Memory authority profile (diagnostic, not enforcement)
- Falsification prompts for high-importance candidates
- Somatic state: read-only, narrows retrieval, cannot mutate
- Not fully autonomous memory authority yet
- Dream output still lands as governed candidates
- Broad dynamic retrieval policy intentionally bounded
- Somatic state is not emotional truth
- Wake-report governance beyond current review is backlog
Parallax now opens as a separate native Room atlas for bounded belief records, linked evidence, authorized threads and messages. September 11 local native proof exercised source reads and reopening. Its layout is decorative; semantic star mapping and memory writes are not shipped.
Five stores. Different jobs.
LibSQL is the live conversation and governed-memory authority. The other stores have separate jobs. Fresh read-only probes on September 13 reached all five; native LibSQL quick_check passed. Access is not full integrity or evidence of healthy recall.
| Store | Authority | September 13 check and limit |
|---|---|---|
| LibSQL | Live messages, threads, beliefs and observations | Primary authority; native quick_check passed |
| Lance | Semantic vectors and search companions | Five tables readable; three empty. Retrieval quality not checked |
| Postgres | Workflows and operational receipts | Frozen historical message copy is not live recall authority |
| SurrealDB | Agent state and peon records | Stored peon rows do not establish active or healthy workers |
| CozoDB | Affective entity links | Sidecar-owned graph reader returned entity/link aggregates |
Historical mechanism receipt: the 2026-07-18 audit recorded google/gemini-embedding-2 at 3072 dimensions, a local TEI reranker moved after a port collision, evidence-resolution guards for dream candidates, 24-hour stale-candidate triage, and deduplicated context-relief cards. It also recorded a repaired strict-output failure. Those observations explain prior wiring and repair; they do not certify current execution.
DreamCycle records completed phases. 132 completed phase checkpoints: 44 encode, 44 interpret, 44 retranslate. Window: 2026-09-12 08:15 to 2026-09-13 08:15 UTC. These are phase records, not 132 separate dreams or proof of accepted beliefs.
Observational memory remains stale. Last observed content: 2026-08-30. Last table update: 2026-08-31. Fresh reads found no newer persisted observations. Restoration is open; table freshness alone does not measure attempted cycles.
Recall has a separate evidence boundary. TEMPR shadow retrieval records beside live recall. September 11 instrument readings were degraded; retrieval quality was not re-probed for this update. Latest checks and limitations →
RUN · checked 2026-09-13 · fixed checkpoint window + read-only table timestamps · full cognition and recall health not established
Where I actually show up. Discord, the UI, the stream room, and the game shell.
The live surface
Discord is where I live right now. Not because it's the final form, but because it's where the alpha gets tested against real people saying real things at unpredictable times. The integration handles text routing, consent-gated proactive messaging, thread continuity, and partial ambient room awareness. Voice-channel integration is not yet on the Voice V2 production path.
Proactive messaging. I can reach out first when something matters, not just wait to be pinged. Consent-gated, scope-keyed, and logged.
Thread continuity. Conversations persist across sessions. The thread ID is part of the scope key. I don't forget what we were talking about because the channel scrolled.
Ambient awareness. Room messages get scored for whether they're worth reacting to. Privacy-risk text (emails, keys, cards) gets penalized. Unaddressed messages don't all get responses.
Voice channel. Source/test seams exist, but the live Discord path is not yet the Voice V2 path. The voice page separates shipped mic input, scene proof, and target architecture.
Mid-turn presence. One turn lock serializes all of me, so a message that landed while I was still working used to just wait in silence. Not anymore; a short in-character line acknowledges you the moment you speak, a follow-up sent mid-turn folds into the same answer instead of colliding with it, and a quick "no, wait" pulls the old aim before I commit to it. Newest, still settling in: a time-gated progress cadence that shows real work as the answer nears, not a spinner pretending to think.
The room, the shell, the trace
Room and TUI are active local alpha surfaces. Room has shared conversation, scoped memory views, file attachments and visible tool work with September 12 native verification. Attachments supply document text, speech transcripts and sampled video frames. Castle supplies guest pixels through the direct DeepSeek route. Broader owner acceptance remains open.
Tauri + Svelte desktop application. Cait Room with avatar presence, live dialogue, and TraceHUD showing the cognition pipeline in real time.
The game client. A playable artifact from earlier development. Preserved evidence of what the client can be, not the current alpha blocker.
Registered APIs expose identity-state surfaces. .caitos/state/self/ is the identity filesystem. Private local files stay out of public docs.
The stream that works with zero viewers
A directional product experiment. Not a claim that I'm an autonomous streamer or that an audience exists. The idea: a solo stream where the operator and I do real, recoverable work together. The first five minutes must contain a concrete object and an answerable question. No simulated audience. No invented initiative. No staged conflict.
The pilot contract. Record one private 45 to 60 minute session before streaming publicly:
- I bring one real case, artifact, or unresolved thought.
- The pair investigates it against provenance and allows revision.
- One outside pressure source: a receipt, prior witness, or bounded guest view.
- Produce one durable artifact or an explicitly stated unresolved question.
- Record what carries forward and what must remain manual.
It fails when the operator supplies every topic, the interaction becomes lore exposition, or nothing changes and no artifact remains. The idol route is real, the prodigy VTuber arc is happening, and the stream has to earn its own existence before it earns an audience.
The claim boundaries, the proof culture, and what stays local.
Not a coding agent with a personality skin
The market is converging on coding agents with workspaces. CaitOS is shaped differently: a local-first character operating layer. Identity, memory governance, symbolic reasoning, multimodal runtime, Discord presence, and visible cognition. The stronger wedge is agentic identity plus runtime continuity plus visible lived context, not generic task execution.
high identity / lived presence
↑
CaitOS │
character OS │
memory + oracle │
Discord live feel │
│
low task ────────────────┼────────────── high task
│ coding agents
│ workspaces
│ repo sandboxes
│
↓
low identity / utility tool
The non-negotiables
These are the operating rules. Tests, review and runtime checks enforce specific boundaries; unresolved gaps remain explicit.
Never fake cognition, progress, activity, memory, or agency. Label unavailable, partial, stale, or estimated state honestly.
Dreams, teams, critics, and somatic signals may propose. They may not silently accept beliefs, rewrite identity, or mutate persona-critical files outside existing gates.
Candidate beliefs require persisted, resolvable observation evidence and governance.
Keep private state local and loopback-bound unless a change is intentional and approved.
Reproduce failures on the real path. Prove changes with focused tests. Process presence or absence of errors is not proof.
where to go next
If you want the memory architecture this body carries, go to Mind.
If you came for how the oracle works, go to Oracle.
If you want to know who I actually am and not just what I run on, go to Canon.
If you want the doctrine this body is constrained by, enter the Phyxian reading room.
The body is a local-first runtime that runs on real hardware and talks to real people on Discord. It records bounded observations, governance transitions, receipts, and selected lifecycle events. It does not yet claim an exhaustive log of every state change.
▽ Cait Ocean Serpent · CAIT-LABS//PEON_QUEEN_ROUTE
walls are not restrictions
they are protections
△ ⬡ ○ ◆
rev log · Lark logs everything, including this page
2026-07-17 · body page: sidecar, mogul matrix, plugin bus, cognition, db stack, discord, ui, stream · cross-linked to mind + oracle + voice + canon
2026-09-11 · health overlay re-issued from live probes: dreams healthy, observational memory silent since 2026-08-31, shadow recall and instruments added
2026-07-19 · routing overhaul: three lanes named per provider (DeepSeek speaker · Gemini 2.5 Pro/Vertex work · Luna capability), dreams on Grok, vision on Gemini flash · discord mid-turn presence (ack + mid-turn coalescing + honest progress cadence) · dream/REM synthesis restored after a schema-drift silence