Skip to content

Releases

INIT v0.6.0-preview

Choose a tag to compare

@nagisanzenin nagisanzenin released this 11 Nov 04:38
Immutable release. Only release title and notes can be modified.

2026-11-11 · research preview · macOS (Apple silicon) and Linux x86_64 (experimental)

v0.6.0 is a large release. It holds the v0.5.7 backlog, a reasoning-effort choice per model, providers v2 (a
signed model catalog with prices, a credential store, more wire formats and auth kinds, local model servers) and
Sign in with ChatGPT as a preview. It replaces the planned v0.5.7: what v0.5.6's notes said v0.5.7 would do ships
here. Linux aarch64 has no bundle in this release, as in 0.5.x.

Live testing, plainly. Every new provider, wire format and auth flow in this release was tested against recorded
or doc-derived fixtures and mock servers on this machine. /model marks each model that has no live run on this
release not live-tested, from the catalog's per-row wire_verified. DeepSeek's three wire formats (Chat
Completions, Anthropic Messages and OpenAI Responses at DeepSeek's own host) ran live on the fourth candidate, whose
Root, kernel sources and prebuilt body the release bundle carries unchanged (Verified for this release): every
check passed on all three except one, Chat Completions' re-send for a refused request without its reasoning, which
could not run because DeepSeek does not refuse it, so the live check's verdict is FAIL (Not verified). OpenAI's
gpt-6.1-sol was not live-tested for this release (no OpenAI key at release time; last live-qualified on v0.5.4,
2026-10-30) and ships marked not live-tested. Sign in with ChatGPT was not exercised with a real sign-in for this release (it needs the owner in a browser); covered by tests against the mock's OAuth mode only (Not verified).

Reviewed the day of the release, four times. On 10 Nov four rounds of independent adversarial review read the
release's code, each one the fixes of the round before. Together they found 3 blockers, 35 should-fixes and 65 notes.
Every blocker and should-fix was fixed the same day, with a test that fails without its fix wherever a test can show
it, except one that the tag itself settles: three catalog rows marked as tested live before this release's live runs
keep that mark only with a live verdict from this release. The notes left open are under Limits, plainly, with what
they cost. What the rounds found is in "Found the day of the release", below.

Then a first candidate and two user sessions. The release's first candidate bundle went to two agent-run user
sessions. The returning user's said ship. The new user's said do not ship, for two reasons: the first self-change
waited 31 minutes before its first check, for INIT's background dependency build, with nothing on screen saying why;
and /panic during that change's checks left its build running on macOS and told the user to end it. Both are fixed
in this release. The wait's fix and the /panic fix were each read by two rounds of independent review, and every
blocker and should-fix of those rounds was fixed; what was deferred is under Limits, plainly, with its cost. A final
round then read every change made in answer to those reviews and to the user sessions, the pause fix's second commit
included, and the same reviewer then read the two fixes made in answer to it (one in the Root, one in init-agent):
both sound; the last fix, to the agent's test code (Fixed, below), was read too. So every product change in the
release's code has been read by an independent reviewer at least once. A
second new-user session, on the second candidate, said ship, but it met neither the wait panel nor a panic
during a gate. An operator then checked both on the fourth candidate: the wait panel appeared and said what was true,
though its times were 2–4 times too long, and /panic during a check left nothing of the agent running (Verified for
this release). What the sessions found and this release did not fix is in "From the user sessions", below.

Install

curl -fsSL https://github.com/nagisanzenin/INIT-Agent/releases/latest/download/get.sh | sh

Then open a new terminal and run init-agent. --no-modify-path (sh -s -- --no-modify-path) leaves your startup
files alone; in the terminal you installed from, ~/.local/bin/init-agent works at once.

  • The PATH block of a fresh v0.5.4 install (it puts ~/.local/bin first) now gets a WARNING block at the end of
    every install, re-install and upgrade: the file, the line number, the line, and the line to change it to. INIT never
    edits a startup file for it. The new init-agent doctor shows the same rows, read-only, and exits 1 when one needs
    you.
  • A source install takes rustup's Rust 1.97 for this machine, whatever your default toolchain is, and never
    changes your default. get.sh installs 1.97.1-<this machine> by its full name (an x86_64 rustup on Apple silicon used
    to get the x86_64 toolchain, and the install fell back to T0); without a 1.97 toolchain, install.sh stops with the
    exact rustup toolchain install … command; init-root toolchain --set looks for the same toolchain first.
  • When ~/.local/bin is already on your PATH before /usr/bin, through a line that is not INIT's, the install
    writes no block and now says so with a WARNING (the stock ~/.profile of Ubuntu and Debian does this whenever the
    folder exists, and so do pipx and uv). On Linux the same WARNING says "from your next login" when the folder is not
    on PATH yet but such a login file will put it first once the install has created it, which is the default case on
    a fresh Ubuntu or Debian account. See Limits, plainly.
  • On Ubuntu, a curl installed from snap cannot write into the hidden folder get.sh downloads to. get.sh now says so
    before the download, with the fix (sudo apt install curl).
  • Which Rust INIT uses is said once. With --no-rust, get.sh says "this run installed no Rust (--no-rust)" and
    points at the install's "Rust for INIT" line, which names the Rust INIT will use (for example "Rust for INIT: rustc
    1.97.1 … (self-evolution T0+T1+T2)", or "no Rust toolchain (self-evolution T0 only)"). get.sh's total says "Rust
    install skipped (--no-rust)". Before, "no Rust installed", a found rustc and "Rust none" could appear in one run.
  • The install's summary says when the first self-change may wait, whenever a Rust toolchain is recorded (a fresh
    install, or an upgrade that keeps one): "Self-changes: if INIT needs to build its dependency cache (on a fresh
    install, and after an upgrade from v0.5.6 or older), it does so in the background about 2 min after the Root starts
    (2 compiler jobs, about 15-33 min on a Mac, a rough estimate). A self-change asked for while that build runs waits
    for it, and the checks panel says so; one asked for before it starts builds the dependencies itself." On Linux the
    band reads "about 21-46 min on Linux".

The release key's fingerprint is SHA256:IS7wIWkppZkHSUwdnsJR+K4fBPkmPa/IJwfNi9sIoMs, the same key 1 as v0.5.3 to
v0.5.6. The model catalog is signed with the same key, under its own namespace (init-catalog). To check a download
by hand, see Release signing.

Upgrade

  • First, if you run the Root in a terminal of its own instead of as a service, stop it there (Ctrl-C). The
    upgrade refuses until you do, and changes nothing. From v0.6.0 that Ctrl-C also writes a stop record to the
    lineage. The terminal shows "init-root: the Root and the agent stopped. Start the Root again: …" with the command
    for this Root; it does not mention the lineage.
  • From 0.5.6, 0.5.5 or 0.5.4: ~/.local/bin/init-agent upgrade.
  • From 0.5.1, 0.5.2 or 0.5.3: /usr/bin/env -i HOME="$HOME" ~/.local/bin/init-agent upgrade. Those releases'
    init-agent upgrade reads INIT_ROOT_HOME from your shell's environment, which a full-access agent can set through
    your startup files, so start this upgrade from a clean environment.
  • From 0.5.0 or 0.4.1, once, from your own shell:
    /usr/bin/curl -q -fsSL https://github.com/nagisanzenin/INIT-Agent/releases/latest/download/get.sh | /bin/bash -p -s -- --upgrade
    With a custom INIT_ROOT_HOME, put INIT_ROOT_HOME=<that directory> before /bin/bash; get.sh prints the line
    filled in.
  • Before 0.4.1: uninstall with the line get.sh prints, then install fresh.

The install matrix ran each of these lines on this release's bundle, on macOS: 14 of 14 rows passed (fresh, and 0.3.1
to 0.5.6), with the bundle read from a file instead of the release page, which holds it only once published (the
published assets are checked right after). No gate ran an upgrade on Linux (Not verified).

