Your coding agent should read the library, not remember it.
Leitir builds a deterministic, provenance-bound corpus of dependency source, and gives an agent a deterministic code-search kernel over it. The library it answers about is the one your project installs, materialized from bytes that were checked before they were indexed.
- Version
- v0.1.6, released 2026-08-25
- Requires
- Python 3.11 or newer
- Runtime dependencies
- None
- Status
- Pre-1.0
$ leitir info npm:zod@3.22.0 --brief- package
- npm:zod@3.22.0
- source
- registry artifact, pinned
- checksum
- matched against the published digest
- provenance
- manifest written to the local shelf
- api
- public signatures, ranked examples
- trust
- deterministic score, 0–100
- parity
- artifact compared against source tree
Where the guessing comes from
Internals are recalled, not read
An agent answers about library internals it has never opened. The shape of the answer is right often enough that nobody checks the rest of it.
Signatures leave out the control flow
A signature and a docstring say what a function accepts. They do not say what it does with an empty list, a null, or the edge case that changed in the last minor release.
Training data goes stale on release day
Version-specific behaviour moves. The model’s memory of the library does not, and it has no way to notice the gap.
Watch it materialize source it can prove.
What the recording covers
- Materialize verified source for a named version.
- Inspect the provenance manifest and the trust score behind it.
- Compare two versions and read what actually changed.
- Detect tampering: bytes that do not match refuse to load.
Written out so the section still reads if you never press play.
Five steps, and the third one can refuse.
- 01
Resolve an exact version
You name a version, or point at a lockfile. Leitir resolves that version and no other.
- 02
Fetch the artifact or a pinned tree
Either the registry artifact published for that version, or a git tree pinned to the tag it was cut from.
- 03
Verify, fail closed
The published checksum must match, or the host’s own tree blobs must. A mismatch refuses the source outright: no partial index, no best-effort substitute, no silent downgrade to something close.
- 04
Shelf it locally with provenance
Verified source lands on a local shelf carrying a manifest that records where every byte came from.
- 05
Expose it to the agent
API summaries, ranked examples, citations, trust and parity, SBOM and version diffs: all read off the shelf, offline, from the same bytes.
Four commands, and the six jobs they do
$ pip install git+https://github.com/anthonykewl20/leitir.git@v0.1.6Install from the tagged release. Python 3.11 or newer; nothing else to pull in.
$ leitir info npm:zod@3.22.0 --briefOne call for the facts about a package: provenance, public signatures, ranked examples, trust, parity.
$ leitir ask "validate an object without throwing" --package zod --ecosystem npm --pin .--pin reads the lockfile or project in that directory, resolves the exact installed version, and compiles the question into deterministic predicates. It never falls back to latest.
$ leitir check src/schema.py --against pypi:pydantic@2.11.7Check a file you wrote against one specific released version of a dependency.
Six things people use it for
Implement against the installed dependency
Write code against the version in the lockfile rather than the version the model remembers.
Debug undocumented behaviour
Read the path the library actually takes when the documentation stops short of it.
Review an upgrade before taking it
Diff two resolved versions and see which API changes touch your code.
Run offline and reproducibly
Export a shelf, import it in CI or an agent sandbox, and get the same answers with no network.
Generate an SBOM
SPDX or CycloneDX, produced from verified artifacts rather than from a dependency list.
Ground an MCP-capable agent
Hand the agent the shelf, so its answers about a library are citable back to bytes.
Four words this page is willing to defend
- Exact
- The version resolved is the version your project installs: not the newest, not the most popular, not the one with the best examples in a blog post.
- Verified
- Bytes are checked against a published checksum, or against the host’s own tree blobs, before anything is indexed. Verification failing is a refusal, not a warning.
- Citable
- Every answer points back at a file inside a specific artifact, so a reviewer can open it and disagree with it.
- Deterministic
- The same question, against the same pinned version, returns the same answer on any machine, including one with the network unplugged.
Four ecosystems, five forges, one score
Ecosystems
npm · PyPI · crates.io · Go
Forges
GitHub · GitLab · Bitbucket · Codeberg · Sourcehut
Trust score
Deterministic, 0–100, computed from verification, parity, license, documentation, tests, checksum, age. The same inputs produce the same score every time it is asked for.
Where this actually stands
v0.1.6 was released on 2026-08-25, and the production-readiness evidence for it is complete. It is still pre-1.0, which is the honest label: interfaces can move before a 1.0, and this page will not pretend otherwise.
Python 3.11 or newer, with no runtime dependencies. The project declares no license field, so this page states no license: read the repository before you build on it. If this page and the repository ever disagree, the repository is right.
$ pip install git+https://github.com/anthonykewl20/leitir.git@v0.1.6One step earlier in the chain
Leitir is planned to fold into Ranex as a feature. Same principle, applied one step earlier: Ranex checks the output an agent produced; Leitir makes the input source real: pinned, byte-verified, and citable.
What the Ranex kernel enforcesPoint it at a dependency you already ship.
Pick a package in your lockfile, ask Leitir something you already know the answer to, and check the citation. If it gets that wrong, that is the useful bug report.