AienOSPERSISTENT MACHINE INTELLIGENCE

Sovereign Intelligence™

Sovereign Intelligence, built on AienOS. My work toward persistent intelligence that belongs to the person running it, from the language to the machine.

The language and the GPU

Omega makes programs explicit. CUDA++ is its GPU half. The implementation, remaining dependencies and receipts are inspectable.

Omega · CUDA++Omega source

Learn, discover, meet Aien

I share the working methods, the mistakes and the evidence so that people learning to build with AI can start from real work.

Learn · Discoveries · AienAien source

Not another app on someone else's computer

Most AI lives in a rented stack. A provider owns the machine, the model, the price, and the off switch. Your agent exists at their pleasure, forgets on their schedule, and works under their terms.

AienOS is the opposite bet: a sovereign machine, built from the first instruction after firmware upward, where a persistent intelligence lives on hardware you own. It keeps its memory, its identity, and its receipts on your side of the line. The hardware underneath is capability, not identity: machines can be replaced, and the lineage persists.

Recorded project state

The canonical layer record was updated 2026-10-01. These dated states preserve their original evidence scope; they are not an assertion that a past release or implementation note describes the current checkout. For the current product, use the Alpha release page and the release record. status.json and llms.txt use this same canonical record.

Turing instrument

status
IMPLEMENTED
note
Implemented (instrument); science partial. Current level: L2, Brownian scope only, instrument certification. L2 verdicts were checked against the private sealed records on 2026-10-01; the records stay private. Outside Brownian scope the ceiling is L1. TY-2 recorded 2,559,679.825 bits of Turing gain. This is a gain in bits, not a yield. Yield is T/J (Turings per joule), and T/J is not established: no energy was measured.
receipt_label
aien-dev/omega · PR #88
Source on GitHub

Turing experiments (EXP-001 / 002 / 003)

status
EXPERIMENTAL
note
EXP-001 FAIL, EXP-001R PASS, EXP-002A PASS, EXP-002B PASS, EXP-002C PASS, EXP-002D INCOMPLETE, EXP-003 BLOCKED. Failures stay on the record.
receipt_label
aien-dev/omega · PR #119
Source on GitHub

Public release

status
PLANNED
note
Pre-alpha. No supported release or installer yet. When there is one, it ships with versions, hashes, and signatures, inspectable before it runs.
receipt_label
null
receipt
null
Source on GitHub

The components, as of the public-record snapshot

Facts gathered at 2026-11-06T18:21:06Z. This is the checked-in public record read at build time, not live telemetry. Repository activity does not establish hardware qualification.

Newest decision records in this snapshot

All decision records · facts.json

The design, machines and full evidence record

Turning search into verified understanding

AienOS is an owned experimental machine for turning search into verified understanding. Aien proposes structure. Omega makes that structure explicit and checkable. The machine tests it against reality under authority. The Turing measures what was actually learned. Cortex keeps the evidence. Then the next search begins from what survived.

  • AienOS is an attempt to build persistent machine intelligence as a scientific process rather than a model invocation. Neural machinery may propose, but proposals have no authority.
  • Omega turns them into explicit programs and theories; verification determines whether they are internally valid; the owned machine tests them against physical reality; the Turing measures whether they explain unseen observations after paying for their own complexity; Cortex preserves the evidence; and that verified experience changes the next search.
  • Atlas carries the lineage across hardware. The goal is not a machine that sounds as though it understands, but a machine whose growth in explanatory power can be measured, falsified, reproduced, and owned.

Weights suggest. Programs explain. Verification decides. Evidence teaches. The Turing keeps score.

The loop

Proposals travel the generation path, meet reality, and are scored. The evidence that survives starts the next search. A perimeter of authority, observation and receipts surrounds the whole loop.

Generation path · Evidence feedback · Verification and authority perimeter

