SIGIL

Compare · Vendor built-ins

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.

COMPARE BUILT-INS
OUTPUT REVIEW 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 runtime exposure, manifest provenance, SPDX license family, every blob's SHA-256, and a deterministic verdict aggregated from analyzer findings (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) JSON + Markdown AI-BOM with runtime, models, licenses, findings, verdict
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 Configured Ollama host classified — localhost / network / public_bind / unavailable
Listener bind classification Out of scope Out of scope /proc walk → localhost / lan / public_bind / docker_published / proxy
Audit artifact Terminal text — not designed for archival Terminal text — not designed for archival Stable JSON (schema_version: 1.1) + Markdown render — diffable across review cycles
Verdict None Pass/fail per file PASS / WARN / FAIL per AI-BOM, aggregated deterministically from analyzer-emitted finding severities (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.

# sigil aibom generate output  (file at out/gemma4-aibom.md)
# SIGIL AI-BOM: [PASS]
- Schema: `1.1`
- Runtime exposure: `localhost` (source: `proc`)
- gemma4:e2b — License: Apache-2.0 (sha256:7339...)
- Layers SHA-256 verified vs. manifest digest
- Findings: none

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 structured deterministic verdict, the manifest-aware integrity check, and the runtime exposure picture as it was when you audited.

  • One JSON (schema 1.1) + Markdown — same model, never drift
  • Manifest-aware SHA-256 against the declared digest
  • Verdict aggregated from analyzer findings — no LLM, no remote service
  • /proc-derived listener classification recorded with a timestamp

Use both

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

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 inspection Evidence fields, SPDX detection table, runtime bind classes, findings. SIGIL AI-BOM contract Schema 1.1, enum reference, planned comparison direction.