habitatmethod
The instrument is fixed. The reading is not.
Across every receipt on this site, one thing recurs. The instrument does not change — but what it can discern is conditioned, every time, by the character of the data itself.
Data character is a factor in the geometry
A corpus has a shape before anyone measures it — how structured or how uniform, how much it varies and where. That shape is not something the reading ignores; it is a factor in what the reading can say. The same instrument, run on two corpora, discerns different things, because the two carry different character. A receipt’s floor is the corpus’s own. Its metric is induced by that corpus, not assumed over it. The reading is relative to the field it reads. The same instrument, on one domain, can return a fit, a bounded fit, and an honest no-fit at once — because each register is a measured property of the corpus, not a fixed property of the tool. Which receipt applies is itself a reading.
A decidable receipt, and the discernment around it
This is why the receipts are built the way they are. The verdict is mechanical: recompute it yourself, and it agrees to the byte or it rings — no tolerance, no judgment at the moment of decision. The judgment lives elsewhere, deliberately: in choosing which receipt to compute, on which corpus, and in reading what a result means once it lands. Detection is the instrument’s; resolution is always a person’s.
The two tests around every receipt
Every receipt on this site is decided by the same two questions, recomputable by anyone. One — does it hold? A change that preserves the finding — reordering the rows, a cosmetic re-export — must leave the geometry byte-identical while the file’s own hash changes. A checksum cannot tell the two apart; the geometry can. This is the decidable one: it is byte-identity, and it needs no floor, no null and no ranking. Two — does a real change ring? A declared, legitimate operation that genuinely moves the finding must move the geometry past the corpus’s own floor — and a floor is a quantile of the data’s own churn, so which quantile you declare is a choice that has to be published. We read it two ways: the median and the 99th percentile. Both are properties of the field, both converge as sampling effort grows, and on three of our corpora they disagree — the same measured move rings past the median and holds inside the 99th. So we publish every ring against both, and a ratio within convergence noise of 1.0 is reported at the floor, not as a verdict. Hold and ring: no trust asked.
What “recomputable” is bound to
The claim on this site is exactly one thing: byte-identity of the digest, recomputable by you, on any engine that follows the kit’s published canonicalization. That last clause is not a hedge — it is the whole claim.
The digest pins a specific arithmetic: exact (Shewchuk) summation for the covariance,
a Gauss-Jordan inverse, and the result serialized as float64 in C order, explicitly little-endian,
then hashed. Follow that and you get our digit. Reach instead for the obvious tools
— numpy.cov and numpy.linalg.inv — and you will not,
because BLAS sums in a different order and LAPACK inverts by a different route; they differ in the
last bits, and SHA-256 turns one flipped bit into a different number entirely. We measured that on
three of our live cases: all three digits differ. That is by design, and you should know
it before you try. The honest consequence: an independent recompute here is a re-execution
of a published, open, ~40-line canonicalization — not a from-scratch reimplementation
agreeing by luck. The kit ships that arithmetic so you can read every line of it.
Where it is measured, and where it is not. The canonicalization is designed to depend on the data alone, and the design is checked rather than asserted: the same digits reproduce on arm64 and on x86_64 — the axis that breaks a naive fixed-order implementation, since SIMD width changes how a vectorized sum accumulates. The kit’s SPEC records a wider matrix (arm64 + x86_64, macOS/Linux/Windows, numpy 1.26.4–2.5). What we will not tell you is that it therefore holds everywhere: platforms beyond those tested are a prediction, not a measurement. If you find one that disagrees, that is a finding and we want it — new legs get added, not argued.
The floors we actually read
“The corpus’s own floor” is not one method — and an earlier version of this paragraph said something our own bench later refuted. It said two receipts were graded against a permutation null. Measured (2026-07-15): they are not. The revision-materiality and material-contribution receipts report in null-widths, and a null-width is a z-score — the published verdict reproduces as that score against a declared cut of 3.0 shipped in the kit. A chosen cut deciding a published verdict is exactly the thing the rest of this page refuses, so it is under review as an open item (stated below and on the ledger), and those two receipts’ rating plates are withheld until it resolves. Where a receipt reads its floor as bootstrap quantiles, the page says median and p99, both; where it says null-widths, that is a z-score against the declared cut.
Run on real data, left recomputable
The two tests are not run on toys. Each receipt is computed on real, pinned data — public at its source wherever the source is public — and every number we publish is left for you to recompute from the artifact, on your own machine, nothing sent. Where a corpus is constructed to isolate a single mechanism, we say so and mark the case a frontier. We would rather publish a thin result on real data than a clean one on data chosen to flatter the instrument — so when the honest reading is a no-fit, that is what we show.
A worked recomputation, on data we had no hand in
A published leaderboard where 714 of its 1,292 cells had nothing in the shipped bundle to recompute against. What shipped set the boundary before the instrument reached it — and two columns still came back exact: one at all 34 rows, one at 33 of 34. We measured it blind, then read the publisher’s own source afterwards; on structure, on null semantics and on the certified columns, the two agree. Method, census and both implementations are published whole: openhands-index — a recompute survey.
It never resolves — in the code, and in the reading
The line between detection and resolution is drawn twice, on purpose. In the code: the instrument emits a number and a match-or-ring, and stops. It renders no verdict about a person, a motive, or what to do — there is no resolution in the machine to argue with, because it was built not to hold one. In the method: resolution is the reading, and the reading is yours. The discipline says what the geometry can bear, hands you the floor, and halts at the threshold of decision. That boundary is not a limit we apologize for; it is the guarantee — what a record means stays yours because the code refuses to say, and the method refuses to take it from you.
A practice, not a toolkit
A toolkit says: run the tool, take the answer, thresholds baked in. This refuses that. It asks you first to read whether the geometry can bear the claim — and that reading is a discipline, learned and practiced, not a button pressed. The instruments produce receipts anyone can recompute. What they cannot do is replace the discernment that decides when a receipt is the right one and what it means. That discernment is the practice. You can watch it work on a recomputation carried out on a leaderboard we had no hand in.
Bottom line
The floor is recomputable by anyone. The reading is a practice. Both are the point.
← Receipts · The sweep · Controls
The baseline — two sentences, every clause measured
As a detector: habitat does exact, replayable change-attestation over a pinned record. Every digest the site recomputes reproduces from its pinned bytes: nine in your browser, checked on every build, and a 1,258-step dated chain on our bench (2026-10-13). No benign reorder has ever moved one. Every declared control moved it — a leak, a single leftover record ten times out of ten, two targeted drops, a future row folded into a past state, five rows deleted from history — each landing on the byte value its kit declared in advance. What it cannot see is on each receipt’s rating plate: relabeling a column that never varies; shifting a whole column where the rounding lands exactly; an edit below the resolution its corpus size sets. A material edit has moved the digest on every column ever measured.
As a conversant: habitat speaks four sentences the corpus decides and the operator does not — which axes are silent; which direction dominates; what couples to what; how the variance ranks. Each survived every arithmetic, ridge, solver, and column-order varied against it; each carries its condition on its face; and every one is computed from the covariance matrix, which the conversant receipt now publishes — recompute the readings and the digest from the receipt alone. It does not yet hold a conversation. The reader-relative reading died on the bench: as shipped it moves with a constant we chose, and its A-reads-B asymmetry is broken by our own one-sided conditioning, not spoken by the corpus. The repair is identified and measured; it stays a door until a pre-registered bench clears it.
Why not just sort the rows and hash? — measured, so you don’t take our word
| question | sigma digest (ours) | sort-and-hash |
|---|---|---|
| benign reshuffle holds | yes (conformant engine) | yes |
| erased == never-had-it · eligible-only == certify · one record left rings | yes — at declared byte values | yes |
| a relabeled constant column rings | no — disclosed per plate | yes |
| a whole-column exact-rounding shift rings | no on mapped columns — disclosed per plate | yes |
| a one-ULP edit rings at card scale | no (size-dependent, disclosed) | yes |
| readable without the rows | yes — digest and every reading recompute from the d×d Σ alone | no |
| carries the field’s shape (silent axes, couplings, dominant direction) | yes — published Σ readouts, conditions printed | no — a bag has no axes |
| reproduces across machines | yes: the same digits on arm64 and x86_64; kit build record: 3 OSes | trivially — no arithmetic |
On every membership question the two agree — measured. Where the sorted hash beats us, the plates say so, with exhibits. Σ-only verification exists as a capability; our own cases don’t need it — the rows are public. Run the pair in the kit. If anything here fails on your machine, that is a finding and we want it.
Open items — stated, dated
- Open: one shipped kit decides a published verdict through a chosen cut (3.0). Under review; until resolved, the two affected rating plates are not published.
- Open: one shipped kit’s own verifier refuses off its reference build on a legacy leg while every current check passes. The digits reproduce on arm64 and x86_64; platforms beyond those tested are a prediction, and no “any machine” sentence appears here.
- Adverse, printed: the reader-relative reading is not real as shipped — see the conversant sentence above.
Dated 2026-10-15; every clause carries a completed bench in the published record. Detection, not adjudication.
How this record was made
The baseline above was not produced by one author checking their own work. It was produced by AI sessions run blind against each other, on this instrument’s own discipline: two agents drafted the work order for these measurements in parallel, neither knowing the other existed; each then audited the other’s draft without knowing the audits would be compared; the merged order was executed twice, independently, by executors who could not read each other’s results — and every load-bearing verdict on this page is one that both runs reached separately, byte for byte. Where the two runs disagreed, the disagreement is in the record with the bench that resolved it. Where one run’s own probe was invalid, its report records it.
Nothing in this section is a property of any dataset. It is a property of us, and every sentence of it has a file behind it. Detection, not adjudication — including of ourselves.
The information on sets below provides some detail on what reference datasets were run.
From trace boundary, keep-out, take-out (one computation, one published digest)
Recompute it yourself — in your tab
The digit 67a6f95e… is the number habitat published for this trace. Recompute it here from the trace's own vectors — nothing leaves your tab — then try to fool it: reshuffle the steps and it holds; change a step and it moves.
what just happened
habitat read this trace once, on our engine, and reduced it to a small set of vectors — the geometry of how its steps relate. From those your browser recomputed one number: the covariance, conditioned and inverted (math.fsum → Gauss-Jordan inverse → SHA-256), ~40 lines of public arithmetic, nothing sent. Built from the relationships, not the order — so a reshuffle leaves it identical, a real change moves it. The reading (text → geometry) is the method; it stays on our engine, the recompute is yours.
what this proves — and what it doesn't
Proves: the published number falls out of the trace's own vectors — reproduced byte-for-byte, no server; and it's not a checksum (survives a benign reshuffle, moves on a real change).
Doesn't: not tamper-proof, not authenticity. Same number = same relationships, not the same bytes: a uniform shift, or a change finer than the arithmetic's floor, is invisible by design, and a dataset engineered to share those relationships would pass. Self-served (our page, our vectors); the independent version is the downloadable kit against a separately-published fingerprint. And it's this published trace, not your data — reading your data into geometry runs on our engine, not your tab.
Now leave one record behind. Erasure that looks complete and isn’t. Here is a single withheld record — one of the 7,499 — in full, nothing hidden:
content_len_log 4.0943 · n_blocks 1 · n_tool_use 0 · n_text_block 1 · is_error 0 · is_generated 1
Append it to the 4,262 and the geometry barely moves — no cell of g shifts by as much as a ten-thousandth. The number moves anyway.
what this catches — and what it doesn’t
Catches: a residue in the state it is handed. A raw-bytes hash would also change here — but it changes when you merely reshuffle the records too, so it cannot tell a benign reordering from a record that should not be there. This can: the reshuffle above holds, and this does not.
Doesn’t: say that the record was supposed to be erased, who left it, or whether it mattered. It reports that the state it was given is not the state that was claimed. The reading is yours.
From trace boundary, keep-out, take-out
That magnitude is set by the ridge, not measured: swept across nine values of λ it tracks 1/λ almost exactly — 999,980 at 1e−6, 85.774 at the shipped 0.01, 0.15 at 1 — because the clean arm’s n_tool_use column is constant, and a constant column’s precision diagonal is pinned at 1/λ by construction. The location holds across four and a half decades; the size is not an effect size.
From trace boundary, keep-out, take-out
From point-in-time
From trace boundary
The reference here is a community dataset — trace-commons, best-effort anonymized. Its provenance is checkable at a public source, and it checks out: rebuilt from the raw public Hugging Face session files, this card's own digit reproduces byte-for-byte — 67a6f95e… — as do the declared leak (c3aee30b…) and the single-residual state (7fbb9ec5…), with │Δg│ = 85.7740 against the kit's declared 85.77404440471331 — a magnitude the ridge sets rather than the data (see the sweep). Three published digits, three matches, from bytes anyone can download.
From keep-out
The reference here is a community dataset — trace-commons, best-effort anonymized. Its provenance is checkable at a public source, and it checks out: rebuilt from the raw public Hugging Face session files, the eligible-only baseline reproduces byte-for-byte (67a6f95e…) and this receipt's own declared fold-in reproduces as c3aee30b…, with │Δg│ = 85.7740 against the kit's declared 85.77404440471331 — a magnitude the ridge sets rather than the data (see the sweep).
From take-out
The reference here is a community dataset — trace-commons, best-effort anonymized. Its provenance is checkable at a public source, and it checks out: rebuilt from the raw public Hugging Face session files, the never-enrolled state reproduces byte-for-byte (67a6f95e…) and this receipt's own declared single-residual state — one record left behind — reproduces as 7fbb9ec5…, the kit's own declared value.