OpenKalea™Working to make intelligence
both private & ambient.
OK!
Developers & makers

Build on the edge.

Kalea is a local-first runtime: on-device inference, a tactile control surface, durable memory, off-grid messaging, and a bounded agent. It's model-agnostic by design — built to trade up to ever-better small models over time. If you care about private, embodied, high-trust intelligence, this is where we open the hood.

Latency Architecture Agents Get the code →

Part of the OpenKalea project.

Kalea
Performance

How we get to sub ten seconds, fully on-device

No datacenter, no discrete GPU — a single RK3588S 8 core CPU. The latency comes from treating the whole voice loop as a real-time budget.

Warm KV cache, reused prefix

On CPU the cost is prefill, not generation. The fast brain (the small, always-resident conversational model) warm-loads at boot, and the multi-hundred-token system-prompt prefix is prefilled once with its KV cache kept resident — every turn reuses that prefix instead of recomputing it, which collapses time-to-first-token. A watchdog keeps the model hot and re-warms the prefix if the OS reclaims it.

4 cores think · 4 cores listen & speak

The RK3588S's 8 cores (4× Cortex-A76 + 4× Cortex-A55) are partitioned: the 4 big cores drive LLM inference, the 4 small cores stay reserved for the always-on STT/TTS pipeline — faster-whisper in, Piper out. Hearing and speaking never steal cycles from thinking, so the model runs flat-out while the ears stay live for barge-in.

A deliberately small context

Prompt context is bounded and budgeted by route and answer length, and written spoken-first. A tight prompt means a small prefill and a stable, reusable KV prefix across turns — the single biggest lever on a prefill-bound CPU. Fewer tokens in, faster first word out.

Small models at 4-bit — 1.58-bit next

We run compact instruct models at Q4 (4-bit) quantization — the quality-per-millisecond sweet spot on ARM, where the Q4_0 format earns dotprod/i8mm runtime repacking. Next is 1.58-bit (ternary, BitNet-style) quantization as it lands in Ollama: far smaller weights, more RAM headroom, and cheaper matmuls — more brain per watt, right at the edge.

Pro: many models warm at once

16GB on Kalea Pro holds multiple models KV-cached simultaneously — the fast brain and the deep brain (the larger reasoning model, switched to deliberately) both resident for instant switching with no reload, so the multi-model Small Council (MMO) can cycle its candidates without evicting a brain.

The result: usually well under ten seconds to first word today, on low-cost hardware, with nothing leaving the room.

Vocabulary

Twelve words this page assumes

Industry terms (DCO, SLSA, AEAD, CODEOWNERS…) are used as-is. These are ours.

the Deck
The Personality Deck: the physical panel of five knobs and two faders that sets her behavior. Read at 12 bits.
fast brain · deep brain
The small always-resident conversational model, and the larger reasoning model switched to deliberately (never by a knob).
Small Council (MMO)
Multi-Model Optimization: the same prompt run across 2–4 local models, a fast judge picks the answer. Text lanes only.
Console
The on-device control app, bound to 127.0.0.1. Reads the runtime's state; writes through the same validators as everything else.
BitChat
Off-grid text control from a nearby phone over Bluetooth LE. No internet, PIN-gated.
swarm · graph
Several Kaleas in one household, joined as nodes in a directed permission graph. Forthcoming until proven on two boxes.
broker
The one node in a household with an internet uplink. Every other node is a sealed leaf: no socket to open.
director
The person who draws the graph — which node may send what, to whom, at what fidelity. Usually a parent.
fidelity
How much of a thing may move: raw > summary > signal > presence > none. Raw never crosses the mesh.
receipts
receipts.jsonl: every allow and every deny, with a human-readable reason. Never raw content.
arm
A plug-in: a Python package with a kalea.arms entry point and an arm.json manifest the permission engine enforces.
Kalea Certified
A release whose manifest carries our Ed25519 signature. Modify the tree and kalea verify says so; the box keeps working.
The Personality Deck, from the other side

Six analog channels. Twelve bits each.