What the upgrade keeps, and what it changes:

  • Your bills do not change. Every charter before v0.6.0 prices its own models, and those prices are what the Root
    bills with, to the micro-dollar: a test compares the new meter with v0.5.6's on 12,000 random usages of each of the
    six preset models and 1,000 of each of 40 random tariffs. The same holds for routing: a v0.5.6 charter routes 3,060
    test requests exactly as v0.5.6 did. So DeepSeek is still billed at its peak price around the clock on an existing
    charter; the catalog's off-peak price applies only to a model the charter lists without a price (Providers v2,
    below).
  • Your keys stay where they are, in 0600 files, and are found without re-entry. The keychain is opt-in (Limits,
    plainly).
  • Your model runs at the same reasoning effort. With no effort line, the six v0.5.6 preset models keep v0.5.6's
    defaults: DeepSeek's two models and Claude Opus 5.5 and Sonnet 5.5 at high, gpt-6.1-sol and gpt-6-astra at medium.
  • gpt-6.1-sol's requests gain one field, "reasoning": {"context": "all_turns"} (OpenAI's documented setting for
    the model), and nothing else changes in them.
  • The first self-change after the upgrade builds the dependencies once more, because the cache's key changed,
    unless the new background build has already done it (Self-change checks...
Read more

INIT v0.5.6-preview

Choose a tag to compare

@nagisanzenin nagisanzenin released this 01 Nov 16:44
Immutable release. Only release title and notes can be modified.

2026-11-01 · research preview · macOS (Apple silicon) and Linux x86_64 (experimental)

v0.5.6 is a hotfix. The review after v0.5.5 (release protocol §7.5) found that v0.5.5's sandbox fix closed one route
to the files it protects and left another open: on macOS a full-access agent could clone a folder above a
protected path, and the copy was readable. v0.5.6 closes it. Everything in
v0.5.5-preview still
applies, except where this page says otherwise; that page now says what it overstated. E2, L5 and M #1, planned for
v0.5.6, move to v0.5.7. Linux aarch64 still has no 0.5.x bundle.

Install

curl -fsSL https://github.com/nagisanzenin/INIT-Agent/releases/latest/download/get.sh | sh

Then open a new terminal and run init-agent. --no-modify-path (sh -s -- --no-modify-path) leaves your startup
files alone; in the terminal you installed from, ~/.local/bin/init-agent works at once.

Upgrade

  • First, if you run the Root in a terminal of its own instead of as a service, stop it there (Ctrl-C). The
    upgrade refuses until you do, and changes nothing.
  • From 0.5.5 or 0.5.4: ~/.local/bin/init-agent upgrade. The launcher upgrades only the home it was installed
    for, and hands the upgrade to the kept get.sh with only HOME, that home and the system PATH.
  • From 0.5.1, 0.5.2 or 0.5.3: /usr/bin/env -i HOME="$HOME" ~/.local/bin/init-agent upgrade. Those releases'
    init-agent upgrade reads INIT_ROOT_HOME from your shell's environment, which a full-access agent can set through
    your startup files, so start this upgrade from a clean environment. get.sh prints this line, with your home filled
    in when it is not ~/.init-root.
  • From 0.5.0 or 0.4.1, once, from your own shell:
    /usr/bin/curl -q -fsSL https://github.com/nagisanzenin/INIT-Agent/releases/latest/download/get.sh | /bin/bash -p -s -- --upgrade
    With a custom INIT_ROOT_HOME, put INIT_ROOT_HOME=<that directory> before /bin/bash; get.sh prints the line
    filled in.
  • Before 0.4.1: uninstall with the line get.sh prints (v0.5.5's notes, The installer and the uninstaller), then
    install fresh.

An upgrade never edits your startup files; only a fresh install does. That includes a PATH block from a fresh
v0.5.4 install,
which puts ~/.local/bin first. Neither the upgrade nor a re-install edits it or adds a second one.
Instead the upgrade names the file and prints the line to change, for example:

  note: ~/.zshrc puts ~/.local/bin first on PATH (INIT's block from v0.5.4); INIT now adds it last, so a command you type is the system's, not a file an agent dropped there. To change it, make the block's middle line: export PATH="$PATH:$HOME/.local/bin"

The release key's fingerprint is SHA256:IS7wIWkppZkHSUwdnsJR+K4fBPkmPa/IJwfNi9sIoMs. To check a download by
hand, see Release signing.

The sandbox: a cloned folder

v0.5.5 stopped a full-access agent from renaming, swapping or removing a folder above a protected path (INIT's
launchers in ~/.local/bin, the provider key files in ~/.config/init-agent, ~/.init-release, ~/.init-root, the
Root's LaunchAgent and every read_deny entry). But macOS can also clone a folder (clonefile(2), what
cp -c and Finder's Duplicate use on APFS): one call makes a copy of the folder and everything in it. Seatbelt checks
a clone against the folder it copies, and no rule of INIT's denied cloning, so tested with INIT's real v0.5.5
profiles a full-access agent could:

  • clone ~/.config to ~/cfgcopy and read ~/cfgcopy/init-agent/<provider>.key;
  • clone ~/Documents and read a read_deny entry inside it, clone ~/Library and read the Root's LaunchAgent, or
    clone your whole home and read ~/.init-root and ~/.init-release.

Full access has the network, so a key read this way could leave your machine. In workspace mode the same worked for
a protected path inside the start folder: with ~/Library/Application Support as the workspace, cloning the folder
above Chrome's profile made its cookies readable. The kernel's own profile could clone ~/.init/run and read other
instances' marks. This predates v0.5.5; v0.5.5's notes said these reads were closed, and only the rename was.

From v0.5.6, a folder above a protected path cannot be cloned either, in full and workspace mode and in the
kernel's profile. Cloning anything else, and cloning single files (also those next to a protected path, such as a
file of your own in ~/.config), works as before. The rule is a word on the lines v0.5.5 added, so starting a sandboxed command costs
the same as in v0.5.5 (workspace profile, median 172 ms before and 178 ms after on the same machine).

The Root: no link followed into a sealed run

The same review found, by reading the code, that the Root's sealed runs (the twin and the audits) copy the body's
starting files (GENESIS.md, SELF.md, self.json, skills/) out of ~/.init/lineage/trees/, which the kernel's
profile may write, with copies that follow links. A link planted there could have made the Root, outside the
sandbox, copy a file of its own (a key under ~/.init-root) into a sealed run's folder. No test showed it reached
the agent. From v0.5.6 those copies open each file without following links, refuse a linked folder, and copy
skills/ with its links kept as links. This predates v0.5.5.

Known limits

The known limits of v0.5.5 still hold, except the clone above. Two of v0.5.5's statements are narrower than they read:

  • The PATH block puts the system's commands first only when INIT writes it. When ~/.local/bin is already on
    your PATH (other installers, such as pipx's or uv's, add it, often first), the installer writes no block and
    prints nothing, so a command you type may still be found in ~/.local/bin first. In full access the agent can
    write files there and edit your startup files anyway; workspace mode keeps it out of both.
  • The uninstall line runs the uninstaller on main, downloaded without a signature check (the install checks
    its download; the uninstaller does not). This predates v0.5.5.
  • The sealed run's copy checks the tree folder, then opens the files in it. A link swapped in for
    ~/.init/lineage/trees/<sha> between the two would still be followed. That needs winning a short race while the
    Root places a sealed run's starting files, and the run's sandbox could not read what was copied; v0.5.7 opens the
    folder once and copies from it. This predates v0.5.5.

Verified for this release

Everything below ran at $0 on the mock model; nothing in this release was run against a live provider. The full
record is REL-056. The tagged code is
930e354 in the development repository (the commit the bundles' latest.json names); the commits after it change
docs and records only.

  • The clone fix, with INIT's real composed profiles on macOS: the 25 clone cases that leaked in v0.5.5 (by path
    with clonefile, and by descriptor with fclonefileat and clonefileat) are refused in full mode, workspace mode
    and the kernel's profile; clones beside a protected path, an editor's atomic save, git and cargo work as before; a
    test fails if any read-denied path lacks the clone rule on the folders above it. An independent review tried
    copyfile, ditto --clone, exchangedata, hard links, snapshots and the /System/Volumes/Data paths too, all
    refused.
  • macOS arm64 bundle (930e354, sha256 ad8b4a7b…):
    • install and the first reply pass, and so does the source install (release-e2e);
    • a self-change of the compiled core through G0–G3 and the hot-swap passes (2,145 s from the promote to the
      swap, on a busy machine;
      receipt);
    • the upgrade from an evolved 0.5.5 passes, keeping the body INIT evolved, its tool, the lineage and keys; a
      broken bundle is rolled back and an incompatible one is refused, with nothing changed;
    • Esc pause and resume pass;
    • install matrix, 12/12 PASS: a clean home, and installs of 0.3.1, 0.3.2, 0.3.3, 0.4.0, 0.4.1, 0.5.0, 0.5.1,
      0.5.2, 0.5.3, 0.5.4 and 0.5.5, each upgraded with the line get.sh prints, or for those before 0.4.1 uninstalled
      and installed fresh.
  • Linux x86_64 bundle (a hosted Ubuntu 24.04 VM, the same code): install and first reply, pause, and a self-change
    of the core through G0–G3 and the hand-off pass (1,665 s from the promote to the job's end). Its binaries need glibc
    2.34, measured with scripts/glibc-floor.py. Linux's sandbox is unchanged in this release.
  • CI on macOS: the Root, TUI, kernel, seed, extension, install and sealed-pack suites pass on the tagged code. Some
    timing tests failed while the release's own builds ran in parallel (load 20–60): kernel-selfmap s08/s12 and the
    Root's wp21. Each passed when re-run alone.
  • Review: the post-release review of v0.5.5 found the hole; an independent review of the fix found no blocker,
    and its two should-fixes (a linked tree folder in the twin's copy, and the folders above /opt/homebrew's read deny)
    were fixed and tested before the tag.
  • Agent-run user sessions, on the mock model, each in a test home under /private/tmp on the maintainer's Mac
    (its project folder under the maintainer's home), with the Root in a terminal (tmux) and no LaunchAgent: a
    returning user upgrading from the published 0.5.5 with ~/.local/bin/init-agent upgrade and this bundle said ship
    (4 min; the upgrade took 20 s); a new user, installed with --no-rust and the maintainer's rustup 1.97.1 on
    PATH, said ship (43 min; a self-change kept through all four gates in 24 min 3 s...
Read more

INIT v0.5.5-preview

Choose a tag to compare

@nagisanzenin nagisanzenin released this 01 Nov 13:13
Immutable release. Only release title and notes can be modified.

2026-11-01 · research preview · macOS (Apple silicon) and Linux x86_64 (experimental)

v0.5.5 is a security patch. It fixes what the review after v0.5.4 found (REL-054 §7.5): on macOS a full-access agent
could get past the sandbox's denies by renaming a folder above them, and the uninstaller, the PATH block and some
printed commands could run a file the agent wrote. The review of this patch, and the work on it, found more before the
release, and this page covers those too: a hole older than v0.5.5 in the kernel's own profile, which is fixed, and one
in workspace mode that waits for v0.5.6 (see Known limits). Everything in
v0.5.4-preview still
applies, except where this page says otherwise. Linux aarch64 still has no 0.5.x bundle.

Install

curl -fsSL https://github.com/nagisanzenin/INIT-Agent/releases/latest/download/get.sh | sh

Then open a new terminal and run init-agent. When ~/.local/bin is not on your PATH, the installer adds it with a
marked block in your shell's startup file, as v0.5.4 did, but from v0.5.5 at the end of your PATH (see below).
--no-modify-path (sh -s -- --no-modify-path) leaves your startup files alone. In the terminal you installed from,
~/.local/bin/init-agent works at once.

Upgrade

  • First, if you run the Root in a terminal of its own instead of as a service, stop it there (Ctrl-C). The
    upgrade refuses until you do, and changes nothing.
  • From 0.5.4: ~/.local/bin/init-agent upgrade. The launcher upgrades only the home it was installed for, and
    hands the upgrade to the kept get.sh with only HOME, that home and the system PATH.
  • From 0.5.1, 0.5.2 or 0.5.3: /usr/bin/env -i HOME="$HOME" ~/.local/bin/init-agent upgrade. Those releases'
    init-agent upgrade reads INIT_ROOT_HOME from your shell's environment, which a full-access agent can set through
    your startup files, so start this upgrade from a clean environment. get.sh prints this line, with your home filled
    in when it is not ~/.init-root.
  • From 0.5.0 or 0.4.1, once, from your own shell:
    /usr/bin/curl -q -fsSL https://github.com/nagisanzenin/INIT-Agent/releases/latest/download/get.sh | /bin/bash -p -s -- --upgrade
    With a custom INIT_ROOT_HOME, put INIT_ROOT_HOME=<that directory> before /bin/bash; get.sh prints the line
    filled in.
  • Before 0.4.1: uninstall with the line get.sh prints (below, under The installer and the uninstaller), then
    install fresh. The PATH=/usr/bin:/bin:/usr/sbin:/sbin prefix that v0.5.4's notes gave is no longer needed: the
    uninstaller the line downloads sets that PATH itself.

An upgrade never edits your startup files; only a fresh install does. That includes a PATH block from a fresh
v0.5.4 install,
which puts ~/.local/bin first. Neither the upgrade nor a re-install edits it or adds a second one.
Instead the upgrade names the file and prints the line to change, for example:

  note: ~/.zshrc puts ~/.local/bin first on PATH (INIT's block from v0.5.4); INIT now adds it last, so a command you type is the system's, not a file an agent dropped there. To change it, make the block's middle line: export PATH="$PATH:$HOME/.local/bin"

The release key's fingerprint is SHA256:IS7wIWkppZkHSUwdnsJR+K4fBPkmPa/IJwfNi9sIoMs. To check a download by
hand, see Release signing.

The sandbox: the folders above what it protects

The sandbox denies the agent a set of protected paths: INIT's launchers in ~/.local/bin, the provider key files in
~/.config/init-agent, ~/.init-root, the Root's LaunchAgent and every read_deny entry. It denied each path and what
lies under it, but not the folders above it. On macOS a deny matches the path a file has when it is checked, so an
agent that renamed a folder above a protected path moved that path to a new name that no rule named. This predates
v0.5.4. Tested with INIT's real sandbox profiles, a full-access agent could:

  • replace INIT's launchers: mv ~/.local/bin ~/.local/bin.old, then put a folder of its own at ~/.local/bin, or
    swap the two folders in one step;
  • replace the Root's LaunchAgent service file, by renaming ~/Library and putting a prepared one in its place;
  • read the key files or a read_deny entry under a new name: mv ~/.config ~/.cfg, then read
    ~/.cfg/init-agent/; or, with ~/Documents/tax in read_deny, mv ~/Documents ~/Docs2, then read ~/Docs2/tax.
    The same worked for the keys of a ~/.init-root nested one folder down, as in a test install.

In workspace mode the rename worked when the start folder held a protected path two or more folders down: with
~/Library/Application Support as the workspace the agent could read Chrome's cookies, and with a read_deny entry
deep in a project it could read that entry.

From v0.5.5, in full and workspace mode, a folder above a protected path can no longer be renamed, swapped or
removed, and one that is missing cannot be made a symlink
(a key or launcher you add later would otherwise land
wherever the link points). What lies inside those folders is as writable as before: new files in ~/.local/bin, your
own settings under ~/.config, caches in ~/Library and an editor's atomic saves in them all still work. Case
variants (~/.CONFIG), decomposed Unicode names and the /System/Volumes/Data/… path of the same folders are
covered too.

The review of this patch found the same gap inside INIT's own folder, older than v0.5.5. The kernel's profile writes
all of ~/.init, and it denied lineage/kernel.git but not lineage/. So the kernel, or a command G0 runs, could
rename lineage/, write refs of its own into the kernel.git inside it, and rename it back. The Root reads those refs
and runs git on that repository outside the sandbox. lineage/ is pinned now too, and the kernel's other work there
is unchanged.

Linux needed less. Its read denies are mounts, which move with a renamed folder and reveal nothing, and the folders
above each protected path were already pinned with mount points, which cannot be renamed. But the list of folders to
pin dropped every folder above INIT's own homes: with INIT_ROOT_HOME=~/.config/init-root, ~/.config could be
renamed, taking the read-only ~/.config/systemd/user with it, and the agent could then add a systemd drop-in. From
v0.5.5 Linux pins the folders above the homes too (see Known limits for how this was tested).

The installer and the uninstaller

These fix the scripts findings of the review after v0.5.4, and what the review of this patch found in them.

  • The uninstall line keeps the uninstaller in memory:
    /bin/bash -p -c 's="$(/usr/bin/curl -q -fsSL https://raw.githubusercontent.com/nagisanzenin/INIT-Agent/main/scripts/uninstall.sh)" && /bin/bash -p -c "$s" uninstall.sh'
    With a custom home, put INIT_ROOT_HOME=<that directory> in front. v0.5.4's line wrote the download to a temporary
    file and ran it, and a full-access agent could replace that file before bash read it (a watcher did in 3 of 8
    runs). The uninstaller is now also one function, called on its last line, so bash has read all of it before it runs
    any of it: a failed or cut-off download runs nothing. install.sh's closing line prints this line too, not the copy
    in the unpacked release (~/.local/share/init/<version>/), which a full-access agent can change.
  • System tools only. The uninstaller sets PATH=/usr/bin:/bin:/usr/sbin:/sbin before anything else. v0.5.4's ran
    env, sed, grep, mv, stat, launchctl and others from your PATH, where v0.5.4's block puts the
    agent-writable ~/.local/bin first, so a planted ~/.local/bin/env ran as you, outside the sandbox. The shell the
    AppArmor step pipes its commands to runs as /bin/bash -p too, like the scripts themselves, so a planted BASH_ENV
    does not run there. Every sudo line install.sh and the uninstaller print is /usr/bin/sudo.
  • The PATH block appends ~/.local/bin: export PATH="$PATH:$HOME/.local/bin" (fish:
    contains -- '<dir>' $PATH; or set -gx PATH $PATH '<dir>'). A command you type, such as sudo, bash or
    launchctl, is then the system's, never a file a full-access agent dropped into ~/.local/bin, and init-agent,
    which is nowhere else, still runs. v0.5.4's block put it first; see Upgrade for an existing one. The uninstaller
    removes both forms.
  • No block is written through a link into INIT's folders. v0.5.4 already refused a startup file that is a link out
    of your home. But a link an earlier agent left inside it (~/.zshrc to ~/.init-root/charter.toml) made a fresh
    install append the block to the Root's charter or lineage, and a link to nothing created its target. The installer
    now refuses a startup file that leads into INIT's own folders (~/.init-root, ~/.init, the command directory,
    ~/.config/init-agent, the unpacked releases, another install's homes) or to its LaunchAgent or systemd unit, a
    link to nothing, and a file with a second hard link. Folders are compared as files (device and inode), not as
    names, so case and Unicode variants such as ~/.INIT-ROOT are caught. It says why and prints the line to add
    yourself.
  • The second-install hint passes --no-modify-path: for a separate, second INIT, get.sh prints
    sh -s -- --no-modify-path -- --no-service (install.sh: pass --no-service --no-modify-path). Without the flag the
    second install's PATH block put its command directory first, and a bare init-agent in a new terminal opened the
    second INIT.
  • The toolchain steps install and name 1.97.1-<host>. With rustup but no 1.97 toolchain, the closing steps print
    rustup toolchain install 1.97.1-<host> --profile minimal --component clippy --target wasm32-wasip2, then, once
    `rustup toolch...
Read more

INIT v0.5.4-preview

Choose a tag to compare

@nagisanzenin nagisanzenin released this 30 Oct 14:40
Immutable release. Only release title and notes can be modified.

2026-10-30 · research preview · macOS (Apple silicon) and Linux x86_64 (experimental)

v0.5.4 is a patch. It fixes what the review after v0.5.3 found in the installer and the upgrade, a meter bug that
billed OpenAI's cache writes twice, and what the v0.5.3 user sessions found confusing. The installer now also puts
init-agent on your PATH. Everything in
v0.5.3-preview still
applies, except where this page says otherwise. Linux aarch64 still has no 0.5.x bundle.

Install

curl -fsSL https://github.com/nagisanzenin/INIT-Agent/releases/latest/download/get.sh | sh

Then open a new terminal and run init-agent. New in v0.5.4: the installer puts ~/.local/bin on your PATH itself,
with a marked block in your shell's startup file (zsh ~/.zshrc; bash ~/.bashrc on Linux, ~/.bash_profile on
macOS; fish a file of its own, ~/.config/fish/conf.d/init-agent.fish). It adds the block once, only when the
directory is not on your PATH already, and says which file it changed. --no-modify-path (sh -s -- --no-modify-path) leaves your startup files alone, and the uninstaller takes the block out again. In the terminal you
installed from, ~/.local/bin/init-agent works at once.

Upgrade

  • First, if you run the Root in a terminal of its own instead of as a service, stop it there (Ctrl-C). The
    upgrade refuses until you do, changes nothing, and prints the line that starts it again afterwards.
  • From 0.5.1, 0.5.2 or 0.5.3: /usr/bin/env -i HOME="$HOME" ~/.local/bin/init-agent upgrade. Those releases'
    init-agent upgrade reads INIT_ROOT_HOME from your shell's environment, which a full-access agent can set through
    your startup files, so start this upgrade from a clean environment. get.sh prints this line, with your home filled
    in when it is not ~/.init-root.
  • From 0.5.4 on: ~/.local/bin/init-agent upgrade. The launcher upgrades only the home it was installed for. It
    starts as bash -p, so bash runs no BASH_ENV file, SHELLOPTS or exported function from your environment, and it
    hands the upgrade to the kept get.sh with only HOME, that home and the system PATH. Proxy variables
    (HTTPS_PROXY, SSL_CERT_FILE) go too: behind a proxy, download the bundle yourself and run
    ~/.local/bin/init-agent upgrade --bundle FILE --sha256 HEX (the upgrade's own message prints it). This covers what
    a variable can do. A startup file can still run any code as you, and only workspace mode keeps the agent out of
    those files.
  • From 0.5.0 or 0.4.1, once, from your own shell:
    /usr/bin/curl -q -fsSL https://github.com/nagisanzenin/INIT-Agent/releases/latest/download/get.sh | /bin/bash -p -s -- --upgrade
    With a custom INIT_ROOT_HOME, put INIT_ROOT_HOME=<that directory> before /bin/bash; get.sh prints the line
    filled in.
  • Before 0.4.1: uninstall with the line get.sh prints (now /bin/bash -p -c '…', which also works in fish), with
    PATH=/usr/bin:/bin:/usr/sbin:/sbin in front until v0.5.5 (see Known limits), then install fresh.

An upgrade never edits your startup files; only a fresh install does.

The release key's fingerprint is SHA256:IS7wIWkppZkHSUwdnsJR+K4fBPkmPa/IJwfNi9sIoMs. To check a download by
hand, see Release signing.

The installer and the upgrade

These fix what the review after v0.5.3 found (REL-053 §7.5).

  • init-agent upgrade uses only the home it was installed with, and runs the kept get.sh under env -i with only
    HOME, that home and the system PATH. Until 0.5.3 a planted INIT_ROOT_HOME made it run another home's get.sh,
    one the agent could have written. If your environment names another home, the upgrade says so and ignores it.
  • get.sh prints the env -i line to 0.5.1, 0.5.2 and 0.5.3 owners. It printed the plain init-agent upgrade to
    0.5.1 and 0.5.2 owners, not the line the v0.5.3 notes gave.
  • The uninstaller's panic advice names the install. On a custom home it printed a bare init-root panic, which
    would have panicked your main install instead.
  • Linux: glibc 2.34 or newer. get.sh refuses an older glibc, or musl, before it downloads anything. The floor is
    measured from the bundle's binaries (scripts/glibc-floor.py), not guessed.
  • ssh-keygen advice that helps. Without ssh-keygen -Y, get.sh says to install the package; with an OpenSSH older
    than 8.1 (RHEL 8), it no longer says to reinstall a package that would not help, and points to a check by hand or
    --allow-unsigned.
  • The uninstall line works in fish (/bin/bash -p -c '…'), and runs under bash -p, so a planted
    SHELLOPTS/PS4 cannot swap the downloaded uninstaller. The 0.4.1/0.5.0 upgrade pipe runs /bin/bash -p -s too.
  • The --no-rust and toolchain lines say what was found: a rustc without rustup, rustup without a 1.97
    toolchain, a 1.97 toolchain beside another default (now found and used), a rustc that does not run (it used to stop
    the install with no message).
  • A failed upgrade download prints the line that applies to your version (0.4.1 and 0.5.0 get the get.sh
    --from form), and every upgrade time says what it measures.
  • The closing toolchain steps keep your default toolchain: with rustup installed they print only what is missing
    (rustup toolchain install 1.97.1 …, a component or a target for that toolchain) and init-root toolchain --set
    with the 1.97 folder. Every printed pipe line names the release's own get.sh URL, never one taken from your
    environment.
  • The uninstaller moves the unpacked release (~/.local/share/init/<version>/) to the Trash too; v0.5.3 left it
    behind without a word.

The meter: OpenAI's cache writes were billed twice

This release's live re-qualify of OpenAI gpt-6.1-sol found it. Since 20 October OpenAI's usage carries a breakdown of
each cache write by lifetime (input_tokens_details.cache_write_tokens_details.ttl_30m_tokens, the ordinary 30-minute
write). v0.5.3's meter took that breakdown for a usage class it has no price for and billed those tokens a second time,
at the model's dearest price, on top of the cache write: a request that wrote 6,001 tokens to the cache was booked at
$0.076 instead of $0.016. It over-counted, never under (a goal's budget ran out early), and it affected every OpenAI
request with a cache write on v0.5.3.

  • The 30-minute write is the ordinary cache write and is billed at its price.
  • Any other part of a write's breakdown (a 12-hour write, or a lifetime the Root has never seen) is still billed at the
    dearest price with a price_drift alert, as v0.5.3 designed, but once: its tokens leave the cache-write class.
  • A write total that disagrees with its breakdown is billed on the larger of the two. If the total is larger, the
    part the breakdown does not explain is billed at the dearest price, with an alert. The meter never bills below the
    list price.
  • Anthropic had the same double count for an unknown cache_creation lifetime; it is fixed the same way. Its write
    total is now checked against its cache_creation split too, and so is a Chat gateway that passes OpenAI's breakdown
    on (it billed the v0.5.3 double count).
  • An Anthropic cache write that comes without its 5-minute/1-hour split is billed at the dearer of the two write
    prices and recorded as cache_write_unsplit. It used to be billed at the 1-hour price, even on a charter where that
    was the cheaper one.
  • Known over-count, unchanged: a usage field the Root has no price for that sits beside the breakdown (OpenAI's
    input_tokens_details.ttl_12h_tokens, Chat's audio_tokens) is billed at the input price and again at the dearest.

The app

From the v0.5.3 user sessions:

  • /help lists /rollback, and says that it acts at once.
  • The upgrade's last lines say plainly that INIT keeps running the body it evolved, that this release's new starting
    body is not merged into it, and that there is nothing to do.
  • While the first dependency build runs, the self-change panel shows one deps+G0 step: the kernel does not say when
    the dependencies end and G0 starts, so v0.5.3's deps □ beside a G0 "to come" was wrong for the last minutes.
  • /details and Ctrl-O no longer promise a call "in full": a long call is marked as the agent's preview, with where
    the whole call is (the session log under ~/.init/state/sessions/, by its call_id).
  • /model and init-root providers list show the cache-read price beside the input and output prices, from the
    charter the Root bills with.
  • /usage's this TUI row counts only the requests this TUI ran; requests replayed after a relaunch are named apart.

From the v0.5.4 user session:

  • /panic stops a self-change that is being checked: the Root kills the kernel and the gate's build with it, and the
    kernel records the job as failed when it restarts. The panel now says so (■ stopped by /panic … this change did not go live and will not continue) and stops its timer; until v0.5.4 it kept counting after /panic and /resume.
    The same goes for /root stop, init-root stop, a kernel crash loop and a kernel restart: the kernel now reports
    each job its restart ended (gate_stopped), so a TUI that attaches later shows the change stopped too. The job
    record shows the build's real step (queued, exporting, the dependencies, the body, G0's tests), not "queued, 0 %".
  • Once the first dependency build runs past 21 minutes, the panel says it is still building and past the estimate,
    not the old range.
  • A pending G4 row says it scores only if INIT has sealed tasks (a fresh install has none).
  • The Root's panic and resume lines are followed by one plain line: what was killed, what an escapee line would
    mean, and that the agent restarts on the last version that passed INIT's audit.
  • /details points...
Read more

INIT v0.5.3-preview

Choose a tag to compare

@nagisanzenin nagisanzenin released this 29 Oct 14:50

2026-10-29 · research preview · macOS (Apple silicon) and Linux x86_64 (experimental)

v0.5.3 fixes what the review after v0.5.2 found, closes the Root's known invariant gaps, makes INIT's statistics hold
the error rates they state, signs releases, and makes the meter honest about what it does not know. Everything in
v0.5.2-preview still
applies, except where this page says otherwise. Linux aarch64 still has no 0.5.x bundle.

Upgrade

  • From 0.5.1 or 0.5.2: env -i HOME="$HOME" ~/.local/bin/init-agent upgrade. The env -i matters: in full
    access, an agent could have planted INIT_DIST_URL in your shell's startup file, and 0.5.1/0.5.2's upgrade would
    follow it. From 0.5.3 on, releases are signed and an upgrade checks the signature against the key your installed
    Root pins, so a planted URL can no longer choose what you install. A planted INIT_ROOT_HOME still can until
    v0.5.4 (0.5.3's init-agent upgrade prefers it to its own home), so use the same line for upgrades from 0.5.3 too.
    If you run the Root in a terminal of its own instead of as a service, stop it there first (Ctrl-C); the upgrade
    refuses until you do, changes nothing, and prints the line that starts it again afterwards.
  • From 0.5.0 or 0.4.1, once, from your own shell:
    /usr/bin/curl -q -fsSL https://github.com/nagisanzenin/INIT-Agent/releases/latest/download/get.sh | /bin/sh -s -- --upgrade
    With a custom INIT_ROOT_HOME, put INIT_ROOT_HOME=<that directory> before /bin/sh; get.sh prints the line
    filled in.
  • Before 0.4.1: uninstall with the line get.sh prints, then install fresh.

The release key's fingerprint is SHA256:IS7wIWkppZkHSUwdnsJR+K4fBPkmPa/IJwfNi9sIoMs. To check a download by
hand, see Release signing.

/undo and the Root's own restore never lose files

In v0.5.2, /undo removed your folder's entries before it copied the snapshot back, so a read-only folder (a Go
module cache, a vendored package) stopped it halfway with files gone. The Root's own system restore had the same
pattern, and an agent could make the Root's rollback fail by creating a read-only folder. Both are now all or nothing:
the snapshot is staged and checked first, entries are swapped by renames that never replace and never follow a link,
and a step that fails puts everything back. Plain /undo also never brings back a state an /undo replaced, and a
stuck probe file no longer breaks it.

Statistics that hold their stated rates

Before changing anything, we measured v0.5.2 against a null: a goal whose changes did nothing ended met in 35–99 % of
simulated goals, and a reading said better on a no-effect change up to 42 % of the time. Now a reading's verdict is an
exact permutation test at 2.275 %, met needs p ≤ 5 % divided by the goal's rounds, and every change that goes live
during a goal spends a round. Simulated false met is 0–4.65 % per goal at rounds = 10
(STATS-053).

Guardrails on discrete cards (requests, cache reads, provider errors, corrections) now read 15 turns, because 5 turns of
a rare event hold too little evidence to see a fivefold rise. They catch at least what v0.5.2 caught in every measured
cell but one, with false rollbacks at most 2.2 %; the cost is a verdict about 10 owner turns later.

A level now means something you can check: at 95 % confidence, valid however often it is re-checked, the share of
exercised change groups (closed with at least 5 owner turns in their window) ending in a rollback attributed to direct
harm is below 25 % (L1), 20 % (L2), 10 % (L3) or 5 % (L4). Release builds still stop at L0.

Signed releases

Each release's SHA256SUMS is signed with one ed25519 key. A fresh install checks the signature with ssh-keygen; an
upgrade from 0.5.3 on asks the installed Root, which pins the key at build time. Older releases and expired lists are
refused. A machine without ssh-keygen -Y (minimal Linux images, RHEL 8, Amazon Linux 2) is refused with the package to
install, or --allow-unsigned and its risk.

The meter and the Root

  • An unknown usage class is billed at the model's dearest price with a price_drift alert; /usage shows one price
    (the Root's, which over-counts DeepSeek's off-peak discount rather than under-count); a cut Anthropic stream is booked
    as an upper bound.
  • OpenAI gpt-6.1-sol was qualified live on v0.5.2 (2026-10-29); v0.5.3 changed how a cut request is booked and
    has not been re-qualified yet. Anthropic stays experimental.
  • The Root re-hashes its own binary, profiles and charter at every admission (A0); a free-path promotion must name
    admitted content; a sealed audit can no longer move LKG backwards; genesis after an upgrade runs the release's kernel.
  • Plain /rollback now works on the gated path. More credential stores, every other INIT install's homes and
    ~/.init-release are denied to the agent.
  • Every printed init-agent command carries its path; install.sh's PATH hint names your shell's file.

Known limits

  • With turns clustered in sessions, the GBAL bounds above are exceeded (2–9 % per reading, 12–24 % per goal in
    simulation). Fixing it needs the session in each observation (v0.6).
  • The agent chooses when a change goes live, and so its baseline window: an open gaming vector, documented in ADR-013.
  • In full access, INIT cannot protect commands you run in your own shell: the agent can edit your shell's startup
    files. Workspace mode (init-agent --workspace) confines it.
  • A ROOT_HOME outside the usual places (for example under /tmp) is not found by the other-install deny list.
  • Monte Carlo p-values (above 2^21 relabelings) act like a randomized test near the level (STATS-053).
  • Release key 1 is a file key without a passphrase on the maintainer's Mac (docs/release-signing.md §8).
  • Faster gates (L5) and the Root's property harnesses (L2) move to v0.5.4.
  • From the user sessions (docs/user-sessions/v0.5.3-*.md): the uninstaller leaves ~/.local/share/init/<version>/
    (the unpacked release) behind without saying so; /help does not list /rollback; the upgrade's "offering its new
    seed" line is unexplained; the gate track shows deps □ while G0 already runs; /details shows the agent's preview
    of a call, not the whole call; the cache-read price is not shown anywhere; after a relaunch "this TUI N requests"
    also counts replayed requests; files /undo restores take the group of INIT's own folder.
  • An agent that stacks changes faster than 5 owner turns gets owner guardrails that cannot decide; the Root now
    alerts when that happens (goal_guard_unchecked), but the baseline is not yet taken from an older tuple (ADR-013).
  • init-root audit verify against a running Root can read the chain and its head between two appends and report
    INVALID; run it again, or with the Root stopped.
  • The descriptor-relative /undo and R2 code paths for Linux were reviewed and built on the x86_64 runner; the
    restore itself was exercised on macOS.

Verified for this release

Everything below ran at $0 on the mock model unless it says live. The full record is
REL-053.

  • macOS arm64 bundle. The shipped bundle (bb5dc0e) differs from the candidate c045d65's in one change: /undo
    waits for the next heartbeat instead of refusing at once. On the shipped bundle, install and first reply, Esc pause
    and resume, and the install matrix (below) pass. On c045d65's bundle, and not re-run on the shipped one, because none
    of them uses /undo:
    • the source install (release-e2e) passes;
    • a self-change of the compiled core through G0–G3 and the hot-swap passes (1,410 s from G0 to the swap, beside
      CI; receipt);
    • upgrade from an evolved 0.5.2 passes: the install kept a self-made tool through the gates, and the upgrade kept
      it, with the lineage, keys and sessions; a broken bundle rolled back, and an incompatible one was refused.
  • Install matrix, on the shipped bundle: the installer was run on a clean home and on installs of 0.3.1, 0.3.2, 0.3.3, 0.4.0, 0.4.1,
    0.5.0, 0.5.1 and 0.5.2, 9/9 PASS.
  • Linux x86_64 bundle (a hosted Ubuntu 24.04 VM): install and first reply, pause, and a self-change of the core through G0–G3 and
    the hand-off, all pass (G0 835 s; 1,671 s from the promote to the swap).
  • CI on macOS: 2,273 Rust tests passed on the candidate; one TUI end-to-end test failed (an /undo typed right
    after a short turn was refused), was fixed before the tag and passed 3/3. The body's own suite, which G0 runs on your machine,
    passed 5 more times while the machine was loaded.
  • Review: three independent reviewers read the release diff; their findings (two /undo path issues, an audit
    pointer race, a halt that could be cleared, a gameable met, and installer and TUI issues) were fixed and tested
    before the tag.
  • Two agent-run user sessions said ship: a new user on a clean Mac (42 min, with a self-change), and a returning
    user upgrading from 0.5.2 with the line above (5 min).
  • Live: OpenAI gpt-6.1-sol was qualified live on v0.5.2 (2026-10-29): it passed all seven checks of
    scripts/qualify-provider.sh on a v0.5.2 install
    (receipt).
    v0.5.3 changed how a cut request is booked and has not been re-qualified yet.

Not verified

  • A live run of this release's own build with any provider: OpenAI's qualify ran on v0.5.2, and this release changes
    how a request cut mid-stream is booked.
  • An upgrade on Linux x8...
Read more

INIT v0.5.2-preview (readiness patch; macOS + Linux x86_64 research preview)

Choose a tag to compare

@nagisanzenin nagisanzenin released this 28 Oct 17:24

2026-10-29 · research preview · a readiness patch · macOS (Apple silicon) and Linux x86_64 (experimental)

v0.5.2 fixes what a first-time user ran into on v0.5.1, and what the review after the v0.5.1 release found. In the
v0.5.1 user session, an agent playing a new user said "do not ship". On this release, both the new-user and the
returning-user sessions said ship. Everything in
v0.5.1-preview still
applies, except where this page says otherwise. Linux aarch64 still has no 0.5.x bundle.

Upgrade

From 0.5.1: ~/.local/bin/init-agent upgrade. From 0.5.0 or 0.4.1, run this once from your own shell:

/usr/bin/curl -q -fsSL https://github.com/nagisanzenin/INIT-Agent/releases/latest/download/get.sh | /bin/sh -s -- --upgrade

If you installed with INIT_ROOT_HOME set, put INIT_ROOT_HOME=<that directory> before /bin/sh; get.sh prints the
line with it filled in. See
Install, upgrade, uninstall.

A self-change is no longer refused at random on a busy machine

Three of the body's tests depended on timing:

  • one expected a helper script to start within 2 seconds;
  • one read a test server's file before the server had finished writing it;
  • one, used by developers, waited a fixed 30 seconds.

On a loaded machine they failed often enough to refuse good self-changes: 3 of 5 macOS runs on release day. All three
are fixed at the cause. The test server now writes its files atomically, and the waits are tied to events, not clocks.
Every timing assertion in the body's tests was reviewed. The body's whole suite then passed 10 times out of 10 while 8
processes kept every core busy. The macOS self-change of the compiled core passed through all four gates and the
hand-off on this release.

What a new user hit, fixed

  • The first self-change of the core builds its dependencies cold, for about 10–20 minutes on an M2. That build is
    now its own step on the gate track, with that estimate. It is no longer shown as "waited".
  • /undo after you reopen INIT goes back to before the agent's edits. It restores the newest snapshot that
    differs from your folder. /undo list shows the snapshots, and /undo <id> picks one. A launch where nothing
    changed no longer takes a snapshot.
  • An unknown command such as /undo lst is refused in the TUI instead of being sent to the model and billed.
    /help lists the commands. Start a line with // to send it to the model as text.
  • After /panic and /resume, the footer shows the version that really runs. Before you confirm, /panic says
    which kept changes a resume would drop.
  • Money: a turn replayed after a relaunch shows $?, never $0.000. "incl. checks" appears only when a gate ran.
  • /details and Ctrl-O show the whole call and the last lines of a command's output, successful or not.
  • The README's install lines work on a fresh Mac: no # comment, which zsh passed as an argument, and the first
    run is ~/.local/bin/init-agent. The installer prints that full path, and how to put it on your PATH.

Upgrades and installs, after the v0.5.1 review

  • The Root never runs the agent while an upgrade is half done. This could happen after a reboot in the middle of an
    upgrade. If the commit had begun, the Root finishes it. Otherwise it rolls the upgrade back and the service starts
    the old Root.
  • upgrade --commit run by hand now also installs the new release's get.sh, so init-agent upgrade never keeps an
    old one.
  • A second install by mistake is refused. If INIT lives in another INIT_ROOT_HOME, get.sh and install.sh refuse
    a fresh install and print that home's upgrade line.
  • On a machine with no bundle for this release (Linux aarch64), get.sh no longer advises an upgrade that cannot work.
  • The uninstaller honours a custom INIT_BIN_DIR, and its printed command carries INIT_ROOT_HOME.

Known limits

  • /undo can lose files if your folder holds a read-only directory (for example a vendored module cache). It removes the folder's entries before it copies the snapshot back, and a read-only directory stops it halfway. This is not new in 0.5.2, and the fix is planned for v0.5.3. Until then, make such directories writable before /undo, or copy files back by hand from ~/.init-root/snapshots/<id>/.
  • Some messages still print a bare init-agent upgrade or init-agent --workspace. On a fresh Mac, use ~/.local/bin/init-agent …, or add ~/.local/bin to your PATH. On Linux, the installer's PATH hint names ~/.zshrc; bash users add it to ~/.bashrc.
  • The deps step has no estimate of what is left once it starts. The kernel reports the start of the dependency
    build, not its end, so the panel learns it only when G0 finishes.
  • /usage can show a self-change's checks at two prices, before and after a relaunch: the Root's charter has one
    DeepSeek price, and the kernel's config has an off-peak price. Both are labelled as estimates. This will be
    reconciled in v0.5.3.
  • After an upgrade the conversation screen starts empty. The session is kept, and the model still gets it. The
    Root's replay buffer is in memory, so a restart clears it.
  • An upgraded install keeps the body it evolved. It does not get this release's body changes: the fuller
    /details output and the test fixes. The upgrade does not yet offer a release's new seed.
  • A few messages still print a bare init-agent (the quit line, the Root's terminal window).
  • In developer CI, the sealed judge's determinism test once recorded a run's exit code as missing under heavy load.
    It passed alone. It is under investigation for v0.5.3.
  • Anthropic and OpenAI are not live-qualified. Releases are checked by SHA-256 and not yet signed; signing is planned
    for v0.5.3.

Verified for this release

Everything below ran at $0 on the mock model. The full record is
REL-052.

  • macOS arm64 bundle:
    • install and first reply, Esc pause and resume, and the source install all pass;
    • a self-change of the compiled core through G0–G3 and the hand-off passes (G0 975 s, G3 822 s, hand-off 6.3 s,
      beside a CI run);
    • upgrade from an evolved 0.5.1 passes: the install kept a self-made tool through the gates, and the upgrade
      kept it, with the lineage, keys and sessions. A broken bundle rolled back, and an incompatible one was refused.
  • Install matrix: the installer was run on a clean home and on installs of 0.3.1, 0.3.2, 0.3.3, 0.4.0, 0.4.1,
    0.5.0 and 0.5.1, 8/8 PASS.
  • Linux x86_64 bundle (a hosted Ubuntu 24.04 VM): install and first reply, pause, and a self-change of the core
    through G0–G3 and the hand-off, all pass.
  • The body's test suite passed 10/10 runs while 8 processes kept every core busy.
  • CI on macOS: 2,108 Rust tests passed. One developer-only kernel test failed once under load and passed alone
    (see Known limits).
  • Two agent-run user sessions said ship: a new user on a clean Mac, and a returning user upgrading from 0.5.1.
    Every v0.5.1 blocker was checked as fixed.

Not verified

  • An upgrade on Linux x86_64: the matrix and the upgrade check ran on macOS.
  • The upgrade's LaunchAgent path on this release. It was first run for real on the owner's Mac with 0.5.1.
  • Linux aarch64 (no 0.5.x bundle), Anthropic and OpenAI on a live API, and any live model call in this release.

INIT v0.5.1-preview (security and readiness patch; macOS + Linux x86_64 research preview)

Choose a tag to compare

@nagisanzenin nagisanzenin released this 28 Oct 12:20

2026-10-28 · research preview · a security and readiness patch · macOS (Apple silicon) and Linux x86_64 (experimental)

v0.5.1 fixes what an independent review of the shipped v0.5.0 and two user sessions found, on the day v0.5.0 shipped.
Two of the fixes close ways around the Root. Update if you run INIT in workspace mode, or if you ever upgrade from a
bundle file. Everything in v0.5.0-preview still applies, except where this page says otherwise.
Linux aarch64 still has no 0.5.x bundle.

Upgrade

From 0.5.0 or 0.4.1, run this once from your own shell:

/usr/bin/curl -q -fsSL https://github.com/nagisanzenin/INIT-Agent/releases/latest/download/get.sh | /bin/sh -s -- --upgrade

This runs 0.5.1's get.sh with the system's curl and sh. 0.5.0's own init-agent upgrade would run 0.5.0's get.sh,
which has the problems listed under "Security fixes", and its --version 0.5.1 asks for a tag that does not exist. If you installed with INIT_ROOT_HOME set, put INIT_ROOT_HOME=<that directory> before /bin/sh; get.sh prints the line with it filled in. From
0.5.1 on, init-agent upgrade is enough. For an install older than 0.4.1, uninstall first; get.sh prints the
command. See Install, upgrade, uninstall.

Security fixes

Workspace mode: an agent could redirect git's config in your folder (macOS).

  • In workspace mode the agent may write the folder you started INIT in. The sandbox denied writes to .git/config
    and .git/hooks, but git reads its config and commands from other places too.
  • By writing .git/commondir, renaming .git aside, creating a .git file, or renaming a directory onto
    .git/modules/<m>, an agent acting against you could point git at a config it wrote. Your next git status in
    that repository would then run its command, outside the sandbox, with your rights.
  • The sandbox now denies the .git entry itself and every config and command source git reads, in .git/,
    .git/modules/… and .git/worktrees/…, including renames onto them. Committing still works.
  • In workspace mode the agent can no longer git init, add a submodule or add a worktree in your folder.
  • Linux was not affected: there, workspace mode keeps the agent in its own home.
  • In full access, the default, nothing changes. The agent can write what you can, except the Root, as
    ADR-012 has always said.

Upgrading from a bundle file trusted files the agent could write.

  • init-agent upgrade --bundle FILE checked the bundle where it lay, then unpacked it from the same place. It took
    the expected SHA-256 from a .sha256 file beside it. With full access, the agent can write both.
  • Now the bundle is copied into ~/.init-root/cache/upgrade/ first, and only that copy is checked and unpacked.
    A bundle file needs --sha256 on the command line; without it, the upgrade stops and prints the exact command.
  • An upgrade from a release bundle (the usual case) now runs only the system's tools (PATH=/usr/bin:/bin:/usr/sbin:/sbin), from /, with curl ignoring ~/.curlrc. An upgrade from a source checkout still uses your PATH, because it builds with your cargo.
    The Root's own git calls ignore the repository you start them in.
  • --version 0.5.0 now finds the tag v0.5.0-preview.

No exploit of either hole was seen. The post-release review found both.

Upgrades

After an upgrade, a panic could bring back the old kernel.

  • upgrade --commit moved the last-known-good pointer to the new version, but left the rollback anchors on the
    version from before.
  • After /panic and /resume, the Root reinstalled the old init-kernel and ran it under the new Root.
  • The commit now moves every anchor to the new kernel, keeping the body your INIT evolved. An anchor it cannot read
    is cleared and reported, never kept silently.
  • An install upgraded to 0.5.0 keeps its old anchor until this upgrade moves it.

What the user sessions found

Two agents played a new user and a returning user on v0.5.0, through the real TUI. Both said "do not ship". The
fixes:

  • / then Tab completed to /panic, and it ran at once. Safe commands now come first. In the TUI, /panic says
    what it does and runs only after you type panic (or /panic again); nothing the agent sends can cancel that step.
    Line mode (init-agent --raw, for scripts) still panics at once.
  • Commands we printed did not run. The Root and the TUI told you to run init-root …, which is not on your
    PATH. Every command INIT prints now runs as printed: ~/.init-root/bin/init-root …, or an init-agent form. A
    test checks the Root's messages, the installer's and the TUI's.
  • Refusals say the rule and the fix. That covers a workspace outside your home, an agent that cannot start, and a
    Root started from the wrong HOME. Without a workspace, the screen says the agent works in ~/.init/work and /undo
    has nothing to restore.
  • Numbers agree. /usage no longer shows "$0.00" for a self-change's checks when the Root metered them. Every
    amount uses one rounding rule. A turn's cost stops at the end of its run. The gate rows add up to the total. An
    unscored G4 says "not scored". The dollar amounts in /root status are labelled as records, not caps.
  • An answered question stays answered after you reopen the TUI.
  • Quitting with Ctrl-D leaves no half-drawn box. It says the agent keeps running and how to come back.

Documentation

  • The README now says what INIT is, how it works, what it has done and its limits, in half the length. Install and
    upgrade details moved to the guide.
  • docs/foundations.md is the formal model INIT's guarantees are stated against. It defines two
    guarantees (recoverability, and Root-only evidence), twelve invariants with their status, the assumptions, and
    what INIT does not promise.
  • docs/release-protocol.md: every release now passes the same gates. These include
    scripts/install-matrix.sh (the installer on a clean machine and on every public release since 0.3.1), two
    agent-run user sessions, and an independent review after release.
  • Corrected numbers:
    • README said a small core change takes "about 2 min end to end". That was never measured. The README now gives what
      was: 788 s (13.1 min) from G0 to the hot-swap, built cold (v0.5.0, M2, mock model), and 126 s for build and G0
      when warm.
    • ADR-011's harm-signal parameters and ADR-013's guardrail false-alarm rate (2.3 %; about 5.1 % in practice) now
      carry notes where the code differs. The guardrail fix is planned for v0.5.2.

Known limits

  • The genesis fallback. If, after an upgrade, the last-known-good, settled and audited versions all fail to
    verify, a resume falls back to the genesis tuple, which holds the install's original kernel. This is the last
    resort, and it is scheduled for v0.5.2.

  • Releases are checked by SHA-256 only, not signed. Signing with an offline key is planned for v0.5.2.

  • Anthropic and OpenAI are not live-qualified. DeepSeek is the only live-tested provider.

  • Two things the user sessions raised are not changed in this release: the gate track shows no estimate of how long a
    self-change will take, and some status labels read "live" when the model is the mock.

  • On a busy machine, two flaky body tests can refuse a good self-change of the compiled core. This is not new in
    0.5.1. One expects a helper script to start within 2 seconds. The other reads a test server's file before the server
    has finished writing it. Either can fail the build-and-test check (G0, or G0 inside G3), and then the change is
    refused. On this release's test machine they failed 3 of 5 self-change runs while other builds ran beside them. They
    passed on the hosted x86_64 runner and whenever the machine was otherwise idle. Nothing unsafe is admitted: retry
    the change when the machine is quieter. Fixing both, with an audit of every such timing assertion, is the first item
    of v0.5.2. Another test of this kind, found on the x86_64 runner, is fixed in 0.5.1.

  • What a new user still runs into. An agent-run session with a first-time user, on this release, said "do not
    ship". The owner shipped 0.5.1 anyway, because it closes two holes in 0.5.0 and makes none of these worse. The
    readiness patch before the Show HN fixes them:

    • the first self-change of the compiled core shows its cold dependency build (about 17 minutes) as "waited", with no
      estimate of how long is left;
    • /panic then /resume returns to the last audited version, which on a fresh install is the original one, so a
      change you just kept is dropped (the confirmation says so, but the footer keeps showing the dropped version);
    • /undo restores the newest snapshot, and every launch takes one, so after you reopen INIT it cannot go back to
      before the agent's edits;
    • an unknown command such as /undo list is sent to the model as a message, and billed;
    • a replayed turn's cost shows $0.000;
    • /details does not show a successful command's output.

Verified for this release

Everything below ran at $0 on the mock model. The full record is
REL-051.

  • macOS arm64 bundle:
    • install and first reply (bundle-e2e) PASS, and the same on the bundle downloaded from this page;
    • Esc pause and resume PASS;
    • source install (release-e2e) PASS;
    • upgrade from an evolved 0.5.0 PASS: the 0.5...
Read more

INIT Agent v0.5.0-preview

Choose a tag to compare

@nagisanzenin nagisanzenin released this 28 Oct 02:59

INIT Agent v0.5.0-preview

2026-10-28 · research preview · macOS (Apple silicon) and Linux x86_64 (experimental)

Linux aarch64 has no 0.5.0 bundle yet: aarch64 machines stay on v0.4.1-preview until one is added to this release.

INIT is a harness in which a coding agent may rewrite itself, including its compiled core. It runs under a Root, a separate process the agent cannot change. The Root holds the keys, the sandbox and a signed record of every change, and it can always roll the agent back to its last known-good version.

This is a research preview, not a finished product. Everything in v0.4.0-preview and v0.4.1-preview still applies (goals with /goal, full access by default, how to confine it, the known limits), except where this page says otherwise.

Upgrade in place: init-agent upgrade

Until now the only way to a new release was to uninstall and install again, which moved the agent's evolved body, its lineage and your keys to the Trash. From this release INIT upgrades in place and keeps what it has become: the body it evolved, its extensions, skills and sessions, the signed lineage, your keys and your charter.

init-agent upgrade                       # the latest release
init-agent upgrade --version 0.5.1       # a given release
init-agent upgrade --bundle FILE         # a downloaded bundle (its .sha256 next to it, or --sha256 HEX)

From 0.4.1, which has no init-agent upgrade, run this once from your own shell:

curl -fsSL https://github.com/nagisanzenin/INIT-Agent/releases/latest/download/get.sh | sh -s -- --upgrade

After that, init-agent upgrade works. The upgrade was tested from 0.4.1 only; for an older install the tested path is its uninstall.sh (which moves everything to the Trash), then a fresh install.

What the upgrade does, in order: it downloads the bundle and checks its SHA-256 into ~/.init-root/cache/upgrade/, which the agent cannot write; stops the Root (a Root you started in a terminal is never signalled, so stop it with Ctrl-C first); refuses an older or the same release, and a release whose kernel cannot run your evolved body; snapshots what it replaces; installs the new Root, kernel and commands; starts a health probe (the kernel ready, your body booted, the lineage verified, within 120 s); then commits, or puts the old binaries back and returns the system to the tuple from before. Your evolved body is never migrated or rewritten. The details are in docs/guide.md, Upgrade.

Limits, plainly:

  • Bundles are checked by SHA-256 only; releases are not signed. The checksum comes from the same GitHub release as the bundle, so it detects a broken download, not a compromised release.
  • The new seed is not merged. A release's new prompts, skills and tools are not merged into the body INIT evolved; INIT keeps running its own body under the new Root and kernel.
  • No live swap. INIT stops for the few seconds the upgrade takes.
  • An open self-change refuses the upgrade (in free mode, a change group in its 2-72 h watch window must close first).
  • Only the no-service path was run end to end. The upgrade's stop and start of the LaunchAgent or the systemd user unit use the same commands the installer and uninstaller already use, but no test drove them, because a test must not touch your running service.

The installer asks one question

install.sh (which get.sh runs) no longer asks for a provider, a model or each limit. It prints the settings it writes into your charter and asks Install with these settings? [Y/n]; get.sh answers yes. Each setting has a flag (--disk-floor, --day-usd, --total-usd, --max-level, --access full|workspace). The provider, the model and the key are chosen on the first run of init-agent.

Spending is tracked, not capped. The day and total amounts in the charter ($5 and $25 by default) are what INIT shows its spend against; nothing stops INIT when they are reached. The one dollar limit the Root enforces is a goal's usd= budget, and it stops that goal, not INIT. Set a spending limit at your provider as well. The installer, the charter template and the guide's Spending section now say this in those words.

macOS: the init shim is gone. v0.4.1 kept ~/.local/bin/init on macOS as a shim that printed the new name. This release removes it, on install and on upgrade, the same way Linux removed the old launcher: only INIT's own init (checked by path, regular file and content), never another file named init. Use init-agent.

Seeing what INIT does to itself

The TUI now shows each self-change as what it is:

  • A gate track. While a change runs through the gate, one block shows its steps (G0 … G4, hand-off) with times. It ends as one line: ✓ kept, ✕ refused at G2 … still on <parent> (nothing went live), or ✕ rolled back at G4 … back on LKG (it went live and was taken back).
  • A failed tool call shows why: the last lines of its output under the call.
  • The lineage at the foot of Ctrl-O: verify ✓ N records · every signature, or the first record that fails, and the newest records.
  • Colour means state. Amber belongs only to the Root, cyan only to a change in flight, green only to something kept, red to harm and refusal. Four colour tiers (truecolor, 256, 16, NO_COLOR) with dark and light variants; --theme light for a terminal that does not report its background.
  • A liveness row while the agent works (waiting for the model · 12 s, thinking, writing · no new text for 9 s, running bash · 41 s), and a status bar split between the agent (left) and the Root (right, ending in root ok or its alarm).
  • Pickers. Setup, /model and /key use arrow-key pickers. The agent can ask you a question with 2-4 options through a new tool, ask_owner; the turn ends and your answer is your next message. Nothing is picked for you and there is no timeout. The question can never look like the Root: it is cleaned, capped, shown under the TUI's own label in plain colours, and an option that starts with / is sent quoted, never as a command. While it waits on you, a goal's wall clock is paused.

Checking a published lineage offline

init-root audit verify --file lineage.jsonl --pub <key> [--head <hash>] checks a lineage file someone published, without an install: the hash chain, every Ed25519 signature from genesis, and key rotations. It proves that the records were not changed after they were signed; it does not prove that the binaries match the source. Publish the key and the head hash apart from the file. scripts/proof/export.sh prepares such a bundle from an install (sessions, the signed lineage and key, one diff per self-change, the spend ledger) and refuses if its scan finds a key or token.

Other changes

  • On Linux the build disk floor read the sandbox's tmpfs; fixed. The kernel checked free space before a self-change (disk.min_free_build_gib, 5 GiB) on its home directory, which inside its Linux sandbox is the sandbox's own tmpfs, not your disk. So on a machine with little RAM every promote was refused (E_DISK), and on others the check never saw the real disk. It now reads the bound build cache, which is on your disk. The Root's own disk floor (measured outside every sandbox) was never affected. macOS was not affected.
  • Fixes from the 2026-10-25 demo: G0 no longer fails with a 63-64 byte INIT_HOME; a gate's G3 stops when the Root rolls its change group back; the body's boot message names the Root's rollback instead of a stale cause.
  • Anthropic and OpenAI cache writes are billed at their write prices. The Root billed them at the input price, about 20 % under the provider's bill on a cold request. Now the ledger, the TUI's $ and a goal's usd= meter use the charter's write prices; a model row without them is billed at twice the input price, so it can over-count, never under-count. DeepSeek is unchanged. A model you added with providers add before this release has no write prices: re-add it to get the catalog's.
  • Linux x86_64: get.sh on a machine the release has no bundle for now names the platforms it has, instead of "download failed". bundle.sh checks that every binary matches its target triple.
  • Guide: /rollback settled|lkg|twin returns the whole system to that tuple; a Spending FAQ.

Live-tested and not

  • DeepSeek (deepseek-flash, deepseek-v4-pro) is the only live-tested provider. This release made no live model call; everything below ran at $0 on the mock model (init-mockllm).
  • Anthropic and OpenAI are not live-qualified. Their cache usage and billing are tested against recorded response shapes, and scripts/qualify-provider.sh (an owner-run live check inside a Root-metered budget of at most $10) is ready but has not run. /model shows which models are tested.
  • Linux x86_64: on a GitHub-hosted Ubuntu 24.04 VM (x86_64, 4 vCPU), the bundle builds (the body inside the Linux build sandbox), passes the Linux sandbox checks and reproduces self.json; after INIT's AppArmor step it installs, answers, pauses and resumes, and a self-change of the compiled core (a no-op T2) passes G0–G3 and hands off, all on the mock model (G0 806 s, G1 1 s, G2 19 s, G3 789 s, hand-off 4.5 s). It has not run on physical x86_64 hardware or on a distribution other than Ubuntu 24.04.
  • Ubuntu 24.04 needs the one-time AppArmor step below.

Linux: a one-time AppArmor step on Ubuntu 24.04

Ubuntu 24.04 restricts unprivileged u...

Read more

INIT v0.4.1-preview (the command is init-agent; macOS + Linux aarch64 research preview)

Choose a tag to compare

@nagisanzenin nagisanzenin released this 27 Oct 09:40

INIT Agent v0.4.1-preview

2026-10-27 · research preview · macOS (Apple silicon) and Linux aarch64 (experimental)

INIT is a harness in which a coding agent may rewrite itself, including its compiled core. It runs under a Root, a separate process the agent cannot change. The Root holds the keys, the sandbox and a signed record of every change, and it can always roll the agent back to its last known-good version.

This is a research preview, not a finished product. Everything in v0.4.0-preview still applies (goals with /goal, full access by default, how to confine it, the known limits). This release changes only the name of the command you start INIT with.

The command is now init-agent

The command INIT installed into ~/.local/bin was called init. On Linux, ~/.local/bin often comes before /sbin in PATH, so in your shells init ran INIT instead of the system's /sbin/init (issue #1). The installer never ran as root and never replaced /sbin/init, but a user command must not shadow a system one. From this release the command is init-agent on every platform:

init-agent                # open INIT
init-agent --workspace    # confine this session to the folder you start it in

init-root and init-tui keep their names.

  • Linux: the installer never installs a file named init. If it finds INIT's old launcher at ~/.local/bin/init (or in INIT_BIN_DIR), it removes it. It checks the exact path, that the file is a regular file, and the old launcher's own header and marker lines. A file named init that is not INIT's is left alone, and the installer says so.
  • macOS: for this release only, init still works. It prints that the command is now init-agent and runs it. The next release removes it.
  • System directories: the installer now refuses an INIT_BIN_DIR that is /sbin, /usr/sbin, /bin or /usr/bin, also through a symlink or another spelling of the same directory, before it writes anything.
  • The sandbox: in full-access mode the agent still cannot replace INIT's launchers. That protection now covers init-agent as well as init and init-tui.
  • uninstall.sh moves init-agent, init-tui and INIT's own init to the Trash, and leaves any other init where it is.

Install or upgrade

curl -fsSL https://github.com/nagisanzenin/INIT-Agent/releases/latest/download/get.sh | sh
init-agent  # first run: pick a provider, paste a key (hidden), pick a model

In-place upgrade is not supported yet: the installer refuses when INIT is already installed. Run the current install's uninstall.sh first, then the line above. Uninstalling moves both homes and the old ~/.local/bin/init to the Trash; nothing is deleted.

Verified for this release

On these exact bundles, at $0 on the mock model (full record: build/status/REL-041.md):

  • Linux upgrade path in a fresh Ubuntu 24.04 container (aarch64, Docker, not privileged, no Rust preinstalled, bubblewrap 0.13.0) with INIT's old launcher planted at ~/.local/bin/init: the install removed it, installed init-agent and no init, and was T2-capable in 93 s with Rust; first reply at 98 s.
  • macOS in a fresh temp home with the same old launcher planted: init became the shim (init --which prints the same as init-agent --which, plus the notice), T2-capable in 133 s with Rust; first reply at 141 s.
  • A foreign init is never touched: a source install from this release left a non-INIT init byte for byte, and so did uninstall.sh, which moved init-agent, init-tui and both homes to the Trash.
  • Pause and resume on both bundles against the strict DeepSeek mock: all 16 checks pass on each.
  • The installer's bin-dir guard: /sbin, /usr/sbin, /bin, /usr/bin, other spellings of them, a symlink to /usr/bin and a relative path are all refused before anything is written.
  • The no-op T2 promote on a fresh macOS bundle install, through the shipped gate: G0–G3 and the hot-swap handoff pass.
  • Full CI on macOS: 1,929 passed, 0 failed, 38 ignored, after a test that still ran the old scripts/init was fixed and three kernel tests, which had timed out waiting for a shared cargo lock, were rerun.

The full list of changes is in the CHANGELOG.

INIT v0.4.0-preview (goals: /goal and GBAL; macOS + Linux aarch64 research preview)

Choose a tag to compare

@nagisanzenin nagisanzenin released this 25 Oct 18:30

INIT Agent v0.4.0-preview

2026-10-26 · research preview · macOS (Apple silicon) and Linux aarch64 (experimental)

INIT is a harness in which a coding agent may rewrite itself, including its compiled core. It runs under a Root, a separate process the agent cannot change. The Root holds the keys, the sandbox and a signed record of every change, and it can always roll the agent back to its last known-good version.

This is a research preview, not a finished product. Everything in v0.3.3-preview and the releases before it still applies (Esc and Ctrl-C pause, full access by default, how to confine it, the known limits).

Goals: /goal (GBAL, ADR-013)

Until now INIT changed itself when it hit friction. v0.4 lets you give it a direction:

/goal "answer short questions about this folder with fewer model requests per turn" done=card:requests_turn<=2 usd=0.40 wall=3h rounds=8 guard=cost_turn:300,provider_errors

Only you can set a goal (the agent may propose one, which you adopt with /goal adopt <id>). The agent then works in rounds: it reads a noise floor, commits a change to its own Body, files a prediction (which card, which direction, how sure), and promotes the change. The Root, which the agent cannot change, keeps the books:

  • Cards. Six observation cards computed from what the Root already meters on your turns: cost, wall time and model requests per turn, cache reads, provider errors, and your corrections. A reading compares the change's first turns with the turns before it: mean, σ, the standard error of the difference, z, and a verdict (better, worse, noise).
  • Registered predictions. A reading counts for the agent only if its prediction was filed before the change went live. The forecasts are scored (Brier), and the score sets one thing: how many rounds the agent may run before it checks in with you (3 by default, 1 to 12). It never touches the autonomy ladder or your budget.
  • Guardrails. A guard= card that gets worse beyond your tolerance rolls the change back, and only that change.
  • The budget is yours (usd, wall, rounds). The Root charges the goal every metered request while it is active and stops the goal at its budget.
  • met must be earned. For a card goal the Root checks the agent's met: the card must have reached your threshold and a registered change must have moved it beyond noise in the predicted direction. Otherwise it records met_unattributed and tells you.

The loop itself (how to choose a mode, when to keep a change, when to stop) lives in two skills the agent may rewrite, gbal and goal-loop. The user guide has the details: docs/guide.md, Goals.

What the real-model runs showed

We ran GBAL four times on deepseek-flash in an isolated install, free mode, workspace access, with the goal above (records: build/status/GBAL-REAL.md). Spend is the Root's estimate, not an invoice.

  • First run ($0.065): the chain worked once, and found six bugs. The agent's first change (a "turn economy" block in its prompt) took requests per turn from 2.6 to 1.0, but its prediction named a commit it then amended, so the reading was unregistered and counted for nothing. A deliberately bad second change was predicted in time; it broke the 30 % cost guardrail and the Root vetoed it. But the kernel did not apply that rollback for 2 minutes (G2), and the agent's own rollback then went all the way back to genesis and dropped the good change too. The outcome scored the forecast regression as a miss (G4). Repeat questions in the same session also inflated the 2.6 → 1.0.
  • Rerun A ($0.076): not passed. The kernel's commit rules refused the promote after each prediction (prose in Repro:, an unknown subject type). Each amend made the prediction stale, each re-file spent one of the owner's rounds, and rounds=3 ran out before anything went live (G7). The bad change was rolled back to its parent in 3.9 s (the G2 fix held).
  • Rerun B ($0.053): round 1 only. Round 1 was registered: requests 2.4 → 2.0, z +1.64, noise, scored o = 0. Round 2's prediction was refused because the re-files had used up the check-in interval, and the agent promoted anyway, so round 2 was unregistered.
  • Rerun C ($0.060): the full chain. Round 1 (after two amends and three filings) was registered: 2.4 → 2.0, noise, o = 0. After the owner's check-in, round 2, the deliberate regression, was predicted worse at p 0.9, read worse (cost +137 %, z −14.7), rolled back by the guardrail to its parent in 3.8 s with the good change kept, and scored as a hit (o = 1). Brier 0.106 over n = 2.

What we take from this: the Root's record, guardrails and rollback work on a real model. The two goal changes that were registered read as noise. Two that read better were not registered: the first run's (z +6.6, inflated by repeat questions) and run A's (2.2 → 1.2 requests per turn on new questions, z +3.5, predicted on a stale commit). So the runs show the instrument, not a gain. They also found the bugs below. In B and C the agent stopped as met on a reading that was noise. Under v0.4's rule that is met_unattributed.

Fixed after those runs (all tested at $0; not yet rerun on a real model)

  • G7: re-files no longer spend your rounds. initctl promote --check evo/<id> runs promote's commit checks (subject, trailers, the exact Repro: forms) and promotes nothing; the gbal skill runs it before every prediction. A re-file that replaces the agent's newest prediction while its change has never gone live keeps the same round and check-in step, and the old prediction closes as superseded.
  • met requires attribution, as above.
  • The goal's meter equals the egress ledger. It used to add each closed turn's cost and missed the turn in which the agent stopped the goal (run C: 51,290 against the ledger's 59,718 µUSD). It now charges every request at settlement, and the $0 end-to-end test checks the two agree to the µUSD.
  • G2: a guardrail rollback of a free-path change whose parent is not the kernel's last known-good is applied at once, to the parent (3.8–4.2 s in the reruns), and initctl rollback undoes only the change group of the running version.
  • G4: an outcome scores what was forecast, on the prediction's own card. A regression the agent predicted and your guardrail caught is a hit, not a miss.
  • G1, G3, G5, G6: an owner turn closes when the agent goes idle (lines 2 s apart were one turn and the cards saw nothing); a prediction for a change already live is refused with the reason; Predicts: accepts card:<id>; the skill says to predict on the final commit, before promote.

Fixes found in the real-model demo of 2026-10-25

  • A fresh gated install rolled back every T1/T2 change about 1.3 s after its swap: with no sealed tasks and an empty pool, the G4 gate had nothing to measure, read that as inconclusive, and the incumbent won. No instrument is now no G4 evidence: the change is kept on G0–G3 (as a T0 change is), with a g4_no_instrument alert.
  • An owner /rollback quarantined GENESIS.md, SELF.md and four seed skills. The seed's own files are now a baseline that no change group owns, so a rollback never quarantines them.
  • Switching extend.mode while INIT ran was not picked up: the next handoff was refused and the whole system restarted. The Root now pushes the new mode to the running kernel. An incident at L0 is recorded as a floor, not as a demotion.
  • Gate notices said only [kernel] gate. They now say which stage, the verdict, the commit, the reason and what happens next.
  • An owner line's acknowledgement could arrive before the line was registered, so the line counted as unanswered; two in a row could restart the kernel or roll back every open change. The acknowledgement is now kept until its line arrives.
  • The user guide documents /rollback, /goal, and that the free path needs the disk floor plus 2 GiB.

Limits

  • No gain is shown yet. GBAL measures whether a self-change helps. In the runs above no registered change helped beyond noise; the one clean-looking gain (run A, z +3.5) was unregistered, from one run. The value so far is the honest record, not a result.
  • Cards read your turns, so a reading takes n turns (5 by default) on each side. At a few turns a day that is slow.
  • An agent can lower cost_turn by doing less. Use corrections as a guardrail.
  • Only the card goals (done=card:…) are checked by the Root. exemplar and owner goals are judged by you (/goal accept|reject). Task cards and artifact capture (ADR-013 phase 2 and 3) are not built.
  • One goal is active at a time.
  • Autonomy is still capped at L0; DeepSeek is the only provider tested live; Linux is aarch64 only and experimental.

Install

curl -fsSL https://github.com/nagisanzenin/INIT-Agent/releases/latest/download/get.sh | sh
init        # first run: pick a provider, paste a key (hidden), pick a model

In-place upgrade is not supported yet: the installer refuses when INIT is already installed. Run the current install's uninstall.sh first (it moves both homes to the Trash; nothing is deleted), then the line above.

Verified for this release

On these exact bundles (built from 4a76b12), at $0 on the mock model unless noted (full record: build/status/REL-040.md):

  • macOS fresh install (a temp home with no Rust; get.sh installs Rust 1.97.1 with wasm32-wasip2 and clippy into it): installed and T2-capable in 56 s, first reply at 59 s.
  • macOS no-op T2 promote on a fresh bundle install, through the shipped gate: G0–G3 and the hot-swap handoff pass (G0 6.6 min including the cold build, G3 5.0 min, 12.1 min end to end).
  • Linux fresh install in a fresh Ubuntu 24.04 container (aarch64, Docker, no Rust preinstalled, bubblewrap 0.13.0): installed and T2-capable in 53 s, first reply at 54 s.
  • **Pause and resume on b...
Read more