One persistent coding agent task built a bootable x86-64 kernel in eleven days. It is called Ginux, it is Rust-first, and it boots through UEFI, runs selected unmodified Alpine Linux programs, and carries a Rocky Linux 10 userspace with systemd all the way to multi-user.target.

That last item is the one to sit with. multi-user.target is the systemd state that means a normal booted machine, the state where services are up and you get a login prompt, not a rescue shell and not a demo that prints a few characters and halts.

The report behind it is blunt about what that does not mean. No production readiness, no Linux equivalence, no independent security audit. The author is Gregory Kurtzer of CIQ, he published it on Zenodo on October 27, 2026, and he is not selling a kernel. He is selling the governance model that made an eleven-day autonomous build reviewable at all.

We covered rule enforcement at the file level in "Your AGENTS.md Is Hope at Scale: Only 3.7 Percent of Agent Rules Name the Check That Enforces Them." That piece audited whether individual rules name their enforcement check. This is the level above it. Gates and stopping points for a whole build, not single rules.

WHAT THE AGENT ACTUALLY BUILT

The numbers first, because they set the scale. At the evaluated commit there are 1,037 commits across eleven calendar days, 261 tracked files, 63 Rust source files, and 138,790 retained lines of implementation and test code once generated payload is excluded. The repository also carries 13,074 lines of Markdown documentation.

The plan lived outside the conversation. Architecture and plans persisted as versioned documents, with a compatibility ledger recording syscall and non-syscall behavior, plus a working goal, use cases, and a decision record. When the agent's context drifted, the specification was on disk, not in a chat window that might get compacted.

The target was not just a kernel. It was a single GINUX.EFI image containing the kernel, the x86-64 assembly, boot-critical facilities, an embedded controller, and recovery metadata. No separate bootloader, no initramfs, no host root filesystem to reconcile. UEFI loads a PE32+ application with all of its sections through LoadImage(), so an operating system can arrive as one large payload instead of growing through a chain of bootstrap loaders. Ginux uses that to make the kernel, the controller, and the initial authority measurable as one image before execution.

The controller is the part worth understanding. It is packaged inside the kernel image but mapped into ring 3 as an ordinary process. Packaging controls how its bytes arrive. The processor ring controls its privilege. It does not bypass the kernel for privileged work; it sends versioned management requests through a control interface, and the kernel validates capability and ownership before performing anything protected.

Memory management, scheduling, a process model, filesystems, networking, devices, and a Linux personality are all in there. Isolation is a kernel object called a domain, broader than a namespace or an OCI container, owning address spaces, process trees, capabilities, mount views, devices, limits, and failure policy. OCI supplies a domain's initial filesystem. Ginux supplies the isolation. Capabilities are tagged with a domain generation, so a crashed service can be quiesced, revoked, and replaced without its successor inheriting the same security identity.

Here is the honest column. The ledger classifies all 375 Linux 6.12 x86-64 syscall numbers, and only 82 are recorded as complete. 245 are partial, 48 are policy-denied. There is no GPU stack, no broad hardware matrix, no stable third-party driver ABI, no native performance baseline, and no independent security audit. The report states that plainly and I will repeat it: this is a research prototype demonstrating rapid integration of established mechanisms.

An unverified artifact is a demo. A gated artifact is a deliverable. The difference is the rest of this article.

THE FIVE GATES OF HUMAN-DIRECTED AGENTIC ENGINEERING

The named framework is HDAE, Human-Directed Agentic Engineering, and it is five human-defined gates wrapped around one autonomous loop. The gates are the part you can copy on Monday.

Infographic titled Five Gates, One Controlled Agent, showing five numbered gates labelled Architecture, Constraints, Milestones, Acceptance and Stopping Points arranged around a circular AI Agent engineering pipeline and a glowing Kernel artifact, with arrows leading to a green Completed Artifact panel and a red Process Stopped panel
Five human gates wrapped around one autonomous loop.