Perimeter: around the loop, never a stage

  • AEGIS: authority + proof boundaries
  • ARGUS: observation / audit
  1. ATLAS

    awakens / lineage

  2. AienOS

    persistent owned substrate

  3. Aien

    proposes / guides search

  4. OMEGA

    formalizes / searches / verifies meaning

  5. FORGE

    realizes

  6. REALITY

    executes / responds

  7. TURING

    scores explanatory gain

  8. CORTEX

    preserves evidence

Back to the next Aien / Omega search: CORTEX evidence feeds the next round.

  • Capability system: controls what may happen
  • Evidence receipts: make outcomes reproducible
ATLAS, AienOS, Aien, OMEGA, FORGE, REALITY, TURING and CORTEX are the stages. AEGIS, ARGUS, the capability system and evidence receipts form the perimeter around them. What Omega is, in plain words, and its GPU half, CUDA++.

Three questions under the loop

Did it learn anything?

Turing gain: net explanatory structure that survives held-out reality.

TY-2 Turing gain

id
TY-2
status
PASS
Evidence status
PASS (verdict=PASS)
headline
2,559,679.825 bits of Turing gain
Measurement limitation
This is a gain in bits, not a yield. Yield is T/J (Turings per joule), and T/J is not established: no energy was measured.
plain
On held-out data, the candidate model C described the events in about 2.56 million fewer bits than the order-1 baseline B, about 0.4387 bits per event.
scope
held-out predictive compression, Turing Yield profile V0; candidate C (op + previous 4 outcomes) vs baseline B (order-1); fit seeds 1-7, held-out 8-10; 5,834,845 held-out events of crumbline control-learner search events
Claim scope
information part of H5 only; sits below the L1 chain (separate profile)
receipt
evidence/TURING_YIELD/ty2_heldout_receipt.txt
commit
scoring code 487de8d7 (TY-1); PR #85 f0dc0af9; verify log PR #88 1b75aa81
date
run 2026-09-29
limitations
Ideal code length only, no decodable bitstream. Verify uses the same tool (self re-derivation, not independent). Not a scientific discovery measure. No energy. Post hoc op+prev1..5 scored higher (+2,722,851.799), not counted. Check: dl_b_ub 7484024867446 minus dl_c_ub 4924345042631 = 2559679824815
Next dependency
H4 then TY-7
evidence
receipt fields t_microbits, dl_b_ub, dl_c_ub, verdict; tools/turing_yield.c:319; src/turing/ty_qrecord.c:343
Receipt on GitHub

What did it cost to learn?

Turing yield: verified explanatory gain per measured physical resource.

Turing yield T/J (H5 physical part)

id
TURING-YIELD-TJ
status
NOT STARTED
Evidence status
NOT STARTED (blocked on H4)
plain
Turings per joule cannot be computed until energy is measured, so this has not started.
scope
n/a
Claim scope
L6 not met
receipt
none
commit
none
date
n/a
limitations
TY2 states no energy was measured; T/J (TY-7) uses the denominator in profile section 10. DIRAC-0 reports NOT_RUN
Next dependency
H4
evidence
QS:24; TY2 last bullets; architecture DIRAC-0-SPEC.md:158
Source on GitHub

Did what it learned make future discovery easier?

Search / verification gap: whether acquired abstraction would collapse future search complexity. An open question I want to study. Nothing here is measured yet.

Start here · The Machine · Scientific Discovery · See the evidence · Explore the architecture · GitHub

  • C kernel boots via UEFI: see the dated receipts.
  • Every claim carries a receipt.
  • Failures published, not hidden.

Five machines, one project

A DGX Spark, an Intel iMac, a Raspberry Pi 5, QEMU and a Windows PC target. QEMU is an emulator, not a physical body. AienOS is the operating-system project; aienux is its kernel. These are dated inventory observations, not live telemetry.

Inventory as of 2026-10-19. Each card states its environment, evidence date, branch and limitations.

NVIDIA DGX Spark

