jodytornado

Show HN: I built a bare-metal OS with an autonomous reasoning engine in no_std Rust I've been working on this for the last 24 months as a solo developer and wanted to share what I've built and the results we just validated. What it is: PROTOS is a bare-metal operating system (no Linux, no Windows, no cloud) with an integrated reasoning engine called "EARL" (EPISTEMIC ADAPTIVE REASONING LAYER) that does autonomous multi-source intelligence fusion. Everything runs on a single laptop — no GPU, no network connection required. It's 174K+ lines of no_std Rust across 189 modules, including custom NVMe drivers, a filesystem, a knowledge base, the reasoning engine, autonomous learning systems, and safety controls. The core problem it solves: Current AI tools (LLMs included) can't explain their reasoning, give different answers to the same question, require cloud connectivity, hallucinate, and can't be audited. For defense and intelligence applications, this is a non-starter — DoD Directive 3000.09 requires that autonomous systems explain every decision with a verifiable audit trail. No existing AI system meets this standard for intelligence analysis. How it works: EARL uses symbolic reasoning rather than neural networks. It reads raw documents, automatically identifies entities (people, organizations, locations, weapons, financial transactions), discovers hidden connections across sources, learns new concepts from context, and detects when sources contradict each other. Every conclusion is backed by a cryptographically signed (SHA-256) evidence chain. Same inputs always produce the same outputs. What we just proved: We tested EARL against the buildup to Russia's 2022 invasion of Ukraine. We reconstructed 12 intelligence documents spanning satellite imagery analysis, intercepted comms, HUMINT reports, financial intelligence, OSINT, and technical weapons assessments from Oct 2021–Feb 2022. We defined 10 intelligence connections that Five Eyes agencies actually identified during this period (all verifiable against public sources — Maxar imagery, CRS reports, OSCE data, investigative journalism). EARL discovered 8 out of 10 autonomously. No training on the scenario, no pre-labeled data, no human guidance. It read raw text, built its own understanding, and independently arrived at conclusions that took the combined intelligence apparatus months to assemble. The system also correctly enforced safety constraints — connections below the confidence threshold were flagged but blocked from triggering autonomous action, exactly as 3000.09 requires. Technical details for the curious:

Pure no_std Rust, bare-metal execution Custom NVMe drivers and filesystem Symbolic reasoning engine (not neural/statistical) PMI-based knowledge representation with 15M+ edges Three-layer cognitive architecture: symbolic reasoning, metacognition, values/constraints Deterministic — reproducible results on every run Cryptographic forensics chain for full auditability Air-gap capable by design

My background: I'm a civil engineer who transitioned into systems programming after retirement. The technology has received preliminary validation from USASOC analysts who described the "reproducible reasoning" capability as disruptive. We're currently positioned for strategic acquisition and are open to strategic investment for formal DoD certification, team buildout, and field deployment optimization. Happy to answer technical questions about the architecture, the benchmark methodology, or the bare-metal Rust experience.

Over the past ~24 months I’ve been building PROTOS_OS, a symbolic reasoning kernel that runs directly on bare metal — no host OS, no hypervisor, no cloud dependency.

It’s written in ~175K lines of no_std Rust. I built the whole thing solo.

The system includes its own boot path, page tables, interrupt handlers, and NVMe driver. It runs in long mode at ring-0. There’s no syscall boundary between the reasoning engine and hardware, and no scheduler preemption separating decision logic from execution.

The goal is bounded, auditable autonomy for safety-critical environments.

The reasoning engine is symbolic and refusal-first. Every conclusion must resolve to an explicitly grounded knowledge-base state. If it can’t, execution halts. Unsupported assertions don’t propagate into automated action.

There’s no probabilistic inference path in the decision layer. All reasoning is local and deterministic. Identical inputs produce byte-identical reasoning chains across reboots, and those chains are integrity-verified.

I model epistemic state explicitly. There are six discrete knowledge states mapped to corroboration level. Automation only executes at full corroboration; contested or degraded states block autonomous action.

So far I’ve run 358 validation tests across 25 phases. The validation footage is uncut, and I documented what each phase is intended to verify:

https://www.jou-labs.com/proof

Some limitations up front:

Capability is bounded by knowledge-base completeness.

The system isn’t formally verified.

Hardware trust is currently rooted in firmware.

The design intentionally excludes probabilistic inference in the decision layer.

I’m particularly interested in feedback around:

Formal verification pathways for systems like this

Deterministic autonomy models

How to make autonomous systems legally defensible