Arzach

Agents that look after your fine-tunes. Every fix they propose clears the same eval your own pushes do.

Fine-tuning goes wrong quietly. A typo’d learning rate destroys a model’s attention. A new specialization wins its metric and silently loses an old one. And the tooling underneath sees only files that differ, so nobody can say which tensors moved, which version was best, or what a repair would even mean.

Arzach is an agentic layer over a version-controlled weight registry. Every version is a compressed delta against its base with its eval record attached — so an agent has something real to read: the history, the drift, the lineage, the metrics.

It hands you the whole fix, worked out end to end. Which tensors to take from which version. What to call the result. What it should score when the gate re-runs. Nothing touches your weights until you approve it.

A patch agent's live transcript: its reasoning in prose, the tools it called, and the eval chart showing the crash it found
a patch agent reasoning through a broken chain, tool call by tool call
A drift map of one model version: layers by tensor slot, coloured by how far each tensor moved
the drift map where the agent reads the damage
The Arzach console's commit graph: a chain of model versions with gate verdicts and compression ratios
the commit graph: every version with its gate verdict

Sometimes the model that passes doesn’t exist yet. The eval bar has three floors — language quality, answer accuracy, math — and each candidate clears two and fails a different third. Choosing between them will never ship a passing model, so the agent proposes building one: interpolate two versions at a named alpha, push the result, re-gate every capability. It states up front what it expects each metric to land at, so the verdict either confirms the fix or says how far to move the alpha.

None of this trains anything. The usual remedy for a regression is another training run: lower the learning rate, mix replay data back in, buy the GPU hours a second time. Surgery skips all of it. Grafting a tensor class back from an earlier version is arithmetic over weights that already exist. A repair costs one evaluation, not one fine-tune — which is why the agent can afford to try an alpha, read the gate, and try again.

This runs at real size.1 The registry knows exactly which tensors moved and how far each one drifted. So the agent reasons over a few hundred measured changes, not two directories that differ. The compression that makes it affordable is the same thing that makes it legible.

1 A 70B DPO fine-tune: 141 GB stored as 3.1, a ratio of 45×. A 120B mixture-of-experts: 65 GB stored as 1.0, a ratio of 64×. On that 70B the agent reads 723 tensors one at a time, which is what makes the reasoning legible rather than statistical. If you run it and your numbers come out different, we would like to see them: hello@arzach.ai.