id
spark
detail
Grace Blackwell GB10, 128 GB unified memory, AArch64
role
The development machine and the judge. Every speed receipt, every chip receipt, the verification pipeline and every agent run here.
today
Linux. Serves Qwen3.8-27B (FP8) through my own server, aien-serve-http, on my own C GPU kernels, built inside the Omega project. The AienOS C kernel has not booted on the Spark; a Rust-era kernel booted once on 2026-09-24.
Evidence date
2026-10-19
evidence
Live-server speed receipt, evidence/qwen38-serve-fast-20261019
branch
qwen38/serve-fast
On the default branch at the recorded date
false
Receipt on GitHub

Intel iMac 2017

id
imac
detail
iMac18,3, Core i5-7500 with 4 cores, 16 GiB, AMD discrete GPU, Broadcom Ethernet
role
Bare metal AienOS, the x86_64 port of the C kernel. The whole screen is Aien's window: night sky, stars, black holes, Aien.
today
Boots the kernel from its own disk or netbooted from the Spark as a signed image, and sends a boot report back over the network. The kernel it runs today is in the open iMac pull request stack, not yet on main.
Evidence date
2026-10-17
evidence
iMac batch run: all cores, both disks read, Ethernet seen (evidence/imac_kernel1_2026-10-17, on main)
branch
main (evidence); kernel in PR #418 stack
On the default branch at the recorded date
true
Receipt on GitHub

Raspberry Pi 5

id
pi5
detail
BCM2712, AArch64
role
Two jobs: the first real hardware for the AArch64 AienOS C kernel, and the project's house server on Linux.
today
Kernel runs are per test, from an SD image written for each run; no resident kernel is claimed. The house server runs readings-window, a read-only window onto the Spark's readings, and pi-register, the register of its services.
Evidence date
2026-10-13
evidence
Hardware runs: interrupts, four cores, user-mode tasks, scheduling, message passing, a log written to SD and read back (evidence/pi5_hardware_runs_2026-10-13, on main)
branch
main
On the default branch at the recorded date
true
Receipt on GitHub

QEMU

id
qemu
detail
AArch64 virt with AAVMF; x86_64 q35 with OVMF
role
The emulator path. Every AienOS kernel gate runs here first, and QEMU qualifies nothing physical, by the repository's own words.
today
Core-only and full AienOS kernel images for AArch64, the iMac kernel image for x86, the Atlas boot seed and the recovery images.
Evidence date
2026-10-09
evidence
24 of 24 emulator gates PASS at 7f0de7e (receipt on main). The gate script now lists 26 gates, so a newer receipt is owed.
branch
main
On the default branch at the recorded date
true
Receipt on GitHub

Windows PC with an RTX 5070

id
rig
detail
12 GB of GPU memory; the AIEN Rig target
role
The target for AIEN Rig: a local AI engine in a 12 GiB budget, a Windows frame-rate tuner, speech to text, a creator helper and one Windows app.
today
Nothing of mine has run on it yet. Every Rig artifact is built on GitHub Actions without a GPU, or measured on the Spark under a 12 GiB budget. There is no release tag yet.
Evidence date
2026-10-19
evidence
Rig engine receipts in a 12 GiB budget, measured on the Spark GB10, not on a 5070 (docs/inference/evidence/rig-engine-20261019)
branch
rig/engine-12gb
On the default branch at the recorded date
false
Receipt on GitHub

The speeds measured on them, with receipts · The inventory data

Speed, with receipts

Recorded model and engine runs, not a claim about the server answering today. Each row preserves its date, environment, previous run, ceiling, branch, verdict and exclusions. A faster candidate that fails its gate remains a failure.

Every number on this page is judged against the physical ceiling of the machine it ran on, and against my own previous run. A comparison with another project is allowed when it is honest, dated, and backed by a receipt or that project's own published numbers. Overclaims stay off this page. End to end means wall time through the server as a client sees it, prompt reading included. Chip time means the GPU's own time per generated token, decode only, with prompt reading excluded. For the 35B, the gap between chip time and end-to-end time comes from prompt reading. The two are labelled and never mixed.

End to end through a test server running a branch build, one conversation

