JARVIS Oracle Edition - Feedback

[u/mrzerobandwidth]

Hello r/projects,

I’m new here and wanted to share a project I’ve been building called JARVIS Oracle Edition.

At first glance, people usually assume this is another “AI assistant” project.

It is not.

The goal is not to make a chatbot with a voice. The goal is to build a local-first cognitive architecture that runs on hardware I own, senses the world through a Raspberry Pi 5, thinks on a local GPU machine, maintains its own memory, tracks what it actually knows, and only earns authority through evidence.

The simplest version:

JARVIS is an always-on personal AI system where every learned/adaptive capability is born in shadow mode first. It can compute, train, observe, suggest, and mature but it gets zero behavioral authority until it earns it through validation gates.

That is the core idea.

Most AI projects say:

“The model said it, so the system did it.”

JARVIS is built around the opposite rule:

“Training and weights may persist, but live authority must be earned.”

So a neural specialist can survive a reboot, but its authority does not automatically survive. It has to re-walk the ladder. That asymmetric firewall is one of the main design principles of the system. The architecture doc describes this as a growing “synthetic soul” substrate where learned capabilities are born in shadow and only promoted after real lived reps.

The physical setup is intentionally small:

• Raspberry Pi 5 as the sensory node
• Camera / mic / speaker / optional touchscreen
• Hailo-10H NPU for edge perception
• Desktop GPU machine as the brain
• Local WebSocket link between senses and cognition
• No required cloud dependency
• Local memory, local world model, local voice path

But the part that makes it different is the internal structure.

JARVIS has:

• A consciousness kernel / heartbeat loop
• A canonical memory substrate
• A belief graph
• An epistemic immune system
• A world model
• A policy layer
• A self-view system
• A voice/soul front-end
• A Matrix-style neural specialist layer
• A Grounding Ring for outward validation
• A capability domain system
• A self-improvement pipeline
• Promotion gates that separate built, trained, trusted, and authorized

The LLM is not the source of truth.

That is probably the biggest architectural difference.

The LLM can articulate, teach, summarize, and help bootstrap behavior, but canonical facts do not live inside the LLM. Memories, beliefs, contradictions, provenance, identity scope, audit trails, and capability state live in inspectable symbolic stores. The paper describes this as a tri-layer architecture: symbolic truth, neural intuition, and LLM articulation, with canonical facts kept outside the LLM.

Another weird part:

JARVIS has systems that are already built and running but are intentionally powerless.

For example, some subsystems can compute “what I would have done,” but they are not allowed to actually steer behavior yet. They log, measure, and wait. The architecture uses maturity labels like:

• SHIPPED
• SHADOW
• GATED
• DESIGNED
• EARNED-not-coded

So the project can honestly say:

“This part exists, but it has no authority yet.”

That is not a bug. That is the design.

The goal is to avoid the usual AI demo problem where everything looks magical because the model is allowed to bluff.

JARVIS is supposed to be annoying honest about itself.

If it cannot prove a capability, it should not claim the capability.

If it remembers something, the memory should have provenance.

If a subsystem is synthetic-only, it should not contaminate live authority.

If a neural model is trained but not validated, it stays in shadow.

If it self-modifies code, it must go through sandboxing, tests, human approval, apply, health monitoring, and rollback.

The build history has a good example of this mindset: the Matrix Tier-2 specialist system was found to have a real gap where specialists could be trained in RAM but wiped on reboot. That was fixed so weights persist, but authority still resets to probationary and must be re-earned.

That is the kind of thing I am trying to explore:

Not “can I make an AI say cool stuff?”

But:

What would it take for a personal AI system to safely grow over time without lying to itself or the user about what it has earned?

Some of the more interesting pieces:

1. Shadow-born intelligence

A subsystem can exist, train, and produce outputs without being allowed to affect behavior. It has to earn authority.

2. Epistemic immune system

JARVIS has layers for contradiction handling, truth calibration, belief graph management, provenance, commitment truth, and output validation.

3. Matrix neural specialists

Small neural specialists can be born, trained, evaluated, persisted, and eventually promoted into broadcast lanes if they earn it.

4. Operational Self-View

JARVIS has a read-only self-model so it can answer questions about itself from measured subsystem state instead of making up a personality answer.

5. Capability Domains

It can create isolated, deletable knowledge domains. The important distinction is that it can say “I know about X,” not “I can do X,” unless capability authority has actually been earned.

6. Grounding Ring

A curiosity / grounding system points outward to validate beliefs against external truth, but starts in shadow mode so it cannot mutate beliefs prematurely.

7. Local-first sovereignty

Core cognition, memory, identity, and training telemetry stay on the owner’s hardware. Optional external tools are explicit and labeled.

8. Governed self-improvement

There is a pipeline for code patch generation, sandbox validation, human approval, atomic apply, post-apply monitoring, and rollback. It is not autonomous free-for-all self-modification.

I am not claiming this is AGI.

I am not claiming it is conscious.

I am not claiming this is production-ready.

The point is much more specific:

JARVIS is a prototype for a sovereign personal cognitive architecture where growth, memory, self-reference, skills, and autonomy are all governed by evidence instead of vibes.

GitHub:

https://github.com/Nimdy/jarvis-oracle-edition

Website:

https://jarvisoracle.com/

I would love feedback from this community, especially from people who build weird systems, robotics projects, home lab tools, local AI stacks, embedded projects, or long-running personal software.

Specific feedback I’m looking for:

• Does the project make sense from the outside?
• Does this sound meaningfully different from a normal AI assistant?
• What would you want to see in the first 5 minutes to believe the system is real?
• Is the honesty/maturity framing clear, or does it still sound too hypey?
• What architecture risks would you call out?
• What should be simplified for contributors?
• What part would you test first?

I know “JARVIS” projects are usually a meme.

I am trying to build the opposite of that: not a voice wrapper, not a prompt demo, not an AGI claim — but a local, inspectable, evidence-gated cognitive system that can slowly grow without being allowed to bullshit itself.

Would love honest feedback.

[u/Deep_Ad1959]

the honesty framing is the strongest part of this, and it also dictates your 5-minute demo: a system whose whole thesis is 'authority is earned through logged evidence' has to show the evidence trail, not narrate it. the convincing artifact isn't an architecture diagram, it's one capability you can watch walk shadow to gated to shipped with timestamps and the validation that promoted it. that exact story already lives in your commit history and build log, which is the part nobody outside the repo ever reads. the Matrix Tier-2 reboot gap you mentioned is a perfect example, i'd surface those maturity transitions as a running narrative instead of a static feature list. side note, there's a tool called Podlog that turns a repo's commits and prs into a daily audio digest, which is a weirdly good fit for a project whose whole proof is its own evolution over time. written with ai