A Polygraph engine

polyviz — the diagram is the artifact, not an illustration of it

A hand-drawn or LLM-drawn diagram of a state machine can drift from what was actually verified. polyviz can't — it's a deterministic renderer: the same verified artifacts in, byte-identical SVG out, every time, on any machine.

When you reach for it

A diagram is going into a PR, a report or a deck, and it has to match what was actually verified — not what somebody drew, or what a model imagined.

What you have when it finishes

Byte-identical SVG rendered from the verified artifacts, with a hash per figure, so the picture can be regenerated and diffed in CI like code.

The pipeline

What goes in, the stages it runs, what it leaves behind. Step through the stages to trace the run.

fig 13

polyviz

draw only what the gate already produced

A deterministic, artifact-derived renderer. A hand-drawn diagram drifts; this one is a pure function of the verified model.

draw

Adapt

Native artifacts map through adapters into the viz-model — the stable contract between what the gate checked and what gets drawn.

→

Trace every mark

Every mark must trace to a field in an artifact. No invented content, and a missing or invalid artifact is an explicit error rather than a silently wrong picture.

→

Layout

Text is measured, boxes size to content, graphs are laid out by an engine. No hand-set coordinates, and no overflow for any bounded input.

→

no model call

Render

state-machine · invariants · counterexample · compat-gate · scorecard · model-card. Renderers reference theme tokens only — no hard-coded colours.

→

Hash

sha256 per SVG, so a figure in a report or PR can be regenerated and byte-compared in CI.

consumes

polyviz.json viz-model, or a Polygraph artifacts directory · theme tokens

produces

SVG per diagram (+ PNG 2×) · sha256 per figure · report figure set

If the renderer were non-deterministic it would reproduce exactly the defect Polygraph flags in others. Same inputs, on any machine, byte-identical output.

How it works

Rendering as a pure function, not an act of drawing.

Every mark traces to a checked artifact

The state machine, the invariants, the counterexample, the compat verdict — never invented content.

No model call at render time

An LLM may invoke polyviz, but it never draws; rendering is a pure function of what the gate already produced.

Byte-identical output, run to run

No clock, no randomness, sorted keys, pinned font metrics — so a figure in a report can be regenerated and diffed like code.

Fits with: Runs after any other engine — it visualizes what polygen, polygraph, or polyvers already checked, for a report, a PR, or a deck.