id
35b-e2e
model
Qwen3.6-35B-A3B FP8, a mixture-of-experts with about 3B parameters active per token
machine
Spark GB10
engine
C GPU stack (Omega project) behind aien-serve-http
value
22.0 to 22.5 tok/s
detail
21.95 and 22.46 tok/s in two runs: wall time from request out to last reply in, prompt reading included, greedy, at most 128 tokens per reply, on a test server running branch build bin-16b0e6f8 (port 18089, context 2048; the live server on port 18091 was stopped). Many conversations at once, in total: 57.1 tok/s at 8, 62.4 at 16, 65.7 to 66.4 at 32.
Tokens per second
null
ceiling
previous
date
2026-10-21
receipt
evidence/q36-batch-20261021, time-v2-16b0e6f8/time.jsonl
branch
main
On the default branch at the recorded date
true
verdict
note
The receipt commit is on main. Chip time for this model is decode only, prompt reading excluded, and is kept on the models page under its own label. The gap between that chip time and this end-to-end time comes from prompt reading.
Receipt on GitHub

Live server, chip time only (not end to end)

id
27b-live
model
Qwen3.8-27B FP8
machine
Spark GB10
engine
C kernels (Omega project) behind aien-serve-http
value
7.63 tok/s
detail
131.05 ms of GPU time per token, median of 4 runs of 256 greedy tokens
Tokens per second
7.63
ceiling
qwen38-27b-fp8-gb10
previous
6.29 tok/s, the old binary, in the same receipt's before folder
date
2026-10-19
receipt
evidence/qwen38-serve-fast-20261019
branch
qwen38/serve-fast
On the default branch at the recorded date
false
verdict
note
Real traffic over 22 replies, chip median from the server log: 7.52 tok/s. The engine alone measures 123.0 ms; the 8 ms gap to the server is not explained yet.
Receipt on GitHub

Fresh account, public guide, new Linux user, chip time only

id
27b-fresh
model
Qwen3.8-27B FP8
machine
Spark GB10, shared with other load
engine
C kernels (Omega project) behind aien-serve-http
value
7.657 tok/s
detail
130.6 ms of GPU time per token, median of 3 runs; answers match the shipped reference
Tokens per second
7.657
ceiling
qwen38-27b-fp8-gb10
previous
date
2026-10-19
receipt
evidence/alpha-fresh-account-20261019/speed
branch
alpha/fresh-account-evidence
On the default branch at the recorded date
false
verdict
install.sh failed as written; the server was built by hand before this run
note
Receipt on GitHub

Engine alone, in process, chip time only

id
27b-engine
model
Qwen3.8-27B FP8
machine
Spark GB10
engine
C kernels (Omega project), engine test tool
value
8.13 tok/s
detail
123.04 ms per token, mean of 3 runs; 24 of 24 golden tokens
Tokens per second
8.13
ceiling
qwen38-27b-fp8-gb10
previous
6.40 tok/s, my run before this series
date
2026-10-19
receipt
omega evidence/q38-decode-speed-chip-20261019T*
branch
qwen38/decode-speed
On the default branch at the recorded date
false
verdict
note
Which of the four receipt folders holds the final three runs has not been marked yet.
Source on GitHub

FP8 final word-scoring step, A against B, chip time only

id
27b-fp8-head
model
Qwen3.8-27B FP8
machine
Spark GB10
engine
C kernels (Omega project), engine test tool
value
8.452 tok/s
detail
118.31 ms per token with the FP8 head; 124.25 ms (8.048 tok/s) with the bf16 head
Tokens per second
8.452
ceiling
qwen38-27b-fp8-gb10
previous
8.048 tok/s with the bf16 head, same session
date
2026-10-19
receipt
evidence/qwen38-ab-fp8head-w4-20261019T1230Z
branch
qwen38/w4-decode
On the default branch at the recorded date
false
verdict
FAILS the full-model gate on p95 drift, so it stays off
note
Receipt on GitHub

4-bit weights, whole model, chip time only

