Train

The hanzo capabilities commands.

Also for this capability: API · CLI · MCP · SDKs

The cloud's one training endpoint, /v1/train (HIP-1333): clients the caller drives on the engine, and jobs the org's linked machines or Hanzo's executor run, whose adaptation, protection, objective and output are fields and whose artifacts, bases and evaluations are what they produce.

API reference →

hanzo capabilities list

Every command takes --json for the raw response and --help for its own flags. Sign in once with hanzo auth login; the commands below use that session, and the org they act in is the one it carries.

Command	What it does
`hanzo capabilities corrections`	Answers every correction of the org's decisions, newest first, each captured (it can teach) or missing (its decision was made with capture off), and the questions they ask, each counted: what a capability is made from.
`hanzo capabilities create`	Makes a capability in draft from captured corrections of one question: that question (its key, type and labels) is the route it will be installed behind.
`hanzo capabilities disable <name>`	Takes a capability's installed version out of the org's published set: its questions are answered by base Kai, bit for bit, from the next decision.
`hanzo capabilities get <name>`	Answers one capability: its versions with their evaluations, newest first, and what its installed version did live.
`hanzo capabilities list`	Answers the org's capabilities by name, each with its state, its latest and installed versions, and what the installed one did live.
`hanzo capabilities publish <name>`	Installs a version in the org's published set, where ai attaches it to the org's decisions: the version's evaluation must have passed, and it must have been taught over the base Kai serves now.
`hanzo capabilities rm <name>`	Deletes a capability and its versions; their artifacts go with the org's retention.
`hanzo capabilities rollback <name>`	Puts the version installed before the installed one back in the org's published set: exactly that version's artifact, nothing retrained.
`hanzo capabilities train <name>`	Teaches a capability a new version from its corrections, on the CPU over the states its org's decisions captured: no row is encoded again.
`hanzo train models`	Answers each base the caller can train today, in one shape: the base, the methods it trains by (adaptations), where it runs (runs: Hanzo's devices or the org's machines) with what one device-second costs there in nano-USD, then the resources that run it (nouns), its executor and devices, and the protections, objective terms, outputs and dataset schemes it takes.

Artifacts

Command	What it does
`hanzo train artifacts create`	Records rows the org is about to upload, named by the SHA-256 of their bytes, and answers the same grant an executor's artifact gets: a presigned PUT S3 accepts only with that checksum and length, encrypted under the org's key — a PUT per 64 MiB part over 64 MiB — or stored: true when the org already holds those bytes.
`hanzo train artifacts get <sha256>`	Answers one of the org's objects, as the list does, with an address that fetches its bytes for ten minutes once it is stored: how an executor reads an `artifact:<sha256>` dataset its job names, and how the org downloads what it uploaded.
`hanzo train artifacts list`	Answers the org's objects — its uploads and its jobs' outputs, one per sha256 — with what produced each, whether it is published and when retention deletes it.
`hanzo train artifacts rm <sha256>`	Deletes one of the org's objects — an upload or a job's output — from the store: every artifact naming it then reads deleted, and its storage is no longer billed.

Capture

Command	What it does
`hanzo capabilities capture get`	Answers whether the org's Kai decisions keep their states for its capabilities to learn from.
`hanzo capabilities capture replace`	Turns capture on or off for the org's Kai decisions from the next one.

Clients

Command	What it does
`hanzo train clients create`	Loads base_model on the engine with a LoRA adapter and answers the client, loading; poll it until ready.
`hanzo train clients forward_backward <id>`	Accumulates the gradients of a batch on the client.
`hanzo train clients get <id>`	Answers one of the org's clients with its loss history.
`hanzo train clients list`	Answers the org's live clients as the engine reports them.
`hanzo train clients optim_step <id>`	Applies the optimizer to the accumulated gradients.
`hanzo train clients rm <id>`	Drops one of the org's clients and frees its memory on the engine.
`hanzo train clients sample <id>`	Decodes from the client's current weights.
`hanzo train clients save_weights <id>`	Writes the client's adapter on the engine.

Jobs

Command	What it does
`hanzo train jobs artifacts create <id>`	Records an output its executor is about to store, named by the SHA-256 of its bytes, and answers a presigned PUT for exactly that object under the org's prefix — S3 accepts it only with the checksum and encrypts it under the org's key — or, over 64 MiB, a presigned PUT per 64 MiB part, or stored: true when the org already holds those bytes.
`hanzo train jobs artifacts get <id>`	Answers a job's artifacts — checkpoint, capability, lora, basis or merged, each named by the SHA-256 of its bytes — with a download address that lives ten minutes for each one stored.
`hanzo train jobs cancel <id>`	Stops a job that has not ended.
`hanzo train jobs claim`	An executor's long poll for work: it names the machine it runs on, its devices and what its build runs, and is answered, within 25 seconds, one task it can run — a job's lead first; a join once its lead has said where it coordinates — or 204.
`hanzo train jobs create`	Creates a job that teaches base_model one capability: the data, the objective, how the trained parameters are represented (adaptation), what they must not damage and by how much (protect), where it runs and how far (resources), the suites it is judged on (evaluation) and what it produces (output).
`hanzo train jobs events create <id>`	An executor's report for the task it holds: status changes, the lead's coordinator address, metrics, log lines, stored artifacts and, last, the lead's result.
`hanzo train jobs events get <id>`	Answers a job's events after a cursor — status changes, the coordinator's address, metrics, log lines, artifacts and the result — waiting up to `wait` seconds for the first new one, so a caller following a run holds one request at a time.
`hanzo train jobs get <id>`	Answers one job: what it asked for, its status and tasks, its artifacts, its result and verdict, and whether it was published.
`hanzo train jobs list`	Answers the org's jobs, newest first, narrowed by ?status=.
`hanzo train jobs metrics <id>`	Answers a job's metric series — loss, throughput and each validation suite's numbers as the executor reported them — one per name, each point [step, value, unix seconds].
`hanzo train jobs publish <id>`	Publishes a job's output under a name.

Was this page useful?

Broken link or missing step? Drop it in #docs on Discord or open a PR.

PreviousML NextAgent