As shipped, the Deck sets who Kalea is: five sliders with five tiers each, plus an age slider with 30 stops — 93,750 distinct Kaleas, set by hand, live on the next turn. Underneath, every slider lands on a 12-bit ADC, and the runtime publishes the raw 0–1 float before any tier is applied. The tier bands are one JSON file. What a knob means is yours to define.

0 · as shipped6 · all of it
40962 × 53 × 30
62.9 billion
distinct Kalea behaviors
55 × 30
93,750
as shipped — personality
40962 × 53 × 30
6.3 × 1010
two knobs re-read at 12 bits
40966 = 272
4.7 × 1021
every channel, full resolution

The path from pot to prompt — and where you cut in

  1. Pot → ADS7828. 12-bit, 8 channels, I2C 0x48, external 3.3 V reference. Driver kalea/deck/ads7828.py (a pure leaf); glue kalea/deck/adc.py.
  2. Sampler. Every channel each 0.15 s (~6.7 Hz), normalised to the chip's full scale, clamped 0–1, published. Consumer faults are isolated; a bad reader can't kill sampling.
  3. The float. A0 Agency · A1 Tone · A2 Posture · A3 Pluck · A4 Length · A5 Age, each a continuous 0.000–1.000. This is the seam. Nothing downstream knows what a knob means.
  4. Bands → tiers. Five edges (≤.10 ≤.25 ≤.50 ≤.75 ≤1.0) and the tier names live in share/personality_config.json, hot-reloaded by mtime on every prompt build. Ten edges give ten tiers. Remove them and consumers read the float.
  5. Consumers. Contrastive AGENCY/TONE blocks, ROLE, LENGTH caps, the Shape Engine (the Posture × Age table that sets her teaching posture), reachouts per hour, the safety gate's age. Each reads a tier today; each could read the float.

One remap already exists in production: Tone and Length carry deep_brain_threshold: 1.1, a value the slider cannot reach. Lower it and that knob routes turns to the deep brain.

What a channel could be

Today a slider sets personality. Read the float directly and it can drive any scalar in the runtime:

contextnum_ctx 1k → 8k effortdeep-brain threshold · thinking budget modelindex into the catalog: fast ↔ deep ↔ candidates temperature0.0 → 1.2, continuous threadsthe 4-big / 4-small core split seed / hash4,096 reproducible worlds primitivesan arm's budget (arms are plug-ins; see the agent stub below): wall-clock, tokens councilMMO candidates, 1 → 4 cadencesynth interval · reachouts/hr voiceCoral · Tide · Firth · Harbor · Keel, and the rate between them retrievalhow much of the compendium (her synthesized memory) is injected per turn your ownanything with a float on one end

Analog prompting is a bus

Six physical scalars sampled at 6.7 Hz, with no screen or menu between the hand and the number. Change the tree and the badge in the Console (the on-device control app) reads Modified — uncertified. The badge describes your box; it doesn't lock it. The silkscreen says Pluck; the ADC reads 0.6183. One honest caveat: 12 bits is resolution, not 4,096 distinguishable behaviors — pot noise and hysteresis eat the low bits. The point is the channel, not the count.

Analog Prompting, the product side →
The agent model

The Agentic Graph

An agent here isn't a model let loose with broad permissions. The agents are the Kaleas themselves, each bound to a role — tutor, companion, thought-partner — and the work of that role is the agentic action. What a node emits is synthesized: a consolidated account of its exchanges, sent up the graph to the nodes allowed to receive it. The director makes any of this possible by drawing the graph — which hardware relates to which people, and how. Capability exists only inside that structure of permission.

Swarm · the whole web ◆ amber border = broker / uplink➤ arrow = direction of flowdemo · the swarm is forthcoming
summary signal presence upward-only (safety / reading concern) broker uplink — the one door drag a card · hover a wire · click either