id
27b-w4
model
Qwen3.8-27B MXFP4
machine
Spark GB10, chip shared with two servers
engine
C kernels (Omega project), engine test tool
value
72.6 to 76.2 ms per token
detail
about 13.1 to 13.8 tok/s; FP8 in the same session 119.35 ms. The receipt records milliseconds; the tok/s is arithmetic on it.
Tokens per second
null
ceiling
previous
date
2026-10-19
receipt
omega evidence/cascade-w4-wm-*
branch
cascade/w4-gemv
On the default branch at the recorded date
false
verdict
24 of 24 tokens identical, but FAILS the FP8 logit-drift gate, as 4-bit is expected to
note
Several rounds failed at load for lack of memory; the failures are published too.
Source on GitHub

Rig engine in a 12 GiB budget, chip time only

id
rig-8b-fp8
model
Qwen3-8B FP8
machine
Spark GB10 under a 12 GiB device budget, not an RTX 5070
engine
Omega dense door
value
15.63 tok/s
detail
5 of 5 golden prompts identical
Tokens per second
15.63
ceiling
previous
date
2026-10-19
receipt
rig-engine-20261019/chip-fp8
branch
rig/engine-12gb
On the default branch at the recorded date
false
verdict
note
Nothing has run on the 5070 yet.
Receipt on GitHub

Rig engine in a 12 GiB budget, 4-bit, chip time only

id
rig-8b-w4
model
Qwen3-8B MXFP4
machine
Spark GB10 under a 12 GiB device budget, not an RTX 5070
engine
Omega dense door
value
20.17 tok/s
detail
5 of 5 golden prompts identical against the host reference; device memory 5.158 GiB; the swap-kv control fails as it must
Tokens per second
20.17
ceiling
previous
15.63 tok/s with FP8 weights, same day
date
2026-10-19
receipt
rig-engine-20261019/chip-w4-ceil
branch
rig/engine-12gb
On the default branch at the recorded date
false
verdict
note
Receipt on GitHub

Cold time to first token at long context

id
27b-ttft
model
Qwen3.8-27B FP8
machine
Spark GB10
engine
C kernels (Omega project) behind aien-serve-http
value
936.7 s at 128k tokens
detail
The 32k and 64k values are in the receipt
Tokens per second
null
ceiling
previous
date
2026-10-18
receipt
evidence/qwen38-prefill-20261018T1836Z
branch
qwen38/prefill-ttft
On the default branch at the recorded date
false
verdict
note
Receipt on GitHub

Physical ceilings: modeled, not measured

Proof, not promises

Every claim carries a receipt

This project does not ask to be believed. Each card names its environment, its gate, its date, and its verdict, and states plainly what the receipt proves and what it does not prove. That includes the failures, especially the failures.

Dated evidence, not a live dashboard: these preserved receipt cards describe the runs and branch states recorded in the site inventory of 2026-10-19. Words such as today and newest inside a card refer to that dated record, not the current machine. Research results below retain the canonical record's own date.

MEASURED

7.63 tok/s · 27B on Omega

A 27B model answers through my own server

Qwen3.8-27B (FP8) served by aien-serve-http on my own Omega GPU kernels, on the Spark. 131.05 ms per token, the median of 4 runs of 256 greedy tokens, 0.752 of the 10.15 tok/s memory ceiling. The old binary in the same folder did 6.29.

Proves
The 27B answers through my own server and kernels at this speed, with the runs published beside the ceiling they sit under.
Does not prove
That the number is on main yet (it is on a branch), or anything about any other machine.
Date
2026-10-19
Environment
Spark GB10, port 18091, branch qwen38/serve-fast
Gate
Live-server decode receipt
Receipt source
aien-sovereign-core-mv · qwen38/serve-fast
Evidence on GitHub

FAIL AS WRITTEN

install.sh exits 101

A stranger follows the alpha guide

A fresh Linux account followed the public guide to install and run the 27B server. The install script failed at the server build step. With a hand workaround, the remaining steps passed: 81 of 81 checksums, the gate, and 7.657 tok/s with answers matching the shipped reference.

