Repository navigation
Releases
INIT v0.6.0-preview
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 | shThen 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
PATHblock of a fresh v0.5.4 install (it puts~/.local/binfirst) 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 newinit-agent doctorshows 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 installs1.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
exactrustup toolchain install …command;init-root toolchain --setlooks for the same toolchain first. - When
~/.local/binis already on yourPATHbefore/usr/bin, through a line that is not INIT's, the install
writes no block and now says so with a WARNING (the stock~/.profileof 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
onPATHyet 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 upgradereadsINIT_ROOT_HOMEfrom 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:
With a custom
/usr/bin/curl -q -fsSL https://github.com/nagisanzenin/INIT-Agent/releases/latest/download/get.sh | /bin/bash -p -s -- --upgradeINIT_ROOT_HOME, putINIT_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
effortline, 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...
INIT v0.5.6-preview
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 | shThen 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 onlyHOME, that home and the systemPATH. - 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 upgradereadsINIT_ROOT_HOMEfrom 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:
With a custom
/usr/bin/curl -q -fsSL https://github.com/nagisanzenin/INIT-Agent/releases/latest/download/get.sh | /bin/bash -p -s -- --upgradeINIT_ROOT_HOME, putINIT_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
~/.configto~/cfgcopyand read~/cfgcopy/init-agent/<provider>.key; - clone
~/Documentsand read aread_denyentry inside it, clone~/Libraryand read the Root's LaunchAgent, or
clone your whole home and read~/.init-rootand~/.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
PATHblock puts the system's commands first only when INIT writes it. When~/.local/binis already on
yourPATH(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/binfirst. 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
withclonefile, and by descriptor withfclonefileatandclonefileat) 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/Datapaths 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 withscripts/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-selfmaps08/s12and the
Root'swp21. 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/tmpon 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 upgradeand this bundle said ship
(4 min; the upgrade took 20 s); a new user, installed with--no-rustand 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...
INIT v0.5.5-preview
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 | shThen 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 onlyHOME, that home and the systemPATH. - 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 upgradereadsINIT_ROOT_HOMEfrom 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:
With a custom
/usr/bin/curl -q -fsSL https://github.com/nagisanzenin/INIT-Agent/releases/latest/download/get.sh | /bin/bash -p -s -- --upgradeINIT_ROOT_HOME, putINIT_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. ThePATH=/usr/bin:/bin:/usr/sbin:/sbinprefix that v0.5.4's notes gave is no longer needed: the
uninstaller the line downloads sets thatPATHitself.
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
~/Libraryand putting a prepared one in its place; - read the key files or a
read_denyentry under a new name:mv ~/.config ~/.cfg, then read
~/.cfg/init-agent/; or, with~/Documents/taxinread_deny,mv ~/Documents ~/Docs2, then read~/Docs2/tax.
The same worked for the keys of a~/.init-rootnested 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:
With a custom home, put
/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'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:/sbinbefore anything else. v0.5.4's ran
env,sed,grep,mv,stat,launchctland others from yourPATH, where v0.5.4's block puts the
agent-writable~/.local/binfirst, so a planted~/.local/bin/envran as you, outside the sandbox. The shell the
AppArmor step pipes its commands to runs as/bin/bash -ptoo, like the scripts themselves, so a plantedBASH_ENV
does not run there. Everysudoline install.sh and the uninstaller print is/usr/bin/sudo. - The
PATHblock appends~/.local/bin:export PATH="$PATH:$HOME/.local/bin"(fish:
contains -- '<dir>' $PATH; or set -gx PATH $PATH '<dir>'). A command you type, such assudo,bashor
launchctl, is then the system's, never a file a full-access agent dropped into~/.local/bin, andinit-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 (~/.zshrcto~/.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-ROOTare 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'sPATHblock put its command directory first, and a bareinit-agentin 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...
INIT v0.5.4-preview
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 | shThen 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 upgradereadsINIT_ROOT_HOMEfrom 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 asbash -p, so bash runs noBASH_ENVfile,SHELLOPTSor exported function from your environment, and it
hands the upgrade to the kept get.sh with onlyHOME, that home and the systemPATH. 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:
With a custom
/usr/bin/curl -q -fsSL https://github.com/nagisanzenin/INIT-Agent/releases/latest/download/get.sh | /bin/bash -p -s -- --upgradeINIT_ROOT_HOME, putINIT_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:/sbinin 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 upgradeuses only the home it was installed with, and runs the kept get.sh underenv -iwith only
HOME, that home and the systemPATH. Until 0.5.3 a plantedINIT_ROOT_HOMEmade 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 -iline to 0.5.1, 0.5.2 and 0.5.3 owners. It printed the plaininit-agent upgradeto
0.5.1 and 0.5.2 owners, not the line the v0.5.3 notes gave. - The uninstaller's
panicadvice names the install. On a custom home it printed a bareinit-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 underbash -p, so a planted
SHELLOPTS/PS4cannot swap the downloaded uninstaller. The 0.4.1/0.5.0 upgrade pipe runs/bin/bash -p -stoo. - The
--no-rustand 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
--fromform), 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) andinit-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 aprice_driftalert, 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_creationlifetime; it is fixed the same way. Its write
total is now checked against itscache_creationsplit 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 ascache_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'saudio_tokens) is billed at the input price and again at the dearest.
The app
From the v0.5.3 user sessions:
/helplists/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+G0step: the kernel does not say when
the dependencies end and G0 starts, so v0.5.3'sdeps □beside a G0 "to come" was wrong for the last minutes. /detailsand 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 itscall_id)./modelandinit-root providers listshow the cache-read price beside the input and output prices, from the
charter the Root bills with./usage'sthis TUIrow counts only the requests this TUI ran; requests replayed after a relaunch are named apart.
From the v0.5.4 user session:
/panicstops 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/panicand/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
escapeeline would
mean, and that the agent restarts on the last version that passed INIT's audit. /detailspoints...
INIT v0.5.3-preview
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. Theenv -imatters: in full
access, an agent could have plantedINIT_DIST_URLin 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 plantedINIT_ROOT_HOMEstill can until
v0.5.4 (0.5.3'sinit-agent upgradeprefers 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:
With a custom
/usr/bin/curl -q -fsSL https://github.com/nagisanzenin/INIT-Agent/releases/latest/download/get.sh | /bin/sh -s -- --upgradeINIT_ROOT_HOME, putINIT_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_driftalert;/usageshows 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
/rollbacknow works on the gated path. More credential stores, every other INIT install's homes and
~/.init-releaseare denied to the agent. - Every printed
init-agentcommand 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;/helpdoes not list/rollback; the upgrade's "offering its new
seed" line is unexplained; the gate track showsdeps □while G0 already runs;/detailsshows 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/undorestores 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 verifyagainst 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
/undoand 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
/undotyped 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
/undopath issues, an audit
pointer race, a halt that could be cleared, a gameablemet, 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.shon 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...
INIT v0.5.2-preview (readiness patch; macOS + Linux x86_64 research preview)
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 -- --upgradeIf 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". /undoafter you reopen INIT goes back to before the agent's edits. It restores the newest snapshot that
differs from your folder./undo listshows the snapshots, and/undo <id>picks one. A launch where nothing
changed no longer takes a snapshot.- An unknown command such as
/undo lstis refused in the TUI instead of being sent to the model and billed.
/helplists the commands. Start a line with//to send it to the model as text. - After
/panicand/resume, the footer shows the version that really runs. Before you confirm,/panicsays
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. /detailsand 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 yourPATH.
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 --commitrun by hand now also installs the new release's get.sh, soinit-agent upgradenever 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 carriesINIT_ROOT_HOME.
Known limits
/undocan 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 upgradeorinit-agent --workspace. On a fresh Mac, use~/.local/bin/init-agent …, or add~/.local/binto yourPATH. On Linux, the installer's PATH hint names~/.zshrc; bash users add it to~/.bashrc. - The
depsstep 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. /usagecan 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
/detailsoutput 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)
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 -- --upgradeThis 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.gitaside, creating a.gitfile, or renaming a directory onto
.git/modules/<m>, an agent acting against you could point git at a config it wrote. Your nextgit statusin
that repository would then run its command, outside the sandbox, with your rights. - The sandbox now denies the
.gitentry 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 FILEchecked the bundle where it lay, then unpacked it from the same place. It took
the expected SHA-256 from a.sha256file 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--sha256on 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 yourPATH, because it builds with your cargo.
The Root's own git calls ignore the repository you start them in. --version 0.5.0now finds the tagv0.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 --commitmoved the last-known-good pointer to the new version, but left the rollback anchors on the
version from before.- After
/panicand/resume, the Root reinstalled the oldinit-kerneland 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,/panicsays
what it does and runs only after you typepanic(or/panicagain); 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 aninit-agentform. 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/workand/undo
has nothing to restore. - Numbers agree.
/usageno 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 statusare 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.
- README said a small core change takes "about 2 min end to end". That was never measured. The README now gives what
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; /panicthen/resumereturns 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);/undorestores 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 listis sent to the model as a message, and billed; - a replayed turn's cost shows
$0.000; /detailsdoes not show a successful command's output.
- the first self-change of the compiled core shows its cold dependency build (about 17 minutes) as "waited", with no
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...
INIT Agent v0.5.0-preview
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 -- --upgradeAfter 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
freemode, 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 lightfor 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 inroot okor its alarm). - Pickers. Setup,
/modeland/keyuse 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'susd=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 withproviders addbefore this release has no write prices: re-add it to get the catalog's. - Linux x86_64:
get.shon a machine the release has no bundle for now names the platforms it has, instead of "download failed".bundle.shchecks that every binary matches its target triple. - Guide:
/rollback settled|lkg|twinreturns 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./modelshows 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...
INIT v0.4.1-preview (the command is init-agent; macOS + Linux aarch64 research preview)
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 ininit-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 inINIT_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 namedinitthat is not INIT's is left alone, and the installer says so. - macOS: for this release only,
initstill works. It prints that the command is nowinit-agentand runs it. The next release removes it. - System directories: the installer now refuses an
INIT_BIN_DIRthat is/sbin,/usr/sbin,/binor/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-agentas well asinitandinit-tui. uninstall.shmovesinit-agent,init-tuiand INIT's owninitto the Trash, and leaves any otherinitwhere 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 modelIn-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, installedinit-agentand noinit, 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:
initbecame the shim (init --whichprints the same asinit-agent --which, plus the notice), T2-capable in 133 s with Rust; first reply at 141 s. - A foreign
initis never touched: a source install from this release left a non-INITinitbyte for byte, and so diduninstall.sh, which movedinit-agent,init-tuiand 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/binand 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/initwas 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)
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. metmust be earned. For a card goal the Root checks the agent'smet: the card must have reached your threshold and a registered change must have moved it beyond noise in the predicted direction. Otherwise it recordsmet_unattributedand 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, androunds=3ran 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
worseat 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 exactRepro:forms) and promotes nothing; thegbalskill 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 assuperseded. metrequires 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 rollbackundoes 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:acceptscard:<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_instrumentalert. - An owner
/rollbackquarantined 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.modewhile 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
nturns (5 by default) on each side. At a few turns a day that is slow. - An agent can lower
cost_turnby doing less. Usecorrectionsas a guardrail. - Only the card goals (
done=card:…) are checked by the Root.exemplarandownergoals 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 modelIn-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...