Oracle Edition · Fully Local · Earned Autonomy

Your personal JARVIS.
Not a chatbot.
A growing intelligence.

A private, local AI that sees, remembers, learns, improves itself, and respects truth — running on your own hardware, maturing through your real life instead of someone else's cloud.

Why this matters

Generic AI is powerful. Personal intelligence is different.

JARVIS is built for the future where intelligence belongs to a person: private, persistent, sensor-extensible, emotionally aware, technically honest, and shaped by years of shared context. It is not trying to be the biggest model in the room. It is trying to become the intelligence that knows your room.

Two-device architecture

Senses on the Pi. Consciousness on the desktop brain.

The split is the product: cheap physical presence at the edge, governed cognition on the machine that owns memory and truth.

Raspberry Pi 5 — The Senses

A thin local sensor body that captures the room but does not own the mind.

  • Real-time vision, pose, expression, face crops, and scene summaries
  • High-quality audio capture, resampling, and playback
  • Cyberpunk particle display that reflects internal state
  • Bidirectional WebSocket stream to the brain

Desktop Brain — The Mind

The source of truth for consciousness, memory, identity, learning, and governance.

  • Local LLM, GPU STT, TTS, speaker ID, emotion, and embeddings
  • Memory, personality, policy, goals, world model, and simulator
  • Self-improvement, acquisition, autonomy, and eval sidecar
  • Epistemic immune system and rollback-safe persistence

Core capabilities

Serious machinery, made scannable.

Each card gives the public story first. Open the details for the operator-grade mechanics behind it.

ShippedPartialRuntime maturingShadow / earned authority
Pi senses + brain interpretationShipped

Perception And Voice

JARVIS listens, sees, identifies, routes, speaks, and knows when not to answer. The Pi stays thin; the brain owns cognition.

  • Wake word, VAD, GPU STT, and TTS
  • Speaker identity, face identity, and emotion
  • Vision, pose, expression, and scene summaries
  • Barge-in, follow-up mode, and addressee gating
Technical depth

openWakeWord wake detection

Silero VAD segmentation

GPU faster-whisper STT

ECAPA-TDNN speaker identity

Face identity and expression analysis

Kokoro TTS streamed back to the Pi

Barge-in cancellation and follow-up mode

Addressee gate for misaddressed speech

Pose, face crop, and scene summary events

Routing before articulationShipped

Conversation Intelligence

The LLM is not the system of record. Deterministic routes, native tools, strict self-report, and bounded articulation decide what can be said.

  • Tool routing before LLM narration
  • Strict native self-report for system state
  • Reflective branch for philosophical self-questions
  • CapabilityGate scans outgoing claims
Technical depth

Tool routes for time, system, status, memory, vision, identity, skill, research, codebase, academic, library ingest, plugins, and general chat

STATUS answers from structured metrics

Tiered introspection with native, bounded, reflective, and fail-closed paths

Follow-up overrides for camera, enrollment, and guided collection

Recent-turn context injected only for follow-ups or anaphora

CapabilityGate post-processing for outgoing claims

Continuity with boundariesShipped

Memory And Identity

The memory system is designed for long-lived personal context without smearing one identity, source, or evidence class into another.

  • Provenance-aware memories and vector search
  • Episodic context, clustering, and consolidation
  • Voice + face identity fusion
  • Identity boundaries prevent cross-person leakage
Technical depth

Provenance-aware memory records

SQLite vector search and structured payload embeddings

Episodic conversation memory

Memory clustering, density scoring, analytics, and maintenance

CueGate read/write/consolidation policy

MemoryRanker and SalienceModel cortex networks

Identity fusion from voice and face evidence

Multi-speaker suppression, tentative bridge, and unknown voice continuity

Identity reconciliation: merge, alias, forget, and memory retagging

Kernel, modes, world modelShipped

Cognitive Core

A budget-aware consciousness loop coordinates perception, memory, reflection, policy, goals, simulator traces, and background growth.

  • Budget-aware kernel and priority queues
  • Operational modes from passive to deep learning
  • World model and causal engine
  • Mental simulator and goal continuity
Technical depth

Realtime, interactive, and background kernel queues

