SIGIL vs `ollama show` + `hf cache verify`

These are the commands a developer reaches for first — and they are the right tools for what they do. This page is honest about what each covers and where SIGIL extends the surface into an audit-ready artifact.

Pick the built-in when

You are inspecting a single model interactively. You want to check that downloaded files are intact, see the Modelfile and tokenizer details, or list which features (completion, vision) the model advertises. The terminal output is the answer.

Pick SIGIL when

You need one artifact you can attach to a compliance review — JSON for diffing, Markdown for the ticket — that records manifest provenance, SPDX license family, every blob's SHA-256, the runtime's exposure (in observe mode), and a deterministic verdict from a policy with a completeness beside it (no LLM).

Axis-by-axis

What each command produces and what it leaves to you.

Axis	`ollama show`	`hf cache verify`	SIGIL
Input	Single Ollama model tag	Single HF repo (model / dataset / space)	Entire Ollama store (or a single model)
Returns	`modelfile / parameters / template / details / model_info / capabilities`	Checksum verification result (file count + OK/FAIL)	The session (JSON) with models, layers, licenses, listeners, findings, coverage, verdict and completeness; Markdown and AI-BOM v2 rendered from it
Integrity check	None	File checksum vs. Hub	Streaming SHA-256 of every Ollama blob vs. manifest digest
License family	Modelfile `LICENSE` string only	None	SPDX id from the Ollama license layer — 10 families by shortname or body match
Provenance	Implicit in the tag	HF repo id	`registry / namespace / model / tag` tuple parsed from manifest path
Runtime API exposure	Out of scope	Out of scope	With `--active api-probe`: whether `GET /api/version` answered at one literal address, and the version it reported. Classifying the configured host is planned
Listener bind classification	Out of scope	Out of scope	Observe mode: the listener held by `ollama serve`, found through its fd table; `loopback / wildcard / private / global` from the address
Audit artifact	Terminal text — not designed for archival	Terminal text — not designed for archival	Canonical JSON session (`sigil-session/1`) + Markdown render — diffable across review cycles
Verdict	None	Pass/fail per file	PASS / WARN / FAIL from findings and a TOML policy, with completeness beside it (no LLM)
Reach	Ollama only	HF cache only	Ollama today; llama.cpp / vLLM planned

What `ollama show` tells you, and what it doesn't

ollama show gemma4:e2b --license prints the license text declared in the Modelfile, and --modelfile prints the Modelfile itself. Useful for triage, not for attaching to a review ticket.

No SPDX id — just whatever string the Modelfile carries
No SHA-256 of layers verified against the manifest digest
No classification of the runtime endpoint or the listener
No structured artifact — terminal output only

# ollama show output
Modelfile: ...
LICENSE: """Apache License Version 2.0, January 2004 ..."""
parameters: temperature 0.7
template: """..."""
# hf cache verify output
✅ Verified 13 file(s) for 'meta-llama/Llama-3.2-1B-Instruct' (model)
in ~/.cache/huggingface/hub/models--meta-llama--Llama-3.2-1B-Instruct/...
All checksums match.

Specification example (golden example 14, tool.version 0.0.0-example), not a real system. An excerpt of SIGIL's AI-BOM v2 Markdown, as it is written:

# SIGIL AI-BOM

| AI\-BOM |  |
|---|---|
| Schema | sigil\-aibom\/2 |
| Mode | observe |

## Outcome

**Verdict:** PASS · **Completeness:** COMPLETE

## Listeners

| Listener | Address | Port | Owner |
|---|---|---|---|
| listener\:tcp\/127\.0\.0\.1\:11434\#7001 | 127\.0\.0\.1 | 11434 | process 4242 \(start 1000\) |

## Models

| Model | Name | Provenance | Layers | License |
|---|---|---|---|---|
| model\:models\/registry\.ollama\.ai\/library\/m\/latest | m\:latest | registry\.ollama\.ai\/library\/m\:latest | 3 \(found 3\, absent 0\, unresolved 0\, not looked up 0\) | MIT |

What `hf cache verify` does well

For Hugging Face cache integrity, this is the right tool. It is fast, vendor-official, and answers exactly the question: "did my downloaded files match the Hub at fetch time?".

HF cache layout only (~/.cache/huggingface/hub/)
Pass/fail per file — not per model or per review cycle
No license family detection
No record of how the runtime was bound at audit time

Where SIGIL extends the surface

SIGIL covers what the built-ins leave out: the auditable artifact, the deterministic verdict and completeness, the manifest-aware integrity check, and the runtime's exposure as it was when you audited.

One session (canonical JSON), with Markdown and AI-BOM v2 rendered from it — never drifting apart
Manifest-aware SHA-256 against the declared digest
Verdict from findings and a policy — no LLM, no remote service — and a completeness that says what was not seen
Listener attribution from /proc, recorded with the time of observation

Use both

Built-ins are daily tools. SIGIL is the per-review-cycle artifact.

Use ollama show for quick triage of a single model
Use hf cache verify as a fast HF cache integrity check
Use sigil inspect ollama --format md when the artifact has to outlive the terminal session

When SIGIL is the wrong choice

If you only need ad-hoc inspection of one model and you don't need a versioned artifact, the built-ins are faster. If your entire AI footprint is the HF cache and you do not run Ollama, hf cache verify covers integrity and SIGIL adds nothing today — llama.cpp and vLLM support are planned, not current.

Sources

Facts above are checked against current vendor docs.

Ollama /api/show: Field list: modelfile, parameters, template, details, model_info, capabilities. No SHA verification, no exposure.
hf cache verify: HF cache checksum verification — file-level OK/FAIL against the Hub.
SIGIL Ollama guide: modes, outputs, and what is read; rules and coverage in the model-store and exposure docs.
SIGIL AI-BOM v2: the projection of the session, and the planned comparison direction.

SIGIL vs ollama show + hf cache verify