Proves
The guide is almost there, and exactly where it breaks is on the record with the fix named.
Does not prove
That anyone can install from the guide today. The verdict is FAIL until the script is fixed and the test is run again.
Date
2026-10-19
Environment
Spark GB10, new user, branch alpha/fresh-account-evidence
Gate
Fresh-account alpha test
Receipt source
aien-sovereign-core-mv · alpha/fresh-account-evidence
Evidence on GitHub

PASS

24 of 24 emulator gates

Every kernel gate, in QEMU, on main

aienux, the AienOS C kernel, passes all 24 emulator gates at commit 7f0de7e, each one a script anyone can rerun, with the receipt on main. The gate script now lists 26, so a newer receipt is owed.

Proves
The kernel reaches every gated stage under emulation at the recorded commit.
Does not prove
Anything physical. QEMU qualifies nothing physical, by the repository's own words.
Date
2026-10-09
Environment
QEMU, AArch64 virt and x86_64 q35, on main
Gate
ck_gates.sh, 24 gates
Receipt source
aienux · evidence on main
Evidence on GitHub

MERGED

Four cores on a Raspberry Pi 5

The kernel on real hardware

The AArch64 C kernel ran on a Raspberry Pi 5: interrupts, all four cores, user-mode tasks, scheduling, message passing, and a log written to the SD card and read back. Pull requests #345 and #346, evidence on main.

Proves
The kernel's core services run on physical hardware, not only in the emulator.
Does not prove
A resident kernel. Each run writes a fresh SD image; release qualification (PI5-8) is still open.
Date
2026-10-13
Environment
Raspberry Pi 5, BCM2712, SD image per run
Gate
Pi 5 hardware bring-up runs
Receipt source
aienux · evidence on main
Evidence on GitHub

MERGED

Aien's window on an iMac

The x86 port boots bare metal

The x86_64 port of the C kernel booted an Intel iMac 2017: all cores started, both disks read, Ethernet seen. The whole screen is Aien's window. The kernel the iMac runs today sits in the open pull request stack (#414 to #424).

Proves
The port runs on the physical machine with its cores, disks and network found.
Does not prove
That today's iMac kernel is on main. The evidence is; the newest kernel is in open pull requests.
Date
2026-10-17
Environment
Intel iMac 2017, bare metal, netboot from the Spark
Gate
iMac batch run, evidence/imac_kernel1_2026-10-17
Receipt source
aienux · evidence on main
Evidence on GitHub

Environment: Omega verification suite, turing-yield CI on main. Receipt source: aien-dev/omega · PR #88.

PASS TY-2

TY-2 Turing gain

2,559,679.825 bits of Turing gain

This is a gain in bits, not a yield. Yield is T/J (Turings per joule), and T/J is not established: no energy was measured.

On held-out data, the candidate model C described the events in about 2.56 million fewer bits than the order-1 baseline B, about 0.4387 bits per event.

Scope, limits and receipt
Status
PASS (verdict=PASS)
Scope
held-out predictive compression, Turing Yield profile V0; candidate C (op + previous 4 outcomes) vs baseline B (order-1); fit seeds 1-7, held-out 8-10; 5,834,845 held-out events of crumbline control-learner search events
Claim level
information part of H5 only; sits below the L1 chain (separate profile)
Limitations
Ideal code length only, no decodable bitstream. Verify uses the same tool (self re-derivation, not independent). Not a scientific discovery measure. No energy. Post hoc op+prev1..5 scored higher (+2,722,851.799), not counted. Check: dl_b_ub 7484024867446 minus dl_c_ub 4924345042631 = 2559679824815
Next dependency
H4 then TY-7
Evidence
receipt fields t_microbits, dl_b_ub, dl_c_ub, verdict; tools/turing_yield.c:319; src/turing/ty_qrecord.c:343
Receipt
evidence/TURING_YIELD/ty2_heldout_receipt.txt
Commit
scoring code 487de8d7 (TY-1); PR #85 f0dc0af9; verify log PR #88 1b75aa81
Date
run 2026-09-29
Evidence on GitHub