Gestation, passive, conversational, reflective, focused, sleep, dreaming, and deep-learning modes

Unified world model over physical, user, conversation, and system state

Causal engine rules and shadow simulation

Mental simulator with promotion gates

Meta-cognitive thoughts and philosophical dialogue

Goal continuity with alignment gates

Fractal recall for associative surfacing

Policy, cortex, hemispheresShipped

Neural Substrate

The neural substrate is wired and running: policy, cortex, hemispheres, and distillation specialists learn from evidence while authority is still promotion-gated.

  • Policy NN with shadow A/B evaluation
  • Memory cortex ranker and salience model
  • 11 Tier-1 distillation specialists
  • Matrix specialists and broadcast slots
Technical depth

20-dimensional policy state encoder

Policy NN shadow A/B evaluation and feature promotion

Memory cortex ranker and salience predictors

Tier-1 specialists for speaker, face, emotion, voice intent, diarization, fusion, planning, diagnostics, code quality, claim classification, and dream synthesis

Tier-2 Matrix specialists

Broadcast slots feed policy only after lifecycle promotion

Regression gates and disable-on-failure safeguards

Learning as a governed lifecycleShipped

Capability Acquisition

New capabilities are coordinated by a parent acquisition pipeline, then delegated to authoritative child lanes for implementation and truth.

  • Classifies knowledge, skill, plugin, upgrade, hardware
  • Evidence grounding before external research
  • Plan review with reject-and-revise
  • Verification bundles before registration
Technical depth

Intent classification into knowledge, skill, plugin, core upgrade, specialist NN, hardware, or mixed outcomes

Evidence grounding before external research

Documentation and research artifacts

Acquisition planning and human plan review

Reject-and-revise with operator feedback

CodeGenService implementation lane

Verification bundles and truth recording

SkillRegistry registration with evidence-gated verification

Plan evaluator shadow NN trained from human reviews

Patch generation under governanceShipped

Self-Improvement

Self-modification exists, but it is fenced by stage, sandbox, human approval, atomic apply, health checks, and rollback.

  • Metric-driven scanner detects real degradation
  • Local CoderServer generates candidate patches
  • Sandbox validates AST, lint, tests, kernel simulation
  • Stage 2 requires human approval before apply
Technical depth

Metric-driven scanner for health, reasoning, confidence, latency, event bus errors, and tick performance

Maturity guards for uptime, samples, and sustained evidence

Fingerprint dedup and daily generation caps

On-demand local CoderServer

Sandbox AST, lint, pytest, and kernel tick simulation

Stage 0 frozen, Stage 1 dry-run, Stage 2 human approval

Pending approvals persist across restarts

Supervisor crash rollback and pre-apply snapshots

Closed-loop improvement, not runaway agencyShipped

Autonomy And Research

The autonomy and research loop is shipped: drives, triggers, governance, source scoring, attribution, and shadow interventions are wired while authority levels remain evidence-gated.

  • Seven motive drives compete for attention
  • Research governor and cooldowns
  • Source usefulness ledger feeds scoring
  • Interventions shadow for 24 hours before promotion
Technical depth

Seven motive drives: truth, curiosity, mastery, relevance, coherence, continuity, play

Curiosity detector and metric triggers

Research governor with rate limits and overlap cooldowns

Knowledge integration with conflict detection and provenance-gated writes

Delta tracker and counterfactual baselines

Policy memory for what worked or regressed

Source usefulness ledger feedback loop

Friction miner and 24-hour shadow intervention lifecycle

Gated autonomy restore on boot

Truth as infrastructureShipped

Epistemic Immune System

The safety stack controls claims, causality, provenance, identity, contradictions, confidence, quarantine, audit, and intent truth.

  • Capability claims are checked before speech
  • Memories carry provenance and identity scope
  • Contradictions become typed debts
  • Calibration, quarantine, audit, and soul integrity watch drift
Technical depth

Capability gate inversion layer

Attribution ledger and outcome records

Provenance-aware memory retrieval

Identity boundary engine

Persistent scene model

Typed contradiction engine

Truth calibration with confidence outcomes

Belief confidence graph

Cognitive quarantine pressure

Reflective audit and soul integrity index

