# Show HN: A custom language that compiles and runs compute kernels on AMD GPUs

> Source: <https://github.com/drakestapleton/omega-mv>
> Published: 2026-11-15 14:24:34+00:00

[Papers:](https://doi.org/10.5281/zenodo.23614483) [Omega](https://doi.org/10.5281/zenodo.23547810), [The Token Is the Instruction](https://doi.org/10.5281/zenodo.23644702), [A Call to Humanity](https://doi.org/10.5281/zenodo.23614483) · Author: Drake Stapleton 

**GPU stack owned by [CUDA++ (aien-dev/CUDApp)](https://github.com/aien-dev/CUDApp)** ([ARCH-0042](https://github.com/aien-dev/aien-architecture-mv/blob/main/docs/adr/0042-omega-cudapp-bridge-ownership.md): Omega owns computation, CUDApp owns GPU execution). CUDA++ is the single source of truth for the GB10 GPU stack: `src/omega_gpu_*`, `src/omega_blackwell_*`, `src/omega_bw_*`, `src/omega_sm121_*`, the GPU host tests (` tests/gpu_*`, `tests/bw_*`, `tests/test_omega_gpu_*`), `mk/omega-gpu-*`, `mk/sm121dis.mk` and `tools/sm121dis/` (full list: `.github/CODEOWNERS`). Make new GPU changes there. The copies here stay in this repository; removing them needs a separate decision by Drake (ARCH-0042, decision 7). CUDA++'s drift gate (`tools/extract/drift.sh`) fails when one of these files changes here after the cutover baseline (`e5b32567`) without the same bytes in CUDA++. Building the server (aien-sovereign-core) from CUDA++ pinned in `cudapp.lock` is pending ([aien-sovereign-core-mv#784](https://github.com/aien-dev/aien-sovereign-core-mv/pull/784)).

**Omega is a systems language and compute platform being implemented in handwritten, seeded `.om`.** Its goal is one inspectable path from a small seed through compiler, runtime and applications to machine execution. Pure computation and authorized effects have distinct contracts; semantic identities identify declared computations, while validation and receipts record what was actually checked.

**Migration is not finished.** This repository's default branch still contains substantial C implementation and build/test tooling. The seeded `.om` compiler, its native host and device/mapping words, the OM-2 profile and the WebAssembly back end are on `main`; an existing C implementation is an outstanding replacement task, not the final language of Omega.

- [The Omega programme: seed to model](https://github.com/aien-dev/omega-mv/issues/599)
- [Omega 1.0 roadmap: readiness audit, milestones and acceptance gates](https://github.com/drakestapleton/omega-mv/blob/main/docs/ROADMAP-1.0.md)
- [One small Omega program, and the identity boundary](https://github.com/drakestapleton/omega-mv/blob/main/docs/TEACH_OMEGA.md) : a bounded lesson for issue #619. It uses a historical teaching pin, not the current compiler, and it does not claim the legacy identity machinery covers seeded programs.
- [Remaining C source/header inventory](https://github.com/drakestapleton/omega-mv/blob/main/docs/migration/C-TO-OM-INVENTORY.md)
- [Experimental `.om` deterministic-stream successor](https://github.com/drakestapleton/omega-mv/blob/main/seed/physics0/README.md) : source/host checks passed; native compilation and execution NOT_RUN.
- [Neuralese supplement](https://github.com/drakestapleton/omega-mv/blob/main/neuralese/README.md) : PROPOSED model-bound representation design, with a bounded native`.om` envelope/codebook candidate and ordinary checked-source boundary. No learned reasoning or model experiment is claimed.
- [Alpha model/platform qualification](https://github.com/aien-dev/aien-architecture-mv/issues/305)

GitHub's language bar measures recognized source bytes on the default branch; it is not the project's language specification or a migration-completion verdict. GitHub Linguist does not currently recognize Omega/`.om`, and the active C files here have not yet been replaced and removed. We do not label handwritten C as generated/vendor code, rename it to `.om`, or assign an unrelated language to change that statistic. See the inventory above for the actual remaining work. Native GitHub recognition requires support in [Linguist](https://github.com/github-linguist/linguist/blob/main/CONTRIBUTING.md#adding-a-language).

``` php
SILICON -> ATLAS -> PHYSICS/FORGE -> OMEGA -> AIEN        (full picture: aien-architecture)
```

Omega was decided by Drake on 2026-09-29 to be both the reaction runtime and the compiler for Omega Systems Core ([decision record](https://github.com/drakestapleton/omega-mv/blob/main/docs/adr/OMEGA-SYSTEMS-CORE-0000.md), frozen). This retires the earlier "not a compiler" wording.

Research-grade, with a staged Alpha qualification programme in progress. An Alpha plan or an open PR is not a qualified release. Plainly:

- **Seeded `.om` compiler (on `main` from PR #696):** one compiler,`seed/out/omc` , written in`.om` and rebuilt from the 408-byte loader by`sh seed/omega-from-seed.sh` (`seed0 -> hex1 -> asm2 -> om4 -> omc` ). Its one supported profile is AArch64 Linux, static ELF output, with the whole language in`docs/one_layer/OMEGESE.md` : native host words (ids 100..165) and the checked device/mapping words (ids 166..177). Host qualification is`tests/gates/run.sh seed` (the`OMEGA-SEED` gate: stage fixpoint,`seed/host/check.sh` and the IR comparison against the C oracles, no gate skipped). What it does not prove: the fixpoint is a same-lineage rebuild check, not diverse double compilation; the reference interpreter on`seed/omega-ref` predates this compiler source (it refuses a call to a function defined later, first at`fexp` ,`seed/omc/omc.om` line 935). Diverse double compilation is the separate gate`seed/qualification/ddc650/ddc.om` (PROPOSED, host EXERCISED, not in CI, not QUALIFIED;[omega#650](https://github.com/aien-dev/omega-mv/issues/650) ): the seed`om4` route and a GCC-built copy of the synced spec interpreter (`tools/omega_ref/omega_ref.c` on the unmerged`seed/omega-ref-sync` at 190130b7, pinned by SHA-256) each rebuild`omc.om` , and at`62d1d0d6` both reproduced`seed/out/omc` (`62775d2a` ) byte for byte while every negative control failed (2026-10-30, one AArch64 host, same project lineage; see[its README](https://github.com/drakestapleton/omega-mv/blob/main/seed/qualification/ddc650/README.md) ). The older`tools/omega_ref/gate_ddc.sh` PASS (omc`734f0a39` , 2026-10-24) exists only on that unmerged branch and does not describe the current compiler. GPU launch and model execution through these device words are not qualified. The language has bounded native recursion; a restricted importer does not describe the whole language. See[conformance and evidence limits](https://github.com/aien-dev/omega-mv/issues/624) .
- **Candidate x86-64 Linux backend (FR-9):** an initial`target x86linux` line selects x86-64 static ELF output for whole programs; no selector preserves AArch64 output. The backend is implemented in`seed/omc/omc.om` , not a C translation.[Design, ABI, provenance and qualification](https://github.com/drakestapleton/omega-mv/blob/main/docs/X86-LINUX.md) distinguish emulated execution from native x86 execution and the existing AArch64 seed chain. Bare x86 units use a private frame ABI, not the SysV C ABI; foreign callers still use omega-bridge. Merged as #923; status DRAFT. x86 execution so far is EMULATED (QEMU) only; native x86 execution and a native x86 seed0 chain are NOT_RUN. The last complete differential, at source`62d1d0d6` (2026-10-30,`seed/qualification/x86-linux/20261030-main-62d1d0d6.json` ), reported 15182 PASS, 0 FAIL, 2 NOT_RUN and 222 EXCLUDED; the two NOT_RUN cases are invalid-fd ioctl fixtures for which QEMU returns ENOTTY where native Linux returns EBADF. Its aggregate verdict remains FAIL because NOT_RUN is not PASS. This is not a hardware-qualified release.
- **Legacy OSC/C implementation on `main`:** OSC-0/1/2 and OSC-3 material describes the earlier implementation and unfinished migration, not the forward source-language path. The old Milestone 6 "self-host" result was a fixed-output self-copy check, not compilation ([historical note](https://github.com/drakestapleton/omega-mv/blob/main/docs/osc/OSC-1-SELF-HOST-STATEMENT.md) ); do not confuse it with the later seeded compiler work.
- **Reaction runtime:** the R1 to R16 qualification ladder passed on builds that predate the composition modules (omega#126), a historical result. Requalification at`3108fc2` recorded R15 FAIL (14 of 16 gates: G1, G15) and R16 FAIL (`evidence/REQUAL-3108fc2/` ); the R16 receipt`22d7a79a` at`850fc54` is invalid as a current claim because its script was later found defective; none of R1 to R16 is requalified on the current candidate, and the ladder rerun is in progress. The R16 loop-site inventory was reconciled on the candidate tree (502 sites, 0 unclassified, 0 stale, PR #279); that is the inventory gate only, not R16. The current living build is IMPLEMENTED / NOT QUALIFIED until re-qualified. Composition, Capability Graph, Skill Router, J-Space and Cortex run on the host; the Fabric interface is a host-only loopback with no network; none of this is on silicon as a qualified system.
- **Numerics (E1):** closed 2026-10-02 on the GB10 chip campaign (Gate 5 26/26 with 47 parity lines, reductions SUM/MAX/MIN/MEAN, nine transcendental ops over all 2^32 inputs each, 148 load/store kernels), consolidated receipt`evidence/E1-CLOSURE/e7851c69d34ac777a9436af16d0bdd5d69264c8528c62d562b600f5d89153061.json` . Natural-base EXP and LOG, the 2026-10-02 exclusion, now have GB10 kernels: on omega`cb6d201` all eleven E1 transcendental ops (the nine plus EXP and LOG) passed on the chip over all 2^32 inputs each with 0 mismatches (`evidence/E1-TRANSC-GB10/b2f4afe9…` ,`ae3a4123…` ,`d846fbe3…` ), and the M20 tensor GB10 tier passed 99 of 99 cases on`0919efc3` (`evidence/M20-TENSOR-GB10/a00b4178…` ); see[E1_GAP_TABLE](https://github.com/drakestapleton/omega-mv/blob/main/docs/numeric/E1_GAP_TABLE.md) , "Update, 2026-10-27".
- **Decode attention (OWN-30B):** one cache holds up to 131072 positions (128k context,`OMEGA_GPU_DATTN_MAX_POS` ). On the GB10 chip, contexts 65536, 100000 and 131072 match the double reference exactly (`evidence/dattn-maxpos-128k-20261018/` ); at those lengths the kernel streams K/V at about 57 GB/s, so long contexts are slower than the weights alone allow.
- **Qwen3.8-27B kernels (GB10, 2026-10-18):** each one is checked on the chip against a double-precision reference with deliberately broken variants that must fail, and none is joined into a serving engine yet. FP8 matrix-vector and the tensor-core prefill GEMM now take k up to 32768, which covers the 27B down projection at k = 17408 (`evidence/fp8-k32768-20261018/` , omega#541). The Gated DeltaNet decode step (the recurrent layer used by 48 of the 64 layers) runs as one launch per layer and matches the reference to about 2e-7; it takes 125.7 us per layer, which moves its 6.29 MB of state at 50.1 GB/s against 273 GB/s nominal (`evidence/gdn-decode-20261018/` , omega#542). The DeltaNet prefill reads a whole prompt in three launches per layer and hands its state to the decode step, which carries on exactly; at 2048 tokens it takes 3.80 us per token per layer, and the recurrent scan in it does about 2.4 trillion operations a second, against a chip peak for that kind of math that has not been measured yet (`evidence/gdn-prefill-20261018/` , omega#543). The full-attention decode step for the other 16 layers (24 query heads over 4 key-value heads, 256 numbers per head, rotation on the first 64 only, done by reordering the numbers once at load) runs as one launch per layer, matches the reference at each tested context (1, 7, 256, 301, 1024, 4096, 8192, 32768 and 131072 tokens) with all five broken variants caught, and at 32768 tokens of context takes 2.10 ms per layer, streaming its 134 MB of cached keys and values at 63.8 GB/s against 273 GB/s nominal (`evidence/QWEN38-DATTN256-8bb4494e-20261018/` , omega#544). The prefill attention for those 16 layers reads a 2048-token chunk of a prompt in two launches per layer and leaves cache rows bit-equal to the ones the decode step would have written; it matches the reference at every tested point up to 129024 + 2048 tokens with all four broken variants caught, and a 2048-token chunk takes 10.0 ms per layer at the start of a prompt and 591 ms at the end of a 128k one, streaming cached keys and values at 230.6 GB/s against 273 GB/s nominal (`evidence/pattn256-chip-20261018T1517Z/` , omega#545). Getting it to run found a bug every kernel shared: the encoder wrote the integer add, one compare and the exit instruction with a fixed timing word, so the waits the code generator scheduled on them never reached the chip. The encoder now keeps them,`make test-bw-encode-control` checks every instruction type, and 18 of 19 kernel families pass their chip tests with the fix (the ternary family fails only its speed gates, which the old encoder fails the same way on the same load;`evidence/encoder-fix-sweep-20261018T1512Z/` ).
- **Expert slots (Expert Ribbon, omega#533):**`src/omega_gpu_fp8_slots.h` keeps a fixed pool of FP8 expert slots that can be refilled while a model runs. A slot is hidden while it is rewritten, gets a new version only after the copy is complete, and cannot be rewritten while any launch or recorded command list still reads it. Shown on the GB10 at the slot commits a8ae3a1f and d8185686 on their 2026-10-18 bases (`tools/run_gpu_fp8_slots_chip.sh` , receipts in`evidence/RIBBON-SLOTS-*` ; not re-run on the current base): a slot gives bit-identical results to the same expert held resident, and the negative control (pins ignored) is caught. The SSD side and the model wiring live in aien-sovereign-core.
- **Hardware:** results on the DGX Spark GB10 are tied to the exact commit in each receipt. Host and emulator passes are never reported as hardware qualification.

The live status is owned by [aien-architecture-mv](https://github.com/aien-dev/aien-architecture-mv): [CURRENT_EXECUTION_PLAN.md](https://github.com/aien-dev/aien-architecture-mv/blob/main/CURRENT_EXECUTION_PLAN.md) and [doctrine/ROADMAP.md](https://github.com/aien-dev/aien-architecture-mv/blob/main/doctrine/ROADMAP.md). This file does not restate numbers that drift. Historical milestone receipts (for example Milestone 4, `OMEGA_SEMANTICS`, 12 of 12 gates) stay in `evidence/` unchanged as history.

- **FP8 expert launch in one wave (2026-10-24, L310, measured on the real chip):** the grouped expert GEMV used 6 CTAs per group, a value tuned on 8 groups; a 9-group model (the 35B, Qwen3.6-35B-A3B, a mixture-of-experts model with about 3B parameters active per token: 8 routed experts + the shared one) therefore launched 54 CTAs on 48 SMs, two waves, in each of its 80 expert launches per token.`AIEN_OMEGA_FP8_GROUPED_WAVE=1` sizes the launch to one wave (min(6, 48 / groups); 9 groups -> 5) and the 35B 1-row step measured 20.498 -> 19.347 ms, expert stream 160.5 -> 193.3 GB/s (N=3, chip time alone, not end to end through the server; receipts in aien-sovereign-core`docs/speed/Q36_CEILING.md` section 11, which is not on that repository's main yet:[commit 65444d38](https://github.com/aien-dev/aien-sovereign-core-mv/blob/65444d3810ddf691e3bffb3276ec4a39eef838fe/docs/speed/Q36_CEILING.md) ). These GPU kernels are C code in this repository, not Omega-language code (bar C1 in`docs/OMEGA.md` ). Off by default until the merge train has judged it;`AIEN_OMEGA_FP8_GROUPED_CTAS=n` forces an exact value.`gpu_fp8_api_test --sim` checks the rule table without the chip; the server prints the value it runs with at load.

- **SMART is not TRUSTED, INTELLIGENCE is not AUTHORITY.** Trust comes from verified invariants, never from capability.
- **Meaning is permanent; representation is disposable.** A program's`SEMANTIC_ID` (SHA-256 of the canonical encoding) names its canonical body, so respellings of one body (whitespace, parameter name, operand order) share it, but`x + 1 + 1` and`x + 2` do not. The separate`FUNCTION_ID` names the function: inside the polynomial fragment (`+ - *` and exact`and` /`or` identities modulo 2^w, w = 1..64) two programs get the same`FUNCTION_ID` exactly when they compute the same function; outside it the id falls back to the body and says so. Equality of arbitrary programs is undecidable, so no id is extensional for every program. Nodes, typed relations and receipt-backed equivalences form the graph of meaning ([spec/program-identity.md](https://github.com/drakestapleton/omega-mv/blob/main/spec/program-identity.md) sections 9-10,`om/meaning/` ; host-exercised, not yet wired into the C library or Visor).
- **Pure computation is separate from effects** , and effects need capability-bounded, receipt-producing transactions.

Ownership rule ([ARCH-0042](https://github.com/aien-dev/aien-architecture-mv/blob/main/docs/adr/0042-omega-cudapp-bridge-ownership.md), Accepted by Drake 2026-10-30, merged as [aien-architecture-mv#342](https://github.com/aien-dev/aien-architecture-mv/pull/342)): Omega owns computation, CUDA++ owns GPU execution, Omega Bridge owns compatibility.

- **This repository** owns the language, its semantics and IR, the seeded compiler (`seed/out/omc` ) and the compiler pin other repositories consume, and the declared contract of what a kernel computes.
- **[CUDA++](https://github.com/aien-dev/CUDApp)** owns GPU execution: the sm_121 encoder and GPU code generators, the cubin writer, the disassembler, the driver client, submission and the GPU runtime.
- **[Omega Bridge](https://github.com/aien-dev/omega-bridge)** owns compatibility: C and Python emitted from a checked Omega subset, native bindings so foreign callers call compiled Omega (pinned here in`om/omega-bridge.lock` ), framework attachments and GPU artifact negotiation. It does not compile Omega for other repositories and does not run kernels.

Not yet true on main: the GPU C under `src/omega_blackwell_*`, `src/omega_gpu_*` and `src/omega_sm121_disasm.c` is a diverged copy of CUDA++ code that is still developed here, and the driver client comes from physics-mv. Existing code stays where it is (Drake, 2026-10-27); new GPU-execution work goes to CUDA++ or a repository connected to it. The copies are recorded in [CUDApp#106](https://github.com/aien-dev/CUDApp/issues/106), [CUDApp#107](https://github.com/aien-dev/CUDApp/issues/107), [CUDApp#108](https://github.com/aien-dev/CUDApp/issues/108) and [CUDApp#10](https://github.com/aien-dev/CUDApp/issues/10). The bridge's own seed bootstrap and front end are [#870](https://github.com/aien-dev/omega-mv/issues/870) and [#871](https://github.com/aien-dev/omega-mv/issues/871).

[aienux](https://github.com/aien-dev/aienux) holds Aienux, the kernel of AienOS, which Omega is meant to run on. [physics-mv](https://github.com/aien-dev/physics-mv) provides FORGE machine realization and the GB10 native path (pinned in `physics.lock`). [aien-architecture-mv](https://github.com/aien-dev/aien-architecture-mv) owns status and sequencing. ARGUS-0/1 (a defensive plane) is implemented in aienux (`native/argus`, pinned by `argus.lock`); Omega only carries the opt-in `RX_ARGUS` hooks (`src/runtime/rx_argus.c`) and receipts in `evidence/ARGUS/`. Physics Zero exists here as a host benchmark apparatus and learner (`src/physics0/`, `tests/physics0/`, `mk/physics0-learner.mk`, `docs/physics0/`, receipts in `evidence/physics0/`), with its specifications in the physics repository. DIRAC-0 is a specification in aien-architecture-mv plus an oracle source in `research/dirac-oracle/` that has never been built or run. The Evolution Arena is a plan only.

Child repositories pin an omega-mv commit and the sha256 of the `omc` it births: [omega-gpu-driver](https://github.com/aien-dev/omega-gpu-driver) is the GB10 GPU driver in seeded Omega (W0 bind/read/release over VFIO via `vfioctl`/` vfiomap`; exercised in QEMU, not hardware-qualified).

Language rule: `.om` is the only forward first-party implementation language. Implement and qualify each replacement, switch its actual consumers, then remove the superseded first-party source and obsolete build/runtime dependencies from the active tree. This includes compiler/runtime code, services, tools, automation and project-owned tests; C/Rust/shell remaining today are unfinished migration, not permanent exemptions. Preserve Git history and immutable evidence. External protocol formats, generated machine code, device firmware and independently sourced qualification oracles have separately declared roles; they must not conceal a foreign implementation of Omega. See the [replacement/deletion contract](https://github.com/aien-dev/aien-architecture-mv/issues/300).

Preserve the native GPU work and its explicitly recorded OS/driver dependencies; do not infer hardware or OS independence from removal of a userspace library. No systemd. Offline, in-house builds. Never overwrite failed experiments or old receipts. Verdict words: PASS, FAIL, NOT_RUN, BLOCKED_HARDWARE, BLOCKED_OPERATOR, MISSING_IMPLEMENTATION.

These are **C/legacy compatibility checks**, not commands for the seeded `.om` compiler. The seeded compiler is rebuilt and qualified with `sh seed/omega-from-seed.sh` and `tests/gates/run.sh seed` (see `seed/README.md`); do not mix compiler binaries or relabel old receipts.

Needs gcc and make on an AArch64 Linux host: CI runs the host suites on `ubuntu-24.04-arm`, and `test-realize` compiles with `-march=armv8.6-a+dotprod+i8mm+sve`. Host suites need no GPU and no physics checkout:

```
make PHYSICS_DIR=/nonexistent PHYSICS_LOCK_CHECK=0 test-compiler-quick   # compiler, quick suite
make PHYSICS_DIR=/nonexistent PHYSICS_LOCK_CHECK=0 test-numeric-cpu      # E1 CPU numerics
make PHYSICS_DIR=/nonexistent PHYSICS_LOCK_CHECK=0 test-realize
```

The full omegatool build (`make`) links the `physics` repository at the commit in `physics.lock`. Some older milestone gate scripts rewrite their receipts in place, so do not run them on a clean checkout you mean to keep; prefer the `make test-*` targets above. Some GPU suites build against physics but still open no device: `make test-gpu-decode-graph` checks the decode graph's glue kernels and, on a fake platform, that a failed or abandoned decode token always gives the GPU session lock back (shown on the fake only; the real-chip decode run is `tools/run_gpu_decode_graph_chip.sh`). Targets that touch the GB10 need the DGX Spark, run one at a time, and are never killed mid-run. The M19 clean-clone gate rebuilds the tree in a temporary directory and runs the milestone gates there; when that nested build or nested run fails, it now prints the tail of its own log to stderr, so a failure names its cause instead of reporting a bare FAIL. CI definitions in `.github/workflows/` list the suites that run on every push.

`make test-bw-hazard` (host only, links `libomega_gpu.a`, so it needs the physics checkout like `make`) reads the encoded bytes of every GPU kernel the generators build and checks the scoreboard waits: a register written by a load must be waited on before it is read, and a register a queued load or store still reads must be waited on before it is overwritten (omega-mv#554). The simulators do not model these waits, so this is the host check that would have caught the omega-mv#545 chip fault. Known findings on older kernels are listed, with how each was confirmed, in `tests/bw_hazard_test.c`.

Host checks on the shared Spark judge, whose 1-minute load average is rarely below 2, keep every
check they had and never turn load into a pass. `tests/runtime/r11_own_hold_test.sh` raises the R11
load limit for its own runs (`R11_LOAD_LIMIT`, which can only raise it) and judges the quiet-flag hold
decision the program prints; the living run's speed checks are judged there only when the load
average is at most 2. The speed checks (the action-graph 2x speedup in
`tests/runtime/rx_action_graph.c`, workflow fusion) take their median over the repetitions the
machine did not disturb (run-queue delay from schedstat, `tests/runtime/rx_quiet_reps.h`); when too
few are undisturbed the check reports `NOT_RUN` with reason `cpu_busy`, and `tests/gates/run.sh`
reads that refusal from the receipt, runs the rest of the step and ends it NOT_RUN. Omega's serve
cost is the CPU time of the serving thread (`cost_ns` in `src/runtime/rx_omega.c`), not wall-clock
time, and the R15 parity rig gives both sides a fixed cost table (`r15_use_cost_model`).

`src/` existing core and C compiler awaiting replacement (`src/compiler/`), `src/runtime/` reaction runtime, `src/fabric/` host-only fabric interface, `src/physics0/` Physics Zero apparatus, `spec/` and `docs/` specifications, `tests/` gate suites, `evidence/` content-addressed receipts, `tools/` harnesses, `mk/` make fragments included by the `Makefile`. Also `bench/prime_race/` (Prime Drag Race implementation), `calibration/` (Turing calibration experiments, preregistration and blinding protocol), `research/` (experiments and prototypes) and `doctrine/` (the Milestone 4 doctrine).

Development follows Human-Directed Agentic Engineering (HDAE): humans define goals, architecture, constraints, acceptance criteria, and stopping points; agents implement, execute checks, diagnose failures, and revise within those boundaries. Human review retains responsibility for claims, acceptance, and release decisions.

For the documented method and a systems-software case study, see Gregory M. Kurtzer, [*Ginux: Building an Independent Kernel That Runs Linux Userspace through Human-Directed Agentic Engineering* (2026)](https://doi.org/10.5281/zenodo.23682548). This is a method citation, not a change to authorship or the qualification of earlier experiments.

Open a pull request with the exact command you ran and its output. Receipts are content-addressed, name the exact commit and refuse a dirty tree. Do not edit existing evidence in place. External review is expected before merge. See [CONTRIBUTORS.md](https://github.com/drakestapleton/omega-mv/blob/main/CONTRIBUTORS.md). Contact: [aien@aienos.com](mailto:aien@aienos.com).

This repo used the Crumb Protocol (RFC-0001): each directory carries a `.crumb` file (what the directory is for, its rules, and a backfilled history). Crumbs are retired from the active workflow (DRA-97, 2026-11-07): no gate or workflow checks them, and reading, writing or refreshing a crumb is not a step of any change. The `.crumb` files stay as history.
Backfilled history (marked as such, not live whispers) is in `docs/crumbs/BACKFILL.md`.