Not a hub: members share directly — child→parent, grandparent→child, child→child — while the broker (the one node holding the household's internet uplink) manages the whole web of directed threads. Raw content never leaves a node. Only the synthesized form moves, only along a wire a person drew, and every emission writes a receipt. The same view, live, in the Console →

The substrate

What every node already runs

The substrate is the runtime layer every arm sits on: identity, the permission engine, synthesis, transport, receipts. Every outbound share and every served answer passes through one function, swarm/permissions.py, before it reaches the transport.

Input

A node: node_id, role (tutor · companion · thought_partner · broker — the uplink node), age gate, network stance (offline by default). Its corpus is its own; nothing wider is addressable.

Permission

An edge: content_class × fidelity cap × cadence × consent. Eleven classes. Fidelity raw > summary > signal > presence > none. Evaluation order is fixed in code — enabled → household wall → age/safety invariants → cadence due → consent → cap — and returns Decision{allow, emit_fidelity, reason}.

Cognition

synth.py builds the payload; it never forwards one. Idle-gated, under the same _llm_inference_lock as voice, ≤270 characters. Signals are computed without the LLM when the datum already exists (a mastery tier, a presence flag); summaries are an LLM précis of a bounded slice of this node's memory, sized to the edge.

Execution & return

One SH (share) frame on the household LAN, in the KSWARM/2 wire format: the K2 header is the AEAD associated data, the payload is XChaCha20-Poly1305 under the household key; answers ed25519-signed against the pinned roster. Every allow and deny appends to receipts.jsonl with a human-readable reason; receipts never contain raw.

Built — not yet proven on two physical boxes

Five invariants the graph cannot override

Checked in code regardless of config; a graph that asserts otherwise is refused.

  1. Cross-household wall. Any peer with a different household_id is refused, edge or send.
  2. Nothing from an adult's node flows down an age edge. To a u18 node: presence, and family_memory at summary with guardian approval.
  3. safety_event and reading_issue go up only — to an 18+ guardian or broker. Never sideways or down; category only, never content.
  4. Raw is never on the mesh. fidelity=raw is invalid on any edge; the engine downgrades or refuses.
  5. wellbeing_signal about an adult requires subject_informed. Otherwise it is refused and the refusal receipted.

State lives in /data/kalea/swarm/: identity.json (0600, born on the box), household.json, graph.json, receipts.jsonl. A new member joins with zero edges: default-deny is the empty graph. The graph, in depth →

Build an arm

The agent stub

In the repo a new agent is an arm: a Python package with a kalea.arms entry point and an arm.json. The manifest fixes role, network, permission class, mounts and budget before any cognition runs, and permissions.py enforces it at the same chokepoint as every household share. You write run(ctx); the substrate decides what leaves.

arm.json — draft. The schema is frozen in openkalea/arms before the first arm is solicited.

{
  "name":             "school-calendar-errand",
  "version":          "0.1.0",
  "license":          "Apache-2.0",
  "roles":            ["broker"],           // which node roles may host it
  "network":          "broker-uplink",      // none | broker-uplink
  "permission_class": "errand:summary",     // content class : fidelity cap
  "mounts":           [],                   // explicit; empty by default
  "budget":           {"wall_s": 120, "tokens": 4000},
  "output_contract":  "summary/v1",         // arms/contracts/
  "conformance":      "arms/conformance/v1" // the merge gate
}

[project.entry-points."kalea.arms"] calendar = "kalea_arm_calendar:run"

def run(ctx):
    q   = ctx.task.query                   # 01 INPUT       this node · role · slice
    d   = ctx.permits("errand:summary")    # 02 PERMISSION  → Decision(allow, fid)
    doc = ctx.uplink.fetch(q)              # 03 COGNITION   uplink: broker role only
    out = ctx.think(summarize, doc)        #    local brains · inference lock · budget
    return ctx.emit(out, d.emit_fidelity)  # 04 RETURN      capped · receipted

The whole handle

ctx is everything an arm can reach.

ctx.task
The bounded request: query, subject, cadence that fired it.
ctx.memory
The permitted slice of this node's compendium (its synthesized memory). Read-only. Nothing from another node.
ctx.permits(cls)
The same permissions.py call every household edge takes. Refusal carries a reason and is receipted.
ctx.think(fn, *src)
Local brains only — fast gemma4:e2b-it-qat, deep qwen2.5:3b-instruct-q8_0 — serialized behind voice, stopped at budget.
ctx.uplink
Broker role only: fact_check, fetch. On a sealed leaf (any non-broker node) the attribute does not exist.
ctx.emit(out, fidelity)
Capped at the class. An arm can only lower fidelity on the way out: raw → summary → signal → presence → none. Appends to receipts.jsonl.

Not on the handle: sockets, the filesystem outside mounts, identity, keys, other nodes. The handle is a draft until that freeze; the invariants it relies on are already in the runtime.

Installs to /data/kalea/arms/ Never the signed release tree. kalea verify still passes: installing an arm does not void certification.
Network: none or broker-uplink No third value. One door per household; the graph shows which box holds it.
Conformance is the merge gate arms/conformance/ proves manifest and behavior agree. registry.json is discovery. Console lists installed arms with class and network.

The contract, the conformance suite and the registry live in openkalea/arms. Where the code lives →

OpenKalea on GitHub

If it runs on your device, it's open.

If it runs on Kalea's infrastructure or grants Kalea's identity, it's closed. One test decides every file. github.com/openkalea is one complete-device repository plus a few satellites that exist only where cadence, license, or ownership differ. Clone it, follow docs/BUILD_IMAGE.md, and stock hardware boots a working — uncertified — Kalea. If any step needs something we didn't publish, the repo is broken and we fix it.

RepositoryLicenseWhat it is
openkalea/kaleaApache-2.0The complete device. Runtime package (core, audio, brains, deck, memory, tutor, safety, bitchat, net, swarm, console, update, cli), the Console UI, first-boot provisioning, the open safety-eval suite, the image recipe, docs/, and keys/kalea_release.pub. Clone = whole device.
openkalea/versionCC0The update feed. stable.json · beta.json · dev.json + imager.json, generated by CI from Releases. The Updates card on your box reads only this.
openkalea/modelsApache-2.0The certified model set, pinned by digest. models.lock.json per release, model cards, license pass-throughs, the eval harness, the trade-up RFC template. The device never pulls :latest.
openkalea/armsApache-2.0Community integrations. The arm.json schema, registry.json, the conformance suite, and the Arms Wanted board — OpenClaw, NanoClaw, voices, languages, settlement.
openkalea/architectureCC-BY-4.0How decisions get made. RFCs open as Discussions and close as ADRs; AI_POLICY.md, GOVERNANCE.md, the roadmap. Nothing executable.
kalea-opsprivate · outside the orgRelease signing and the ceremony, the OTA channel, the flasher, fleet provisioning, the store, supplier files. What stays closed is the mark, the keys, and the rails (the store, customer data, manufacturing files), not the code that runs on your box.

How a change lands

DCO, not a CLA. Every commit carries Signed-off-by:; Apache-2.0 §5 is the contribution and patent grant. Conventional Commits drive the changelog.

main is trunk. release/1.x takes only fixes already proven on main; certified builds are cut from there. v* tags are immutable.

Rulesets on both: CODEOWNERS review (two for safety-class, kalea/update/, kalea/swarm/, evals/), merge queue, signed commits, linear history, no admin bypass on release/*. A PR that adds a network call outside the three documented apertures (updates, model acquisition, opt-in broker errands) is rejected by policy.

Two signatures on every release

Public layer. Sigstore/GitHub attestation and an SBOM on every asset — SLSA Build L3 — so anyone's build gets provenance:

gh attestation verify kalea-1.4.2-py3-none-any.whl \ --owner openkalea

Certified layer. An Ed25519 signature over MANIFEST.sha256, produced only in kalea-ops after the release checklist and the safety-eval attestation pass, uploaded to the same Release. A version reaches the stable channel only when that .sig exists.

Open verifier, closed signer: kalea verify diffs your box against the public tree.

AI-assisted, human-accountable

We use coding agents daily. The rule is accountability.

Use any tool. You open the PR, you understand it, you can debug it and discuss it without the tool. Disclose with an Assisted-by: trailer; undisclosed AI content that reviewers detect is closed.

Fully autonomous agents do not open PRs or issues here. A first-time contributor's PR needs a maintainer's vouch before CI spends hardware-runner minutes. Reviewers may use AI; the approving human owns the approval.

github.com/openkalea Arms Wanted

The org opens once three things are done: trademark prep for “Kalea Certified,” a full-history secret scan, and a README held to the same rules as this site: the swarm is forthcoming, first audio is about ten seconds, and nothing is called encrypted until it is.

Arms Wanted

Bounded work and a test that merges it.

Every ask on the board has four parts: the outcome, the contract it must satisfy, the test that proves it, and the reviewer who will merge it. Nine examples here.

arm:openclawruns on: broker

The OpenClaw errand

Ask. An arm that lets a broker node delegate one explicitly permitted errand to an OpenClaw gateway (an external open-source agent framework) — “find the school calendar, return a summary” — and hands back a synthesized result, never raw context. ClawHub SKILL.md on their side, arm.json on ours.

Contract. roles: ["broker"] · network: broker-uplink · input → permission → cognition → return · nothing raw crosses back · passes arms/conformance/ · default off.

arm:nanoclawruns on: any role, sandboxed

The split-trust worker

Ask. A NanoClaw container (the split-trust worker from our whitepaper) that receives a task, a limited mount, a permission class, a memory slice, an execution budget and an output contract — and never Kalea's identity or keys. The reference implementation of the whitepaper's sober NanoClaw.

Contract. Container-isolated · explicit mounts only · credentials via vault, never inside the agent · returns one bounded artifact · one audit line in receipts.jsonl.

arm:settleruns on: broker

Paying for an errand

Ask. An arm that pays for one permitted errand without opening an account. x402 is the shape of it: the service answers HTTP 402 with its price, the arm signs and retries, a stablecoin settles — no account, no session, no API key. RFC first, then the code.

Contract. roles: ["broker"] · a ceiling per errand, enforced on-device before the request leaves · keys in the vault, never in the arm · testnet until the RFC lands · we custody nothing and take no cut · passes arms/conformance/ · default off.

models:trade-uprepo: openkalea/models

Model trade-ups

Ask. Candidate fast and deep brains as small open models arrive. Run the eval harness on real hardware; file a trade-up RFC with the numbers.

Contract. Fits the SKU ceiling (lite 8 GB / Pro 16 GB) · kid-facts hallucination rate ≤ the current certified set's · latency parity · Apache, MIT, or a pass-through-able license.

tutor:syllabusreview: @openkalea/safety

Languages & syllabi

Ask. Syllabus translations, locale-specific PreK-12 tracks, STT/TTS language pairs.

Contract. Follows the share/syllabus/ schema · age-floor rules intact · every child-facing change reviewed for the gates.

arm:voicetarget: RK3588S

Voices

Ask. New Piper voices for the five-voice palette — Coral, Tide, Firth, Harbor, Keel — and beyond it; multilingual voices; quality and latency reports measured on the board.

Contract. .onnx + .onnx.json · per-voice license and dataset attribution (never assume MIT) · passes the eight TTS acceptance tests (T1–T8) · meets the medium-tier latency budget.

safety:evalsafety-class

Safety evals

Ask. New probes for the open eval suite — child gates, the adult catalog beyond self-harm (currently unauthored) — and red-team reports.

Contract. Evals are open; signatures are not · reproducible · never real minors' data.

docsgood first issues live here

Docs & the manual

Ask. The user manual, seeded from the device file map's chapter crosswalk; translations; tutorials.

Contract. Open items are written as open. Nothing forthcoming is described as shipped.

console bitchatloopback only

Console & BitChat UX

Ask. Loopback Console cards, BitChat menu ergonomics, accessibility.

Contract. 127.0.0.1 only · PIN-gated actions stay PIN-gated · no new network apertures.

The board · openkalea/arms
The next vessel

We're designing the next piece of hardware Kalea will ride on. This is your chance to weigh in.

Kalea is neither a single model nor a single device; she is the vessel, built to trade up. We are designing a custom SBC and the decisions are still open. Tell us what would make you build on it.

Your email opens the box and lets us reply. You're not added to a list unless you tick the box.

What's on the bench

Audio pathMic array, far-field pickup, the speaker. Voice-first, so this comes first.
Compute & memoryHeadroom for two brains resident, and for the models that arrive next year.
Power & portabilityWall-tethered, or a battery and a handle.
RadiosWi-Fi, BLE for BitChat, and what else an off-grid arm might want.
Form & repairEnclosure, the Deck, ports, and whether you can open it with a screwdriver.
PriceWhat the object should cost.
Get building

Ask for a key to the repo.

github.com/openkalea is password-protected until the first product ships. Tell us who you are, and what you'd like to work on, and we're likely to give you early access.

Where can we see your work? fill in any you like
Full Specification

The Complete Specification

Kalea end to end — the physical platform she runs on, and the software architecture that runs on it. Expand any branch.

Hardware
    The board
  • Orange Pi 5 Pro single-board computer — the same platform in both models
  • Rockchip RK3588S — 8-core 64-bit (4× Cortex-A76 + 4× Cortex-A55), ARM Mali-G610 GPU
  • 6 TOPS NPU on-board; hardware acceleration is on the roadmap — inference runs on CPU today
    • Memory & storage
  • LPDDR5 memory: Kalea lite 8GB · Kalea Pro 16GB
  • eMMC storage: Kalea lite 64GB · Kalea Pro 256GB
  • Memory sets warm-model capacity: lite keeps one model warm; Pro keeps both brains warm and prewarms KV cache for up to 4 models
    Custom PCBA
  • A dedicated board reads the deck; each control's position is converted to a 12-bit analog-to-digital signal — 4,096 steps per knob or slider
  • Personality Deck and Analog Prompting™ — patent pending (U.S. application filed)
  • Five knobs (Agency, Tone, Posture, Pluck, Volume) + two sliders (Length, Age)
    • Feel & behavior
  • Continuous, instrument-like feel rather than menu steps — "analog system prompting"
  • Changes take effect live with no restart; tier crossings, brain switches, and age changes are spoken aloud; graceful fallback if the ADC is unavailable
    Audio
  • Microphone in / speaker out for fully local listening and speaking — no cloud STT/TTS
    • Wireless
  • Wi-Fi 5, Bluetooth 5.0, and Bluetooth Low Energy (the off-grid messaging mesh)
    • Display, data & power
  • HDMI out + USB keyboard/mouse → a full Ubuntu desktop; USB for history export (Markdown)
  • Board also exposes Gigabit Ethernet, USB 3.0/2.0, dual HDMI, an M.2 (PCIe) slot, and a 40-pin GPIO header; powered over USB-C
    What differs
  • Memory: lite 8GB LPDDR5 · Pro 16GB LPDDR5
  • Storage: lite 64GB eMMC · Pro 256GB eMMC
  • Warm models: lite one at a time · Pro both brains + KV-cache prewarm for up to 4
  • Best for: lite → tutor & companion, single user · Pro → multi-user households, heavy / agentic / swarm use
    • What's identical
  • Same board, and the same local, private, voice-first, off-grid design — capability lives under the hood, never behind a paywall
Software architecture
    Voice-first companion
  • Wakes on "Kalea"; explicit awake/asleep; auto-sleep after silence; post-wake chatter filtering; gentle wake/sleep/ack sounds + optional thinking music
  • On-device speech recognition; VAD tuned per context (awake / asleep / onboarding / barge-in); pre-roll capture so first words aren't clipped
  • On-device speech; multiple voices; streamed for low latency; audio-native, spoken-first phrasing
  • Barge-in; foreground human outranks long replies, background inference & proactive work; she yields rather than finishing at all costs
  • Guest onboarding: name + age before a named profile
    • Physical Personality Deck
  • Four knobs: Agency, Tone, Posture, Pluck
  • Three sliders: Length, Age, Volume
  • 12-bit ADC per control (4,000+ steps) — continuous "analog system prompting" — patent pending
  • Live, no-restart changes; spoken tier changes ("I'll be Playful"); rapid-move collapse to final setting; ADC-unavailable fallback
    • Off-grid messaging / BLE control surface
  • Encrypted text control over a Bluetooth Low Energy mesh — off-grid, no internet, no cloud account
  • Kalea is the BLE client: a bootstrap listener scans the phone's off-grid messaging service and connects over GATT — no OS pairing dialog
  • Local 4-digit PIN (sent alone or with a username); voice and off-grid messaging identity converge on one profile
  • Exactly one active owner; bootstrap stands down when the runtime takes over; shared PIN file + single runtime lock
  • Self-healing BLE: an adapter watchdog survives idle and phone MAC rotation
  • Top-level menu (auto-sent after auth; cmd shortcut still works): A · CMD, B · Custom, C · Agentic, D · Stop
  • A · CMD (device & system): Users · Models · Wi-Fi · Autostart · Stop
  • B · Custom (behavior & data): History logging · Output mode · Deck verbalization · Age range · Export (USB / Desktop, Markdown) · Refresh interests
  • C · Agentic (orchestration): Multi — Multi-Model Optimization, slots A–D · Swarm — household mesh status / on-off / graph edits over BLE; output modes text / verbal / file
  • Mesh limits: public replies chunked to 90 characters; text capped tight for latency, file replies run longer
    Local brain runtime
  • Fast brain (low-latency, also MMO judge)
  • Deep brain (heavier, hot-swappable)
  • Model catalog; graceful degradation if a model is missing
    • Warm-cache & latency
  • Kalea Pro (16GB): both brains stay warm; KV cache prewarmed for up to 4 models → instant deep-brain switching and a fast Council
  • Kalea lite (8GB): one model warm at a time → the deep-brain switch takes a moment
  • Prompt-prefix warming + verification before "ready"; resident while running; re-warm watchdog; unified runner shape prevents warming one model while turns hit another
    • Prompt builder & context
  • Assembles identity, age gate, Deck state, route, recent chat, notes, interests, syllabus, lesson plan, family, artifacts
  • Bounded/budgeted by route & length; voice-quality (spoken-first) rules
    • Multi-Model Optimization
  • 2–4 models in slots A–D; same prompt; fast-brain judge; winner annotated
  • Voice/verbal/file bypass MMO; text off-grid messaging tolerates the cycle
    Age gate
  • Under-18 (protected, age-graded, interests as seasoning)
  • Adult (open, interests become curriculum)
    • Posture knob
  • Low: bestie/peer — presence
  • Middle: tutor — balanced learning
  • High: coach/mentor — depth & challenge
    • Folder-activated behavior
  • Family History folder → companion behavior
  • Interests folder → interest learning
  • Lesson Plan folder → guided tutor
    • Memory mix & floor
  • 4 pools: family / history / syllabus / interests, renormalized by gate × posture
  • Invariant floor: anti-confab, no scaffolding leak, gentle grief, repetition-tolerant, name discipline, warm correction, audio-native
    Learning relationship
  • Tutor: foundations, gentle correction, encouragement
  • Coach: practice, drills, mastery tracking
  • Mentor: synthesis, Socratic, higher expectations
    • Curriculum sources
  • Built-in age-graded syllabus (ages 2–18)
  • Lesson Plan folder (can dominate)
  • Interests; conversation history; notes
    • Teaching mechanics
  • Explanation, practice ("try one", "explain it back"), warm correction, follow-up & open loops
    • Learner state & subconscious
  • Topic tracking, spaced review queue, open loops, learning artifacts
  • Lesson dreams, compendium, interest synthesis, agency-gated proactive review
    Corpus & ingestion
  • Per-user + shared household folders; desktop drop-folder; text, docs, sheets, image/audio metadata
  • Folder scan on boot & idle; incremental; thin metadata artifacts
    • Enrichment (local only)
  • Summaries; people & relationships; places; dates; gentle world-context
    • Reminiscence
  • "On this day"; gentle non-interrogative recall; repetition tolerance; no hard fact-checking of memory
    • Emotional register & privacy
  • Warm presence, gentle grief, silence tolerance
  • Family content never leaves the device; logs are counts/timestamps, not content
    Bounded local workcell
  • An agent is intelligence with permission to act — run as a bounded, interruptible local workcell, not a loose process with the run of the host
  • Lifecycle: Input (limited workspace) → Permission (context-aware) → Cognition (local models within a memory slice & budget) → Execution (bounded action) → Return (results + a clear path to interrupt)
    • The household intelligence graph
  • A swarm is not "many Kaleas" — it is one household intelligence with a permission graph
  • Nodes carry a role (tutor, companion, thought-partner, director, broker); edges are directional, typed, permissioned, fidelity-bounded — symmetry is never assumed
  • Synthesis is the permission boundary: raw content stays local; only a representation moves, at the lowest fidelity the edge allows
  • Fidelity ladder = privacy ladder: raw (never on mesh) → summary → signal → presence → none (default)
    • Invariants (enforced in code, not config)
  • No cross-household edges · no adult content into a child node · safety events upward-only · wellbeing signals require subject awareness · raw never crosses the mesh
  • Default-deny: edges don't exist until a human draws them; every allow/deny logged to receipts with a human reason
    • Broker & director
  • Broker = the one visible, governed door to the internet; a sealed node asks it and stays offline by construction
  • Director = the synthesizer; merges allowed summaries (not raw lives) into a family digest; hosts distributed MMO across peers
    • Transport & box mode
  • LAN-local signed mesh (never the internet — only the broker may); the hardened off-grid messaging BLE path is client-to-phone only
  • Box mode single/multi: a shared device can present multiple people as distinct graph nodes under one device-wide age gate
    • Trust model
  • Local identity, physical control, BLE command, prompt-state legibility, model orchestration, context-aware permissioning
  • "Capability without containment is not trust" — capability grows; the boundary holds
    Profiles & conversation
  • Named users, guest fallback, per-user folders/history
  • Recent chat; episodes; cleaning & compression
    • Artifacts
  • Dream reflections, lesson notes, compendium, outreach, family summaries, interest synthesis, learned facts
  • Scored, relevance-selected, retention-bounded
    • Learner state & notes
  • Topics, review queues, open loops
  • Always-on, match-triggered, and per-user notes
    Dreaming
  • Idle/sleep windows; stops on user activity; sound-guarded
  • Syllabus, history, family synthesis, interest synthesis, lesson reflections
    • Compendium
  • Turns prior interactions into structured continuity; feeds learner state
    • Proactive reachouts
  • Agency-controlled (Passive → Driver)
  • Lesson follow-up, review, interest connection, family memory, "keep going?"
  • Human priority; background work stops on speech
    Under-18 (protected)
  • Pre-LLM intercepts run before the model: self-harm redirect, sexual-content handling, abuse-disclosure escalation, cussing rephrase
  • Per-user intercept logs stay local, for parent review
    • Adult (open)
  • Self-harm / suicide intercept with an agency-respecting 988 redirect; other topics generally pass through
    • Anti-confabulation
  • Fabricated-contact & first-person-family validators; learning-memory validators; known-fact vs. inference discipline
    • Honest limits & supervision
  • A parent in the loop for kids; competent-adult supervision where needed
  • An experiment under development — far from perfect, never "perfectly safe"
  • Open source: if you modify her, unsafe behavior is yours to own
    • Safety as trust
  • Local, age-aware, no surveillance cloud services
    A full Ubuntu desktop
  • Orange Pi 5 Pro running Ubuntu Desktop; plug in HDMI + a USB keyboard/mouse and it's an ordinary computer — no app, portal, or account
  • What she learns from lives as plain folders you own: Family History (~/Desktop/Family History), Lesson Plan (~/Desktop/Kalea/Lesson Plan), Interests (an editable text file), Exports (~/Desktop/Kalea/exports, Markdown)
  • Local, incremental ingestion while idle — reads only what changed; nothing uploads or syncs
    • Runtime & data
  • Single canonical runtime; lock; clean shutdown; bootstrap handoff
  • Canonical data dir; mutable state separated; per-user folders; config files
    • Connectivity & fleet
  • Wi-Fi toggle via off-grid messaging; BLE watchdog & reconnect; off-grid baseline
  • Golden image; first-boot personalization; unique identity; reproducible eMMC deploy
    • The Console (on-device control plane)
  • Loopback-only HTTP API bound strictly to 127.0.0.1, served as a chromeless app on the Pi's own desktop — no cloud, no LAN, no authority outside the box
  • Reads runtime singletons; writes only through the same managers/validators off-grid messaging uses (one state, three editors: Deck, Console, off-grid messaging)
  • Modules: Home · Devices & Models · People · Deck mirror · Folders · The Work · Conversations · Swarm graph · Safety · System
  • PIN-gated on three critical actions only: switch active user, change device age gate, rotate PIN