Gate one is architecture. The human owns the shape and the agent fills it in. Kurtzer wrote the boot model, the kernel and userspace boundary, the domain concept, authority, storage, devices, and the acceptance criteria before the loop started. Codex chose implementation details inside that shape. The report is explicit that the agent also proposed mechanisms, including generation-tagged capabilities, copy-on-write handling, and pre-authorized shared-page paths, and that those stayed subject to architectural review. A proposal passes through the gate. It does not become architecture by being written.

Gate two is constraints. What the agent may not touch, defined before the loop starts rather than after the first incident. The compatibility ledger is the mechanism here. Every syscall number is classified as complete, partial, or policy-denied, so a passing test cannot quietly expand the claimed surface. The agent could add behavior. It could not relabel the boundary.

Gate three is milestones. Six overlapping stages, each ending in an observable gate: boot and architecture, kernel mechanisms and hardware, userspace control, Linux execution, distribution ingestion, compound system boot. A printed success message never completed a stage on its own. Firmware entry preceded hardware control, a bounded ELF probe preceded general Linux process behavior, and Alpine preceded glibc-based Rocky. Eleven days without milestones is eleven days of unauditable motion.

Gate four is acceptance criteria. A test the artifact must pass to count, and machine-checkable wherever possible. Booting Rocky systemd to multi-user.target was one. The performance gate was the interesting one: when the first sysbench numbers came back catastrophic, the human did not accept them as a limit. He fixed the scope to single vCPU, defined the gate as closing the gap without weakening correctness, and handed the profiling back to the agent.

Gate five is stopping points. Pre-declared conditions where the loop halts for a human. This is the gate most teams skip, and it is the one that turns a runaway agent into a paused one. In the report, work stopped when the research questions had a demonstrable system, documented evidence, and explicit remaining gaps, not when the prototype became production-ready. That is a stop condition written before anyone could rationalize continuing.

The rule to keep: an agent loop is safe exactly to the extent that its failure states were named before it started.

THE LOOP BETWEEN THE GATES

Inside the gates the cycle is mundane. Implement, build and boot under QEMU, measure and analyze failure, revise, run the regression test. The agent is never idle, and it is never ungated.

What makes that more than a slogan is the harness. Repository scripts launched headless x86-64 QEMU on the Mac, injected controller commands, captured serial output, enforced timeouts, checked expected markers and failure conditions, and shut the emulator down. The agent could run that loop itself, read the logs, change the system, and repeat. Without an executable gate, a long agent run is a long conversation with a compiler attached.

The distinction that matters is model versus harness. This was not a model talking to itself in a chat window; every step ended in an exit code, a serial log, or a benchmark number, and none of those three can be talked into agreeing. The harness is the product. The kernel is only what the harness allowed the agent to prove.

The performance work is the clearest proof. First results had memory throughput at 48.390 MiB/s against Rocky's 679.510, and thread throughput at 0.078 events per second against 306.129. Neither number was a slow kernel in general. The memory failure was timestamp overhead, because the one-kibibyte workload crossed into the kernel on every clock read and Ginux had no vDSO. The thread failure was the scheduler repeatedly selecting a just-preempted supervisory thread and saving a complete user context when no other thread could run. Adding a Linux-compatible vDSO and a read-only vvar page, then making that snapshot immutable per execution image and replacing clock division with fixed-point conversion, moved threads to 309.732 events per second and memory to 620.580 MiB/s.

Those are defect classes that a benchmark found and a gate closed. Not a model getting smarter.

The counterexample is the asset flip. A developer essay on HyperTesto uses fifteen years of videogame history to name the failure mode: when generation is cheap, the promise becomes the product, and the missing work is the integration, tuning, and maintenance that nobody budgets for. The five gates are the direct countermeasure, because they force that unglamorous work to be named before the loop starts instead of discovered after the demo.

