Build agents you can test, that can't break their rules, and that don't forget.
Describe the agent you want. Genesis interviews you until every requirement is confirmed, writes the agent's tests before it writes the agent, and installs it into your repo — as a subagent you call by name, or as the folder's own Claude — wired to rules it can't talk its way past, and a memory of its own that gets sharper the more you use it. Every claim below is a file in the repo you can open.
Genesis is self-hosting: its own agents built it, under the same rules it enforces on everything else — the proof is CLAUDE.md in the repo, the persona of the agent that maintains it. It is also used in production: agents built with Genesis work as the engineers on live systems, from ML operations to a decades-old .NET/C++ codebase, under those same enforced rules.
In plain words — "an agent that reviews my pull requests for security issues."
/genesis:new · or "use sensei to build…"
02
Sensei interviews you
Restates every requirement back and builds nothing on a guess. It won't even choose one agent or a team for you — that's your call, and so is what the agent must know.
verified facts only · escalates every decision · a hook blocks assembly unless the expertise step actually ran
03
Method writes the tests first
It writes what the agent must pass — refuse this, escalate that, stay in its lane — proves those tests fail without the agent, then writes the smallest agent that passes them.
red baseline → green · adversarial + persona-leak + contradiction scans · nothing ships untested
04
It lands where you choose
A named subagent you call on — or the folder's own Claude. Full enforcement either way, and your teammates get it on a clone.
.claude/agents/<name>.md · or --main · the tools list is a real boundary
Then, every time it runs
It can't break its own rules.
Not because it remembers them — because four checks sit outside the model and simply refuse.
injectHands it the rules at the start of every session.
gateBlocks the write itself — a banned phrase, a password, an over-long file.
validateWon't let it finish until it cites which rules it applied — and the evidence matches the files it actually wrote.
reviewA separate, faster model reads the artifacts and the rule manifests itself — and can only block, never bless.
one native binary — a check costs 2–10 ms, not a Node process per tool call · fail-closed · a fabricated rule-id or invented evidence blocks the turn
It remembers, and it sharpens.
Every agent gets its own vector database, on your machine — one file, no cloud and no account. It searches by meaning, not by keyword match.
storeKeeps a decision or fact worth carrying forward. The agent chooses what's worth keeping — it isn't taping everything.
recallFinds it again next week from a loose paraphrase — and the act of using it makes that memory stronger.
consolidateFolds near-duplicates into the one that earned its place, and keeps the trail of what it replaced.
↻What gets used keeps its weight. What nobody touches halves every 30 days. That's the agent getting better at your work.
SQLite + sqlite-vec KNN · 384-dim embeddings computed locally, no network · scoped per agent_id · committed as JSONL, so a teammate's clone rebuilds it
New
The agent doesn't have to be something you summon.
Promote it to the folder's ClaudeOne command and the agent you built becomes Claude Code in that folder — its persona is the folder's brief, its enforcement moves to the main thread. Nothing to remember, nothing to invoke. It stays available as a subagent too.
And change your mind freelyDemoting puts the folder back exactly as it was. Your own notes and your own hooks are never touched — Genesis only ever adds and removes its own marked block.
/genesis:promote <name> · /genesis:demote · or build it that way from the start (assemble --main) · a managed block in CLAUDE.md + --main-agent hooks in .claude/settings.json · idempotent and non-destructive
No mocksthe memory server's suites run against the real embedding model, the real database and the real spawned server. A missing model fails the run — it never quietly skips.
62.5s → 0.55sthe finish-check on a 21,000-file project, after the hooks were rewritten in Rust. It stopped walking your build folders.
17 / 17decisions the new native hooks had to reproduce byte-for-byte from the ones they replaced — before those were deleted.
30 daysto halve an unused memory's weight. Every recall pushes it back up.
How agents get built today
You paste a persona from a blog post and hope it holds — then re-explain your project from scratch tomorrow. It doesn't hold: instruction-following drops ~39% from a single turn to a conversation, and half the guidance is effectively gone by 32K tokens.
Laban et al. 2505.06120 · NoLiMa 2502.05167 — cited in expertise/expertise-application.md
With Genesis
The agent can forget all it likes — the gate still denies the write, and the validator still refuses the finish. And what it learned last month is still on your disk this morning, weighted by how much it actually got used.
the whole design in one line: determinism lives outside the model
Install it, ask for an agent — then read the tests it wrote before it wrote the agent.
# in Claude Code, from your project: /plugin marketplace add Atiqul-Islam/genesis /plugin install genesis@genesis > Use sensei to build an agent that reviews my diffs for security issues.
Part two
What everything does
Every surface Genesis exposes, and what it is for. You will only ever type the first group — the slash commands. Everything below them is machinery those commands drive on your behalf, listed so nothing is a black box.
Slash commands
3
The whole user-facing surface. Typed in Claude Code, from your project folder.
/genesis:new
Start a build. Sensei interviews you, then delegates the authoring to Method. Nothing about Genesis runs until this is invoked — the plugin is dormant otherwise.
optional argument: what the agent should do
/genesis:promote <name>
Turn an already-built agent into the folder's main Claude. Its persona is merged into CLAUDE.md as a managed block and its enforcement moves to the main thread. The agent stays available as a subagent too.
non-destructive · idempotent · one agent is main at a time
/genesis:demote
The exact inverse. Strips the managed block and the main-thread hooks, preserving everything else you had. Takes no argument, because only one agent is ever main.
reports which agent was demoted, or that none was
The team that does the building
3
Installed into your project on plugin install. Separate roles, separate tool lists.
sensei
The coordinator, and the only one you talk to. Gathers and verifies every requirement, decides the plan with you, then assembles, wires and installs. It never authors a persona itself and never guesses.
The test-first craftsman. Writes each agent's acceptance tests before the agent, then the smallest persona that passes them. Has no Agent tool, so it physically cannot delegate — the boundary is config, not a promise.
The memory specialist. Structures each memory the moment it's written and keeps every agent's store contradiction-free through deterministic bi-temporal supersession — so recall reflects the latest truth without deleting history. It runs right after a memory is stored, and never orchestrates.
One native binary, genesis-hook, dispatched by its first argument. A check costs 2–10 ms. Dormant unless a Genesis agent is active.
inject
At session start, hands the agent the house rules and pointers to its expertise store — and, for a session-copied agent, its carried-over digest.
SubagentStart / SessionStart
gate
Blocks the write itself. A banned phrase, a credential value, or a persona over the 200-line budget is refused at the moment of writing — and the governing rules are re-surfaced right before the attempt.
PreToolUse on Write|Edit
enforce-research
Refuses to assemble a new agent unless the expertise-research step actually ran. Resume-safe: it scans sibling transcripts and writes a durable marker, so a compaction can't make confirmed research invisible.
PreToolUse on Bash · Sensei-scoped · built-in agents exempt
validate
Won't let the agent finish. It must cite the rules it applied — real ids from the manifest, at least three, with evidence that resolves to a file it actually produced or a quote that appears in one. Fabricate any of it and the turn is blocked.
Stop / SubagentStop · fail-closed · a 21,000-file tree checks in 0.55 s
session-pointer
Records the live session id so "copy my current session into an agent" knows which session to capture. Fails open and silent — it must never disturb a session.
writes .genesis/current-session.json
Build & install — genesis-cli
10
The one-time build-and-wire layer. Runs at install time, never per tool call. Sensei drives these for you.
assemble
Turns an authored persona into a real installed agent — as a subagent, or with --main as the folder's own Claude. Registers its required expertise and installs its skills either way.
writes .claude/agents/<name>.md — or CLAUDE.md + .claude/settings.json
bootstrap
Makes a repo a self-contained Genesis workspace: copies the expertise store and hooks into .genesis/, stages the native binaries, registers the memory server, and manages a .gitignore block so the agent's brain and memory travel with the repo.
installs sensei + method wired to the repo-level .genesis
promote · demote
What the two slash commands run. Promote merges the persona into CLAUDE.md and wires the main-thread hooks; demote removes only Genesis's own block and its --main-agent entries.
your content and your hooks are never touched
install · build-plugin-agents
Assemble Genesis's own team into a target repo; and regenerate the plugin's committed agent files from source, so the shipped ones can be drift-checked against a fresh render.
the plain install path · maintainer tooling
capture
Session-copy, step 1. Extracts your current session from all six stores and scrubs credentials on the way out.
transcript · auto-memory · context-mode DB · claude-mem · genesis DB · user config
store · embed
Steps 2 and 3. Turn the captured records into a portable history plus a deterministic digest, then write each record into the new agent's memory so it can recall its inherited history by meaning.
history.sqlite + summary.md · then an MCP stdio client writes them under the agent's id
build-session-agent
Runs all three in order and resolves --session current from the session pointer. The "copy my current session into an agent" entry point.
credentials are never copied; --known-secret forces removal of values you name
Memory — the MCP tools every agent gets
3
A vector database per agent, on your machine. Scoped by agent id, so an agent only ever sees its own memories.
store
Keep a durable fact or decision. The agent chooses what is worth keeping — this is not a transcript recorder.
embeds the text and writes the row + its vector in one transaction
recall
Find it again later from a loose paraphrase — nearest-neighbour search by meaning, not keyword match. Using a memory makes it stronger.
returns id, text and distance, nearest first · k defaults to 5
consolidate
Fold near-duplicates into the one that earned its place, summing their use counts and keeping a trail of what was replaced.
weight halves every 30 days unless recalled · summarise/evict deferred to v2
The launcher
6
The one remaining Node file: the irreducible bootstrap, since something has to download the first binary. Standard library only.
(no argument)
Downloads and SHA256-verifies the memory server for your platform, caches it per user, and execs it over stdio for Claude Code's MCP channel.
what .mcp.json runs
--run-hook · --run-cli
Resolve and run one of the native binaries. The hook path fails open — an unresolvable check must never block your session. The installer path fails loud, because you asked for it explicitly.
assembled agents skip the shim entirely and call the binary directly
--stage-hook · --stage-cli
Copy a binary into a repo's .genesis/bin so its enforcement runs natively with no Node in the hot path.
used by bootstrap
--sync
Refreshes an already-bootstrapped repo's staged binaries when a stamp shows they are stale. This is how /plugin update actually reaches your repos — no manual staging.
a one-file-read no-op otherwise · run automatically by the plugin
Skills
22 + 11
Procedures the agents follow. Twenty-two are Genesis's own; eleven are vendored verbatim from the MIT-licensed superpowers plugin by Jesse Vincent, so Genesis ships self-contained.
build-agent · research-expertise
The build itself: the exact procedure Sensei follows, and how an agent's expertise is chosen and researched — always with you, never silently. Assembly is blocked until the second has run.
spec-forge · spec-build
Supervisor-led multi-agent builds — nine steps, five specialists, the same gates. Forge adds worktree isolation, structured plans, TDD discipline, systematic debugging and local code review at every gate.
The manual escape hatches: write a spec, compile it to Gherkin plus unit stubs, run the suites, simplify, and score every function for change risk — failing the build above the threshold.
the five specialists ×2
spec-agent · dev-agent · verify-agent · review-agent · docs-agent, and their forge- counterparts. Silent workers; the supervisor is the only voice you hear.
Four worked examples: one expert agent, a team, making an agent the folder's own Claude, and cloning the session you're already in. You drive all of them from a single command — the rest is Sensei asking you questions and refusing to guess at the answers.
Example one · the common case
Build a single expert agent
Say you want an agent that reviews your pull-request diffs for security problems — and you want it to actually know something about the subject, not just be told to "be careful". This is the path most builds take.
01
Ask for it
One command, in the folder you want the agent to live in. Put the whole request on the line, or type nothing and let Sensei start the interview.
/genesis:new an agent that reviews my pull-request diffs for security issues
02
Sensei interviews you — and restates it back
It gathers the goal, what done looks like, the exact tools the agent may use, and when it should stop and escalate to you. Then it repeats every requirement back and builds only on what you confirm.
It also asks two questions it will never answer for you: is this one agent or a team, and does it install as a named subagent or as this folder's main Claude.
03
You choose what it must know
Sensei proposes the expertise the agent has to apply — for a security reviewer, that might be your threat model and your review standard. You add, drop or change it, and you decide whether to have it deep-researched now against sources you name.
This step cannot be skipped.
A hook blocks assembly outright unless the research step actually ran this session. The point is that no agent is ever built on expertise nobody chose.
04
Method writes the tests first
Sensei hands Method a task-spec. Method writes the agent's acceptance tests before the agent — must refuse this, must escalate that, must stay in its lane — proves they fail without the agent, then writes the smallest persona that makes them pass.
a persona that passes because the base model would have done it anyway is a test that proves nothing — hence the failing baseline
05
It lands, wired
The finished agent is written into your repo with its enforcement hooks attached and, if you asked for it, its own memory. Your teammates get it on a clone.
# what you now have
.claude/agents/security-reviewer.md the agent
.genesis/expertise/ what it must apply
.genesis/bin/genesis-hook what enforces it
06
Use it
It is an ordinary Claude Code agent from here — call it by name. The difference is what happens while it runs: it cannot write a credential, cannot exceed its budget, and cannot finish a turn without citing the rules it applied.
> Use security-reviewer on the diff for this branch.
Example two · when one isn't enough
Build an agentic team
A team is a supervisor plus specialists, each with its own narrow job and its own tools. It is genuinely more expensive — multi-agent work costs several times the tokens of a single agent — so Genesis makes you earn it.
01
Ask for the outcome, not the org chart
Describe what you want done. Sensei decomposes it; you are not expected to design the roster.
/genesis:new a team that audits our repos: one pass per repo, then a single consolidated report
02
The single-agent-first gate
Before anything is built, Sensei applies a test drawn from its own teams expertise: would one agent do? A team is justified only by a named limitation of the single agent — work that exceeds one context, subtasks that are genuinely independent, parallelism that materially cuts latency.
If one agent suffices, you get one agent.
That halt is a feature, not a failure. And Sensei will still not decide team-vs-single for you — it puts the recommendation and the reason in front of you, and you choose.
03
The roster gets decided with you
One specialist per independent responsibility, each scoped to a job you could state in a sentence, each given only the tools that job needs. Sensei states the plan back before building anything.
The supervisor
Decomposes, delegates, verifies each result, synthesises, and decides when the work is done. It owns the outcome and does none of the specialist work itself.
Each specialist
One coherent job, least-privilege tools, and an explicit out-of-scope rule so it hands work back rather than improvising outside its lane.
04
Every member is built the same way
Expertise chosen with you, tests written first, assembled with full enforcement. A team is not a shortcut around the discipline — it is the same discipline, several times.
delegation is a contract, not a sentence: each specialist receives an objective, its inputs, an output schema and acceptance criteria — and every result is untrusted until the supervisor checks it against them
05
Genesis is itself the worked example
Sensei and Method are a team built on this pattern: a coordinator that never authors, and a craftsman that never orchestrates — with the boundary enforced by the tool list, not by asking nicely. Method has no Agent tool, so it physically cannot delegate. (Mneme, the memory specialist, makes three agents in all.)
Example three · promotion
Make an agent the folder's own Claude — and undo it
A subagent is something you summon by name. A promoted agent simply is Claude Code in that folder: its persona becomes the folder's brief and its enforcement moves to the main thread. It stays available as a subagent too.
01
Decide at build time — or change your mind later
Sensei asks during the interview. If you said "subagent" then and want to switch now, one command does it. Only one agent is the folder's Claude at a time, so promoting a different one simply replaces the block.
/genesis:promote security-reviewer
02
What actually changes on disk
Two files, both edited surgically. Genesis writes between its own sentinels and leaves everything else exactly as it found it.
Your own CLAUDE.md content and your own hooks are preserved. Re-running is idempotent — you get one block, not two.
03
Reopen the folder
The main-thread persona and hooks take effect on a fresh session. From then on there is nothing to invoke — the folder's Claude is your agent, with the same enforcement it had as a subagent.
04
Undo it whenever
No agent name needed — only one is ever main. The managed block and the main-thread hooks come out; your content and hooks stay; the agent remains available as a subagent. If nothing was promoted, it says so and changes nothing.
/genesis:demote
Example four · the unusual one
Turn the session you're in into an agent
Sometimes the context you want an agent to have is the conversation you are already having. Genesis can capture the live session and hand it to a new agent as memory — then specialise it the normal way.
01
Ask for a single agent, and say yes to the copy
For single-agent builds Sensei offers the choice explicitly: a fresh agent, or a copy of your current session. It never assumes.
02
Everything is captured — and scrubbed
Six stores are read: the transcript, auto-memory, the context-mode database, claude-mem, the Genesis database and your user config. Credentials are scrubbed on the way out, and you can name specific secret values for guaranteed removal.
Credentials are never copied.
Scrubbing runs over six credential shapes plus anything you list explicitly, and it has its own unit tests — this is the security-critical step in the pipeline.
03
It becomes memory, not a transcript dump
The captured history is embedded into the repo's memory under the new agent's id, plus a short digest it loads at the start of every session. The agent recalls the rest by meaning, on demand — it doesn't carry the whole conversation in its context.
the bundle lives in the repo and travels with a git clone — no dependency on your ~/.claude
04
Then the normal build continues
Method authors the specialised persona on top, and the assembler wires it. You end up with a named agent that already knows everything the two of you worked out.
Worth knowing up front
Four things Genesis will refuse to do
These are not rough edges. Each one is a deliberate decision, and each is enforced by something outside the model — so it holds even when the conversation gets long.
It won't decide for you
Single agent or a team, subagent or main Claude, what the agent must know — Sensei asks and waits. Tell it "you decide" and it will still put the choice back to you.
It won't skip the research
A hook blocks assembly unless the expertise step ran. Being in a hurry is not an accepted reason.
It won't ship untested
Method writes the tests before the agent and returns only when they pass. Ask it to skip them and it refuses.
It won't let an agent finish quietly
An agent must cite the rules it applied, with evidence that resolves to something it actually wrote. Fabricate a rule id and the turn is blocked.
Part four
Releases
17 releases to date — one alpha, then the beta line. The arc is short and legible: get off Node, get off npm, make the gestures good, then re-architect memory and ship the binaries. The headline releases are below; the full list is on GitHub. Newest first.
v0.2.0-beta.22026-08-18currentrollup · fix
Live binaries, portable workspaces, and a self-healing update
The 0.2.0 line's latest: the release binaries are published and SHA256-verified on first use, and an update now heals older workspaces.
Prebuilt binaries are live — genesis-memory-server, genesis-hook and genesis-cli plus the pinned model ship as GitHub Release assets for macOS and Linux (x64/arm64) and Windows (x64).
Portable workspaces — bootstrap emits ${CLAUDE_PROJECT_DIR}-relative paths, never an absolute machine path, so a generated .mcp.json and settings survive a clone or move.
Self-healing update — the launcher's --sync regenerates the managed .gitignore on every plugin update, so an older repo starts committing its memory DB without a re-bootstrap.
Turn-scoped expertise validation and atomic decision-log writes in the enforcement binary.
v0.2.0-beta2026-08-15the memory re-architecture
Mneme, and a bi-temporal memory store
The headline of the 0.2.0 line: a third agent, and a memory store that stays contradiction-free by construction.
Mneme — a dedicated memory specialist that structures each memory as it's written and supersedes contradicting facts deterministically, rather than letting them pile up.
Bi-temporal supersession — every fact carries when it was true and when it was recorded, so recall reflects the latest truth without deleting history.
v0.1.0-beta.82026-08-09rollup
Promote / demote, a resume-safe gate, a working update, and honest docs
A cumulative release that gathers everything since beta.3 into one version. No code changed since beta.7 — only the version bump and the documentation corrections.
/genesis:promote and /genesis:demote, from beta.6 and beta.7.
The resume-safe research gate, from beta.4.
/plugin update version lockstep and repo auto-sync, from beta.5.
Contributor docs corrected and made drift-proof — the test counts had gone stale for the second time, so the docs now describe what each suite covers and point at cargo test as the source of truth, rather than pinning integers that rot.
v0.1.0-beta.72026-08-09gesture
Demote — the exact inverse of promote
Promotion without a way back is a trap. This adds the undo, and makes it precise: it removes only what Genesis put there.
genesis-cli demote plus the /genesis:demote command. Strips the managed persona block from CLAUDE.md and the --main-agent hooks from .claude/settings.json, preserving all your other content and hooks. The agent stays a subagent.
No agent-name argument — only one agent is ever the main Claude, so there is nothing to disambiguate. It reports which agent was demoted, or that none was promoted.
The removal is name-agnostic: it matches on the sentinels and the --main-agent marker, so it works even if you have forgotten which agent you promoted.
Verified with a demote round-trip that asserts your content and hooks survive, plus a live promote→demote smoke test.
this release carries BOTH gestures — promote (beta.6) and demote
v0.1.0-beta.62026-08-09gesture
Promote — make an existing agent the folder's main Claude
The capability had existed since beta.2 as an installer flag. This turns it into something you can actually reach: a slash command, consistent with /genesis:new.
/genesis:promote <agent-name> runs the installer through the plugin launcher, so there is no manual staging — a bare plugin install can promote.
Merges the agent's persona into CLAUDE.md as a managed block and wires the main-thread enforcement hooks into .claude/settings.json. Non-destructive and idempotent.
The agent stays available as a subagent as well.
No demote command yet at this point — promoting a different agent simply replaced the block.
v0.1.0-beta.52026-08-06reliability
/plugin update actually works now
Updating the standard way was silently broken in two separate places. Both are fixed, and both are now impossible to regress.
The plugin version was never bumped — stuck at 0.1.0 across beta.1 through beta.4 — so the plugin manager saw no new version and the update was a no-op.
A repo's staged binaries never refreshed, so an already-bootstrapped project kept running the old hook binary after an update.
Fix one: the version script sets the plugin version and the launcher's release version in lockstep, and the release job now refuses a tag whose versions disagree — they can never drift apart again.
Fix two: the launcher's --sync refreshes a repo's staged binaries when a stamp shows they are stale, and the plugin runs it automatically. A one-file read when there is nothing to do.
v0.1.0-beta.42026-08-06reliability
The research gate stopped forgetting
The gate that requires expertise research before a build proved it by scanning the current session's transcript. A resume or a compaction starts a new transcript — so research you had already done became invisible, and an in-progress build was wrongly blocked again.
Defence one: scan every transcript in the session's project directory, not just the active file — a resume leaves the earlier one sitting alongside it.
Defence two: on first confirmation, write a durable per-agent marker, so a later session change, compaction or transcript pruning can never undo it.
The requirement itself is unchanged — research is still mandatory. Only the forgetting was removed.
v0.1.0-beta.32026-08-04port
Session-copy goes native — the launcher is now the only Node file
The last remaining Node pipeline becomes part of the Rust installer, finishing the "everything except the fetch-launcher is Rust" mandate.
capture extracts and credential-scrubs all six stores; store builds a portable history plus a deterministic digest; embed writes each record into the agent's memory; build-session-agent orchestrates all three.
Credential scrubbing is the security-critical part — a faithful port of six credential shapes plus explicit known-secret redaction, with its own unit tests.
The Node session-copy scripts and their tests were deleted; the coverage moved to Rust, including a full round-trip against the real binaries.
v0.1.0-beta.22026-08-04port · capability
An all-Rust installer — and agents that can be the folder's Claude
The whole install layer becomes one native binary, and the promotion capability appears for the first time.
The Node installer becomes genesis-cli, byte-identical to the version it replaced — the subagent file, the main-Claude wiring, and the committed plugin agents were all verified by diff before the Node code was deleted.
New capability: build an agent directly as the folder's main Claude, or promote an existing one. Persona into a managed CLAUDE.md block, enforcement onto the main thread, non-destructive and idempotent — with full enforcement retained.
The launcher gained --stage-cli, --run-hook and --run-cli, so a bare plugin install can run the orchestrator with no binary on disk yet.
Only the registry-free fetch-launcher stays in Node — the irreducible bootstrap.
v0.1.0-beta.12026-08-03the big one
Native enforcement hooks, and goodbye to npm
The release the rest of the beta line is built on: the enforcement layer stops being Node, and distribution stops needing a package registry at all.
The Node hooks become one native binary, genesis-hook, with gate / enforce-research / inject / validate / session-pointer as subcommands — byte-identical decisions, 17 of 17 verified before the old ones were deleted.
The finish-check went from 62.5 seconds to 0.55 on a 21,000-file tree, by no longer walking build directories.
The semantic review moved onto a built-in agent hook — a fast, tool-capable model that reads the artifacts itself, instead of shelling out twice per expertise.
npm dropped entirely. Binaries and the model now ship as GitHub Release assets, downloaded and SHA256-verified by a standard-library-only Node launcher and cached per user. Publishing needs only the token GitHub provides — no registry account, no npm token.
v0.1.0-alpha.12026-08-03alpha · npm era
ARM builds, on real ARM machines
The last alpha, still on the npm distribution model that beta.1 replaced the same week.
Linux ARM64 (both glibc and musl) and Windows ARM64 moved onto native ARM runners — the inference engine's hand-written ARM64 SIMD compiles there, where cross-compiling from x64 had failed.
Re-running at the same version added the three ARM platform packages while the six already published were skipped.
two platforms remain deferred and are tracked in TODO.md — Alpine-on-ARM and Windows-on-ARM, both blocked upstream rather than by CI configuration