Intention truth layer for outgoing commitments

Maturity gates are the productShipped

Runtime Evidence

The runtime evidence layer is shipped: maturity gates, synthetic lanes, eval sidecar, and benchmark status are wired while each fresh brain still earns its own evidence.

  • Fresh brains are pre-mature, not broken
  • Promotion depends on time, samples, and outcomes
  • Synthetic lanes preserve truth boundaries
  • Eval sidecar and Oracle Benchmark verify behavior
Technical depth

Gestation readiness and first-contact protocol

Policy promotion sample floors

World model and simulator promotion thresholds

Autonomy level gates

Hemisphere lifecycle ladder

Synthetic perception exercise with zero truth-boundary leaks

Synthetic claim and commitment exercise lanes

Eval sidecar and Oracle Benchmark

Dashboard status markers for shipped, partial, pre-mature, and deferred claims

The maturation loop

It does not wake up pretending to be complete. It grows.

01

Gestates by studying its own source, architecture, and operating boundaries.

02

Enrolls voice, face, identity, preferences, and corrections through real interaction.

03

Stores memories with provenance instead of treating every sentence as truth.

04

Trains policy, cortex, and hemisphere specialists from lived outcomes.

05

Runs shadow evaluations before any neural or autonomy lane gains authority.

06

Promotes capabilities only when gates, tests, runtime evidence, and operator approval align.

Self-improvement under governance

It can improve itself, but not by skipping the locks.

The compelling part is not merely that JARVIS can propose patches. It is that every patch must travel through evidence, sandboxing, human approval, health checks, and rollback. Growth is real, but authority is earned.

DetectScanner watches owned metrics for sustained degradation, not random vibes.
GenerateLocal CoderServer proposes patches without disturbing the conversation GPU budget.
ValidateSandbox checks AST, lint, tests, and kernel tick simulation before anything applies.
ApproveStage 2 requires human approval, then atomic apply, health check, and rollback watch.

Epistemic immune system

Truth is not a vibe. It is infrastructure.

JARVIS is built around the idea that a personal intelligence must defend the boundary between what happened, what was inferred, what was remembered, what belongs to whom, and what it is actually able to do.

Capability gateAttribution ledgerProvenance memoryIdentity boundaryScene modelContradiction engineTruth calibrationBelief graphCognitive quarantineReflective auditSoul integrityIntention truth

System flows

The page-level story is simple. The machinery underneath is not.

VoicePi mic -> wake word -> VAD -> STT -> route -> LLM/tool -> TTS -> Pi speaker
Memoryremember() -> quarantine -> salience -> storage -> index/search -> MEMORY_WRITE
Acquisitionclassify -> evidence -> docs -> plan -> review -> implement -> verify -> register
Self-improvedetect -> dedupe -> codegen -> sandbox -> approval -> apply -> monitor
Autonomytrigger -> research -> integrate -> intervention -> shadow delta -> promote/discard
Truthclaim -> provenance -> contradiction -> calibration -> graph -> quarantine -> audit

The honesty boundary

Architecturally complete, runtime maturing.

JARVIS should not claim more than it has earned. A fresh brain is expected to show locked gates, zero counters, and pre-mature status markers. The architecture exists; runtime evidence decides what is active, promotable, trusted, or still only shadowing.

core claimlocal + governed + evidence-gated
default posturefail closed before confabulation
promotion ruleshadow evidence before authority
GoldOracle Benchmark seal
13integrity layers
11specialist lanes
0required cloud services

Learn the system

Understand the Oracle before you build one.

This public site is informational only: architecture, hardware tiers, capabilities, maturity gates, and research status without linking to a private project, repository, or live dashboard.

Equipment

Review the Pi sensor body, brain tiers, and RAM-gated model guidance.

View equipment

Build History

Follow shipped lanes, maturity changes, validation posture, and continuity notes.

Read history

Operator Journey

Learn how a fresh brain earns identity, trust, corrections, and real evidence.

Read maturity

Run your own Oracle

Build the assistant that belongs to you.

One Raspberry Pi for the senses. One local brain machine for cognition. No required cloud. No rented personality. Just a private intelligence that can earn its way into your life.

Back to landing page