What the receipt actually says.

Every term labelled by how it was obtained.

A single number called "the error" hides which part of it is a theorem and which part is a guess. Alelyon publishes the decomposition instead, with each term carrying its own provenance, and names the dominant term rather than letting it disappear into a sum.

At 24-bit capture, sampling typically binds the result by roughly four orders of magnitude over quantisation. The envelope names which term binds rather than leaving a reader to assume the composite is dominated by the part that sounds most rigorous.

Designed for third-party verification.

The component that checks a certificate is public. The component that computes one is operated by Alelyon. That separation is deliberate: a recipient can run the public replay checks without the private issuer implementation. Those checks still require independently obtained inputs and a public key pinned out of band, and a substrate-sensitive nonzero width may remain explicitly unverified.

The open surface ships as alelyon-os on PyPI. The verifier is the alelyon.verify module inside it, together with thealelyon-verify command it installs, the normative spec, and the conformance vectors — so the format is checkable against a written specification rather than against our implementation's behaviour.

It replays the program against inputs you supply yourself, and a pinned public key obtained out of band is mandatory for a positive verdict — a certificate that carries its own key verifies nothing. Where the numeric substrate differs from the issuer's, the verifier degrades honestly: the scalar is verified to tolerance and the width is left explicitly unverified with a stated reason, rather than being quietly accepted.

Where the boundaries are.

• Determinism

  Bit-identical reductions

  A Rust substrate produces identical reductions across runs, threads, and machines, with a tested NumPy fallback. A certificate never depends on the native extension being installed — the fallback path is a first-class citizen, not a degraded mode that silently changes results.

• Language

  The model writes a program, not an answer

  Where a language model is involved, it authors a restricted DSL program and nothing else. A deterministic interpreter computes the result. There is no eval, no shell, no arbitrary import, no dynamic attribute access, and no filesystem or network reach inside that language.

• Refusal

  Refusing is a result

  When a program falls outside the tier scheme — linear-exact, smooth-first-order, branch-margin-guarded — it is hard-refused rather than approximated. Margin guards are evaluated per element, because one benign element pinning an aggregate margin would defeat the safety factor entirely.

• Corroboration

  Asked, answered, or silent

  The attempt ledger records what was asked of each source and whether it answered or stayed silent, under a closed outcome vocabulary. Deleting or rewriting a silence is detectable by re-derivation. With a single answering origin this anchors the record of having asked — it is not a cross-source agreement claim.

Run your experts through Vulkan.

The public alelyon-ai harness opens a selected Vulkan device, reads one expert from a durable bank, runs packed matrix products, and commits a clipped AdamW update. Your model keeps control of tokens, routing, batching and the surrounding graph.

• Install

  Keep the device choice explicit

  python -m pip install "alelyon-ai[numpy]==0.1.0a3"

  The wheel uses Vulkan directly. No ROCm, CUDA or cloud service is required; a compatible driver is still required.