Independently, people keep landing on the same shape. samir-vllm is a from-scratch C++17 and CUDA inference engine published with more than 85 pages of handwritten notes and six or more hours of video walkthroughs, the author stating the notes were written without AI assistance. mintigate-demo is a control layer built around scoped changes, approval boundaries, and audit records, and its repository says outright that it is a simulated agent with no live model. Different people, different projects, one conclusion. The durable artifact is the constraint surface, not the output.

WHAT ELEVEN DAYS DOES NOT PROVE

It does not prove that agents can ship production kernels, and the author does not write it that way.

The limits are specific, and they are the credibility spine of the piece. Compatibility is partial by the ledger's own count. The performance evidence is exploratory: three-second sysbench workloads, nine samples per system, a single vCPU, cross-architecture QEMU translation on an Apple Silicon host, and two userspace profiles that are not equivalent. Read that caveat sharply, because systems people will: QEMU's Tiny Code Generator translated x86-64 instructions for an ARM CPU without hardware virtualization, and translation cost is not uniform. It weighs differently on a tight clock and syscall loop than on bulk memory copies, so these medians diagnose defect classes and do not transfer to bare metal or KVM. The CPU difference of 15.2 percent in Ginux's favor sits inside what emulation variation and background work could produce. The startup comparison, 12.860 seconds against 42.579, measures two different boot paths, including work one path skips entirely.

At the evaluated commit, make check passed and the aggregate make test target did not, because a post-execve() system-supervisor lifecycle probe still failed. That known failure is part of the checkpoint, and it is the sort of detail that tells you the author is reporting rather than promoting.

There is no matched human-only project, no alternative-model run, no independent reconstruction from the original requirements. The same person wrote the architecture and judged whether the observed behavior was acceptable, which is informed judgment carrying evaluator bias. Provider-exported token totals were not archived. The API cost of roughly 8,000 dollars is author-reported, and divided across eleven days that is about 727 dollars a day, or 30 dollars an hour across 264 hours. That arithmetic is mine, not his, and it describes an experiment, not a productivity measure.

So what carries over to a reader who will never write a kernel? The report's own stated contribution. The same loop applies to any large, test-gated software build. A small change fits inside one bounded issue and one regression test. A large program needs architectural milestones like these. A greenfield project has to write its specifications and its harness alongside the code. An established project starts with interfaces, tests, and review practice already in place, then adds gates for a bug reproduction, a compatibility requirement, a performance threshold, or a security property.

Which leaves the reviewer's question that matters. If your agent's current task ran for eleven days unsupervised, what would you be able to verify at the end? If the answer is that the tests pass, ask who wrote the tests, and ask whether the agent was free to edit them.

WHAT TO DO TODAY

  1. Write the five gates down before your next long agent task: architecture, constraints, milestones, acceptance criteria, stopping points. One page is enough.
  2. Make at least one acceptance criterion machine-checkable, so the agent can gate itself instead of waiting on your calendar.
  3. Name two stopping points you would actually honor: a budget exceeded, a milestone missed twice, a diff that touches a declared constraint.
  4. Audit your last agent build and write down which of the five gates existed. The gap list is your retrofit plan.
  5. Read the Ginux report's limits section before its results section. That order is the lesson.

THE UNCOMFORTABLE QUESTION

Your agent can work for eleven days straight and never get tired. Your oversight process is still sized for a human who needs lunch, and a sign-off nobody could reconstruct afterward is not oversight. So treat the next question as governance, not scheduling. If this build reached production, who could produce the gates, the acceptance tests, and the record of what stopped it? Until someone can, the schedule you are keeping is the agent's, and the review you are claiming is the part you are pretending to do.

Enjoyed this article?

☕ Buy Me a Coffee

Support PhantomByte and keep the content coming!

Build Real AI Infrastructure

PhantomByte teaches you to build real AI infrastructure yourself: local AI stacks, autonomous agents, multi-agent orchestration, web scraping, and custom tools. Step-by-step PDF tutorials you download, follow, and deploy. No subscriptions. No fluff. Just skills that ship.