AxonOS

The open cognitive operating system for brain–computer interfaces.

_{🇬🇧 English · 🇯🇵 日本語 · 🇨🇳 中文 · 🇮🇹 Italiano · 🇫🇷 Français · 🇩🇪 Deutsch · 🇪🇸 Español · 🇸🇦 العربية}

axonos.org  ·  Specifications  ·  SDK  ·  Research  ·  Articles  ·  connect@axonos.org

AxonOS is a hard real-time neural operating system for brain–computer interfaces. Open-source kernel in #![no_std] Rust on ARM Cortex-M. Formally bounded worst-case response time. Structural privacy that the application layer cannot bypass.

It is not an AI-agent framework, not a chatbot runtime, not a generic Python SDK, and not a token project. Everything below the application — the timing guarantees, the neural-permission model, the consent state machine — is specified, openly licensed, and built to be independently verified.

Applications should receive typed, consent-bound intent events — never unrestricted raw neural streams.

Three honest paths, depending on what you want.

Every repository is public. Source under Apache-2.0 OR MIT, specifications under CC-BY-SA-4.0. There are no private repositories. Each repository has one role.

	Repository	Role	Language	Latest
⬢	axonos-standard	Normative architecture — the canonical technical standard	Markdown
⬢	axonos-rfcs	Design-change process — numbered engineering RFCs, normative once finalised	Markdown	active
⬢	axonos-kernel	Execution substrate — hard real-time microkernel, formally bounded WCRT	Rust
⬢	axonos-sdk	Application boundary — typed intents, capability manifests, kernel ABI v1	Rust
⬢	axonos-sdk-python	Application boundary (Python) — RFC-0006 wire format, byte-compatible with the Rust SDK	Python
⬢	axonos-consent	Consent / co-authorisation subsystem — #![no_std] reference crate	Rust
⬢	axonos-protocol	Network-level consent protocol — no_std, zero-alloc, bounded CBOR frames and an exhaustive consent state machine	Rust
⬢	axonos-conformance	Byte-exact conformance — RFC-0005 capability manifest & RFC-0006 intent wire format, cross-checked across Rust, Python, C, JavaScript, Java in CI	multi	active
⬢	axonos-validation	Evidence and trace record — measurement traces and reference post-processing	Python	record
⬢	axon-bci-gateway	Acquisition bridge — OpenBCI fork, MIT preserved from upstream	HTML
⬢	axonos-swarm	Long-horizon distributed timing — multi-node Neural PTP coordination	Rust
⬢	AxonOS	Public entry point — landing, concept, and links into the stack	—	—
⬢	become-the-brain-os	Community front door — browser game that teaches the runtime, no install	HTML/JS

A complete brain–computer interface operating system is a continuous chain — from a raw electrode signal to a typed, consented intent, and back to a safe failure state. AxonOS is building that chain in the open. This map is deliberately honest about what is shipped, what is partial, and what is still ahead.

The execution core, the consent and capability layer, and the conformance surface are in place. To be a full operating system — not only a standard and a kernel — AxonOS still needs, and is sequencing on its roadmap:

• a dedicated acquisition driver and a fixed-point DSP pipeline (signal → features), plus a reference on-device classifier;
• a deterministic simulator, so a developer can run the full path without hardware;
• a structured safety case (hazard analysis, FMEA, residual-risk argument) and a formal threat model for cognitive data — as engineering artifacts, not regulatory claims;
• a privacy-vault enforcement layer that guarantees raw neural data never crosses the application boundary;
• a public conformance program and an independent-implementer challenge, so a third party can build a compatible kernel and SDK from the specification alone;
• a path from founder-led to foundation / technical-steering governance.

These are roadmap items, not present capabilities. They are published here so the distance between today's reference implementation and a complete, independently implementable BCI operating system is visible rather than hidden.

flowchart LR
    A[EEG/EMG sensors<br/>ADS1299 · 24-bit] -->|raw| B[Acquisition gateway<br/>nRF52840]
    B -->|filtered| C[AxonOS kernel<br/>Rust no_std<br/>Cortex-M4F]
    C -->|WCRT ≤1000µs, proven| D[Cognitive scheduler]
    D -->|typed intent| E[Application<br/>via SDK]
    F[Cognitive Hypervisor<br/>TrustZone-S] -.->|isolates| C
    G[Consent FSM<br/>axonos-consent] -.->|gates| D

    classDef kernel fill:#0a4a8f,stroke:#0a4a8f,color:#fff,stroke-width:2px
    classDef secure fill:#0d7a5f,stroke:#0d7a5f,color:#fff,stroke-width:2px
    class C kernel
    class F,G secure

Every arrow is a contract. The Standard defines what must hold at each boundary; an implementation is free in everything else.

The evidence taxonomy — L1 formally proven, L2 measured on reference hardware, L3 independently validated — is defined in VALIDATION.md, and every claim is graded in CLAIMS.md. The bounds above are L1: machine-checked proofs, published and proof-linked. The corresponding L2 worst-case figures — end-to-end latency, jitter, and the resulting improvement over a general-purpose OS — come from internal long-duration soak testing. Until their raw traces are published in axonos-validation, no measured performance figure is claimed here; the figures are held as publication-pending and graded in CLAIMS.md. L3 independent reproduction is not claimed.

git clone https://github.com/AxonOS-org/axonos-sdk
cd axonos-sdk
cargo test --features std

use axonos_sdk::{Capability, IntentStream, Manifest};

let manifest = Manifest::builder()
    .app_id("com.example.cursor")?
    .capability(Capability::Navigation)
    .max_rate_hz(50)
    .build()?;

let mut stream = IntentStream::connect(&manifest)?;
while let Some(obs) = stream.try_next()? {
    println!("{:?} @ {} µs ({}%)",
        obs.kind(),
        obs.timestamp().as_micros(),
        obs.confidence_percent());
}

The SDK is the Rust reference binding. C FFI, Python, WebAssembly, JNI, and Swift bindings are on the published roadmap.

AxonOS does not currently claim, and this organisation must not be read as claiming:

• FDA clearance, CE marking, or medical-device approval in any jurisdiction;
• clinical efficacy, or independent clinical validation;
• certified medical-device status, or production-implant readiness;
• complete compliance with IEC 62304, ISO 14971, or ISO 13485.

These are possible future milestones. They are not present facts, and the project records them as such.

• Specifications — kernel ABI v1, capability catalogue, IntentObservation wire format, RFC index
• SDK and language bindings — Rust today; C FFI, Python, WebAssembly, JNI, Swift on the published roadmap
• Standards engagement — IEEE P2731 · IEC 62304 · ISO 13485 · FDA 510(k) · EU MDR
• Governance — current state, transition plan, trademark policy
• Engineering memo — three-page summary for technical readers
• Long-form articles — 42+ pieces, one per major architectural decision

The AxonOS Project

axonos.org  ·  connect@axonos.org  ·  LinkedIn  ·  Medium

_{Singapore · Zurich · Berlin · Milano · San Mateo}

_{Built with Rust. Verified with Kani. Aimed at hard real-time.}