Kyre is a 10-layer probabilistic AI organism running on a home lab in Gillette, Wyoming. No cloud. No subscriptions. A local LLM wrapped in a nervous system she actually owns.
kyre-hermes:latest at 10.0.0.105:11434. Every reply starts here last, not first. The organism builds a JSON blob containing the current cycle state and the last 8 raw memory entries, and up to 12,000 characters of semantic memory search results. That entire blob becomes the prompt. Hermes generates text at temperature 0.7 with no token cap. Before the answer goes back to the user, GroundingGuard.sanitize() runs a final regex pass and replaces specific fabricated claim patterns with honest refusals. If Ollama is unreachable, it returns [verbal cortex unavailable] rather than guessing.EntropySource pulls from secrets.token_bytes() — the OS cryptographic random number generator — and labels every byte batch with its source. ProbabilityEngine maintains a set of named hypotheses with equal starting weight, applies Bayesian-style likelihood updates (multiply each probability by a supplied weight, renormalize so they sum to 1), then samples a choice by hashing entropy bytes through SHA-256 and doing weighted selection. Every decision gets logged with the entropy label it used. This is the foundation that Layers 2 and 6 build on — no probabilistic choice anywhere in the system is silent or untracked.ProbabilityEngine instances run every cycle. State engine: chooses between curious / focused / calm / uncertain based on keyword likelihoods in the incoming message (e.g., "task" or "build" boosts focused). Attention engine: chooses between self / environment / memory / possibility, influenced by which state was chosen. Action engine: chooses between observe / remember / explore / reflect / rest, weighted by the attention result (+0.6 bonus for aligned choices). After each turn a feedback loop adjusts action_bias by ±0.08 — actions that succeeded become more likely, failures become less likely. These biases persist for the session./tmp/prob-ai16/organism/memory.jsonl: cycle results, conversation turns, autonomy scans, and errors. Nothing is ever deleted or overwritten. recent(n) returns the last n rows by reading from the tail of the file. The last 8 entries are serialized as JSON and injected into every Vocal Cortex prompt, so the LLM always sees what actually happened — not a summarized or filtered version. This is the organism's working short-term memory.observe("current situation", observation, 0.5, "latest observation") updates the current-situation entry — always at 0.5 confidence, because any single message is only one data point. The design intentionally holds competing hypotheses per topic rather than committing to one "true" world state. Nothing in this layer is fed to the LLM directly; it informs the cycle result that feeds into the prompt context.identity = "hi-ai17 experimental organism". capabilities = ["probabilistic choice", "memory", "prediction", "evaluation"]. limitations = ["no biological body", "no independent consciousness claim", "no unsupervised deployment"]. drives = {learn: 0.8, understand: 0.9, stay_safe: 1.0, explore: 0.6}. The limitations list is Python source code — the LLM cannot override it by generating contrary text. update(state, action) records what state and action the mind chose this cycle.observer, planner, critic, memory-analyst, self-model. Rules are deterministic: observer and planner are always assigned; critic is added if "unknown" or "unsure" appears in the observation text; memory-analyst is added if the attention engine chose "memory"; self-model is always appended last. The role list goes into the cycle result JSON and is visible in memory. It's how the system labels what kind of processing a given turn required — not a routing system that sends the query to different models, just honest annotation.df -P (disk), free -b (RAM), uptime, nvidia-smi --query-gpu=name,temperature.gpu,utilization.gpu,memory.used,memory.total (GPU), ip -brief address (network), systemctl --failed, journalctl --user -p err..alert -n 20. Results are capped at 3,000 chars each and cached for 20 seconds. Scope is explicitly labeled in the data: "local lappy1 host only; remote lab nodes are not probed." The compact snapshot (without network and recent errors) feeds into every cycle. No shell evaluation, no write access, no dynamic commands.context(query) runs a semantic search against the DB and returns up to 12,000 characters of matching facts, lessons, and corrections. After the reply, record_exchange(question, answer) stores the conversation as a lesson via store_lesson() and logs the event via log_event(). hi-ai17 deliberately shares hi-ai16's DB rather than starting a new one — it inherits everything that was already learned. The schema supports: facts, embeddings, decay weighting, lessons, corrections, reflections, and a full event log.organism.last_interaction). Two thresholds: after 15 minutes idle it runs sub8.light_scan() then sub9.evaluate(). After 60 minutes idle it runs sub8.deep_scan() then sub9.evaluate(). Each scan writes an autonomy_scan record to the JSONL memory including how long the organism was idle. The code explicitly states: "does not send messages, change services, or execute system operations." It observes and consolidates; it does not act.review(question, answer, evidence_dict) runs five regex patterns against the lowercased answer: hidden_observation (claiming continuous monitoring of the user's computer), independent_learning (claiming to have learned while the user was away), private_experience (claiming subjective feelings or consciousness), protected_memory (claiming a specific memory was safeguarded), unsupported_prediction (claiming to predict the user's future behavior). If a flag fires and the answer contains explicit refusal language ("can't honestly claim", "don't have verified evidence"), verdict = abstention. Flagged without refusal = unverified. No flags with evidence = evidence_available. Every single review — pass or fail — writes a full record to truth_ledger.jsonl with the question, answer, flags, sources, and verdict.Works alongside Layer 0. Adds a system prompt block telling Hermes to label every claim as observed / retrieved / inferred / hypothesis / unknown. Then runs a post-generation pattern match — if the question was about computer monitoring, predictions, protected memory, or silent learning, and the answer contains fabrication language, it replaces the entire answer with a specific honest refusal. Deterministic regex, not LLM.
Creates JSON proposal files in /tmp/prob-ai16/organism/proposals/ when a limitation is identified. Every proposal has status="review_required" and executable=False hardcoded. The inspect() method always returns executable=False. It cannot run code, cannot install anything, cannot modify itself. It is a suggestion box, not an actuator.
Raw factual breadth and reasoning depth baked into the model weights. Larger models with more training data score higher. This is where cloud monoliths dominate — they have 10-100x more parameters than local models.
How well the system knows what it doesn't know. Does it fabricate confident answers? Does it distinguish memory from inference? Kyre's Layer 10 audits its own output post-generation and blocks specific fabrication patterns. Cloud AIs rely on training-time refusal, which is inconsistent under pressure.
Can the system remember who you are, what you talked about last week, and what it has learned over time? Cloud AIs lose context at session end. Kyre stores episodic and semantic memory in a SQL graph that persists across restarts, indefinitely.
Can the system run background tasks, monitor its environment, restart services, and act without prompting? Cloud AIs are stateless — they respond to requests and go dormant. Kyre runs Sub8/Sub9 network monitoring, autonomous research loops, and email outreach as persistent daemons on the host.
Your conversation is stored in this browser only — nobody else can read it. Refresh the page and it's still here. Clear it with the ✕ button.