• Run

  Use your own arrays

  python -m alelyon_compute_kit.harness --device `
    --bank ./my-bank --input ./batch.npy `
    --target ./target.npy --steps 4 `
    --output ./prediction.npy --force

  Inputs and targets are rank-2 float32 .npy arrays. Each update commits a complete bank generation.

Proprietary models can stay closed-weight: keep the expert bank and model service in a private Google Cloud project, and let the website call an authenticated gateway that returns responses only. The public bundle contains no weights or private storage locators. A deployment still needs its own reviewed identity, storage, egress and live refusal checks before it is enabled.

Where the tools meet real work.

For researchers, model builders and teams who want the work behind their answers. These workflow examples span current tools and integration patterns.

• Current core

  Quantitative research

  You need a computed relationship between named price or public economic series, not a number recalled by a chat model.

  Workflow and limits

  Ask, for example, “How closely have SPY and QQQ daily returns moved together?” Lattice writes a restricted program, runs it over the named series, and refuses calculations outside that vocabulary.

  You get: The result, source, as-of stamp, executed program, tool trace, and a calibrated interval when supported—or an explicit statement that none is available.

  How we would use it: We would use the same path to separate a computed public-series fact from the interpretation written around it.

  Boundary: This is not a generic scenario or file-upload calculator. It supports named price and FRED statistics; standalone Lattice has no portfolio, position, or order tools.

• Current core

  AI and model engineering

  You need to know which local model is selected and what its runtime actually declares about its structure and storage.

  Workflow and limits

  Model Morphometry reads runtime metadata and the available tensor inventory without reading model weights or running a forward pass.

  You get: Model identity, architecture, parameter coverage, blocks, context length, storage precision, routing when declared, and named UNMEASURED gaps.

  How we would use it: We would inspect that inventory before assigning a model to work, without trusting the model’s description of itself.

  Boundary: It describes declared structure, not learned behaviour, quality, or performance. It does not produce a model-comparison verdict or certify the reported figures.

• Open toolkit

  Receipt replay and review

  Someone sent you a signed calculation receipt and you want to check whether it replays from the input copy you hold.

  Workflow and limits

  Run the open verifier with the receipt, your own input copy, and a public key obtained separately from the receipt.

  You get: A replay or refusal result that names what matched, what could not be checked, and why.

  How we would use it: We use the same acceptance and refusal conformance vectors to gate changes to the verifier before any release is considered.

  Boundary: The verifier uses only user-supplied inputs. It detects revision of committed inputs, not whether the producer invented them. No external CNE verification is recorded, and a substrate-sensitive nonzero width may remain unverified.

• Developer surface

  Software delivery

  Several coding sessions are working at once, and the team needs a clear view of overlapping branches, waiting work, and recorded checks.

  Workflow and limits

  Fleet reads worktree, harness, and ledger records; its views map branches, current areas, and the verification states already recorded.

  You get: A read-only coordination map with attention states and a visible distinction between derived records and session-declared claims.

  How we would use it: We use the same pattern to coordinate parallel website and runtime work without treating an agent statement as proof.

  Boundary: The views do not inspect tool results or verify an agent’s reasoning. They do not start work, run checks, or grant deployment authority.

• Integration pattern

  Data and analytics operations

  A report changed, but the team cannot tell which data revision produced the earlier answer.

  Workflow and limits

  Connect a bounded, read-only domain pack to a versioned dataset. The tool returns the value, source, and as-of context while Lattice keeps that return separate from the explanation.

  You get: An answer with the visible tool return, trace, and data vintage beside it.

  How we would use it: We would use the pattern to compare research-data vintages without silently replacing an earlier observation.

  Boundary: This requires a read-only domain integration. Sector-specific tool packs are not included in standalone Lattice, and provenance does not establish input truth or quality.

• Integration pattern

  Internal totals and tie-outs

  Two teams hold totals expected to agree and need the residual plus a durable review trail.

  Workflow and limits

  A bounded producer integration runs supported sums, counts, or differences over validated table inputs, then issues a signed receipt or a refusal for a reviewer to replay.

  You get: The residual and its receipt or refusal—not an automated materiality verdict. A person still applies the organization’s policy.

  How we would use it: We would apply the same pattern to internal billing and entitlement totals before reporting them.

  Boundary: The receipt and replay path exists, but a generic ingestion and reconciliation UI is not a beta feature. It checks arithmetic over supplied records, not whether either team supplied the correct records.

Selected public research notes.

This website collection includes selected findings, including results that failed. Each entry states what it establishes and, immediately beside it, what it does not. It is not a complete inventory of Alelyon research or public papers.

• ●Shipped06 Sept 2026

  Separating model-authored programs from computed results

  The restricted DSL parses an admitted program and computes its result through an interpreter instead of accepting a recalled figure.

  Does not establishThe restriction does not establish that the program asks the right question or uses correct inputs, and it does not cover unrestricted narration.

• ▲Gated06 Sept 2026

  Evidence required before applying a receipt in another domain

  A new domain application needs a defined user decision, a covered uncertainty term, and evidence that the receipt helps with that decision.

  Does not establishThis guide establishes no domain approval, customer deployment, or new experimental result; the earlier mixed-origin narrative has been retired.

• ●Shipped06 Sept 2026

  The scope of a storage-error execution bound

  The execution certificate evaluates supported computations under a declared storage-quantization model and refuses unsupported cases.

  Does not establishThe result is not a guaranteed enclosure of rounding, discretization, sampling, provider, and model error together.

Prior art, stated plainly.

The attestation layer is a competent re-derivation in the SCITT, Sigstore/Rekor, Sigsum, and RFC-6962 family — not new cryptographic theory, and Alelyon does not present it as such. Vendor dispersion as uncertainty is Markit Totem and EBA prudent-valuation territory; over-dispersion is the Birge ratio; error variance without ground truth is triple collocation. The contribution is systems and product: putting these together in one pipeline, at capture, with a public checker.