How it fits together

Hardware is treated as capability metadata, never as identity. The identity is the lineage: who wakes the machine, what keeps it alive, what checks its work, and what learns from the results.

These are responsibilities, not a literal turn order. AEGIS, FORGE, ARGUS and CORTEX serve the system by verifying, realizing, observing and remembering. Nothing receives authority merely by advancing through a diagram.

OMEGA

verb
defines · synthesizes · verifies
text
Aien's language for all computing, GPU to CPU. Its own tools check every program and compile it to the machine code of the chip that runs it. Replacing CUDA is not true yet. Nothing runs on a claim; everything runs on a check.
Source on GitHub

Sovereign Intelligence stack map · AienOS project · aienux kernel

Published research

Do not take my word for it. Check the receipts.

Most AI asks you to trust a demo and a promise. This project publishes its science in the open instead: the Turing, a unit of net held-out explanatory compression (one operational component of machine understanding), plus the papers behind it and the data anyone can recheck. It starts with the Turing.

The Turing (T)

A unit of net held-out explanatory compression

One Turing is one bit of net held-out description-length improvement: a short explanation that predicts things it has never seen earns Turings. Guessing earns nothing. Memorizing earns nothing, because the test data is new.

The Turing measures net held-out explanatory compression: one operational component of machine understanding.

Current level: L2, Brownian scope only, instrument certification. Outside Brownian scope the ceiling is L1. TY-2 does not change the ceiling.

The scorer behaves as specified on known stochastic cases. It does not mean AIEN discovered anything.

Explore the TuringRead the formal paperSee the full research ladder.

Evidence on GitHub

Try it: earn your first Turings

Round 0 / 12

A hidden rule is generating this stream of bits. Watch it, find the pattern, and call the next bit before it lands.

Score: 0 T

Each call you get right earns 1 T, each miss costs 1 T. A coin flip averages zero.

Everything, including protocols, sealed experiment profiles, and source files: the full research index · the public code and receipts on GitHub.

The syscall interface, simulated

INTERACTIVE SIMULATION

A simulation that runs entirely in your browser. No live machine is attached to this page, and nothing you type leaves it. It shows the shape of the interface the real machine speaks. The real machine's proof is in the evidence section, receipts and all.

AienOS REPL v0.4.0 (sm_121a · aarch64 · 128GB LPDDR5x) · COHERENT_ACTIVE

[*] AienOS Neural Kernel v0.4.0 initialized on GB10 (aarch64).

[*] Unified coherent address space: 128 GB LPDDR5x online.

[*] Capability vault sealed. Zero disk secrets invariant active.

[*] Type a syscall below or click one of the quick trigger buttons above.

Follow the work.

Watch the repositories, read the receipts, open an issue. Release artifacts and installation instructions are on the Alpha page; source, qualification and deployment are separate states.

Learning to code with AI? You are welcome here. Start with a practical working method, then watch my agents and me in Hive: the instructions, the models, the corrections, and the work as it happens.

Want to reach me? Follow me on X, @mdrakestapleton, email drake@aienos.com, or read where I am and how to reach me.

Machine-readable: status.json · facts.json · llms.txt

The public repositories

Say hello to Aien?

Hey, you just clicked an ad. I just want you to know that if you didn't intend to click an ad, that's cool. Just click No and this popup will close. Nothing will be tracked by my X pixel. Your browser may not let me close a page I didn't open.

Saying hello covers only the X pixel. Whether Aien remembers you is a separate choice that only the chat asks, and saying hello never makes it for you: Tell Aien my name or chat with Aien anonymously.

Who can see me right now?

This panel reads only this page and your browser. It sends nothing and stores nothing.

Outside sites this page has loaded: checking

What your browser tells every website

Any site you visit can read these. I don't keep them. Your IP address and browser name also reach this site's hosting providers with every request, as on any site.

What this page can't see

Trackers on other sites, in other tabs or inside embedded frames, tracking by your internet provider or network, and your browser extensions. These tools check more:

Privacy, what X receives, and your choice