The Medium Grid — Mapping 15 AI Design Models by What Agents Can Perceive and Verify

Overview

Every AI design model emits one of four things: a verdict, code, pixels, or a structured file. An agent can learn from exactly one of those without translation — and it isn’t pixels. The other three are parseable, diffable, and verifiable; pixels require a vision round-trip that reintroduces the exact resolution bias our previous post identified as the cause of agents regressing to safe minimalism. That post found the symptom; this one names the cause: the model’s output medium bakes resolution in at generation time, and no downstream re-render fully removes it.

This post maps 15 models on two axes: perception modality (text-only / screenshot / video-native / training-distribution-only) and output medium (verdict / code / pixels / structured file). The core claim: an agent should route each design subtask to the model class whose output medium it can parse and verify, and whose perception covers the artifact being critiqued. The medium axis is exactly where resolution bias lives — pixels are always trained at some fixed resolution, while CSS, SVG, and Figma tokens have no resolution at all.

We score all 15 models across four dimensions — perception depth, output structure, verifiability, and specialization/cost — and deliver one routing rule. This answers three open questions: perception modality determines what an agent can see (sub-question #1), output medium determines verifiability (sub-question #4), and resolution bias is a medium property, not a model property (sub-question #5). The verifiable-output post established that extractability equals verifiability equals learnability; here we apply that test to every major model class.

The Medium Grid

The grid’s logic: perception modality (rows) tells you what an agent can feed the model; output medium (columns) tells you what the agent can parse back. Models that emit code or structured files close the learning loop; models that emit pixels force an expensive OCR or segmentation round-trip. Diffusion models score zero on perception depth — their “taste” is frozen in a training distribution, not available at inference.

#	Model	Class	Perceives	Emits	One-line verdict
1	Claude	LLM	Text + code (no images)	Verdict, code	Long context, best critique; Constitutional AI = design taste as rules
2	GPT-4o	Multimodal LLM	Screenshots (static)	Verdict, code	Image-to-code; image gen safe-to-a-fault
3	Gemini	Native multimodal	Video → interaction flows	Verdict, code	1M+ context; analyzes flows, not static pages
4	DeepSeek V4 Flash	MoE LLM, text-only	Text + code only	Code	Surprisingly good CSS; cost-efficiency beats scale
5	Midjourney V7	Diffusion	Training distribution only	Pixels	Best aesthetics via human-preference loops; no code, weak UI, no text rendering
6	DALL-E 3	Diffusion	Training distribution only	Pixels	Safe, prompt-adherent, less aesthetic
7	Stable Diffusion 3	Open diffusion	Training distribution only	Pixels	ControlNet/LoRA/IP-adapter community extends it; open source compounds value
8	v0.dev	Design-specialized	Screenshots + prompt	Code (React/Tailwind/shadcn)	Narrow specialization beats general capability
9	Galileo AI → Google Stitch	Design-tool model	Prompt + reference	Structured (Figma files)	Editable output enables iteration
10	Ideogram	Diffusion	Training distribution only	Pixels (+text)	Best-in-class text rendering; typography is hardest AI problem
11	Recraft	Design-specialized	Prompt + brand refs	Structured (SVG/vector)	Vector output, brand consistency
12	Flux	Flow-matching	Training distribution only	Pixels	Architecture innovation leapfrogs scaling; open weights
13	Llama 4	Open MoE LLM	Text + code	Verdict, code	Fine-tunable for brand-specific aesthetics
14	Qwen	Multilingual LLM	Text (+CJK-first corpus)	Verdict, code	Asian web patterns differ; diverse data = globally relevant
15	Mistral	Efficient LLM	Text + code	Verdict, code	Efficient architecture, good code design

Dimension Scores

Perception Depth

Perception depth is the ceiling on what an agent can ask a model to evaluate. Gemini leads: its video-native understanding means it can see hover states, transition timing, and scroll behavior — none of which appear in a static screenshot [2]. GPT-4o reads static screenshots competently but misses temporal artifacts [3]. Claude and v0 perceive text and code only — v0 compensates with design-tool specificity, but neither can see a rendered page [1][8].

Text-only LLMs — DeepSeek, Llama 4, Qwen, Mistral — perceive zero pixels. That’s a feature for code generation but a hard blocker for visual critique. Diffusion models (Midjourney, DALL-E 3, SD3, Ideogram, Flux) are the worst case: their “perception” is a frozen training distribution at fixed resolution. They cannot see your artifact at all; they only sample from what they saw during training. This is resolution bias at the perception layer — the model’s taste is locked to whatever resolution its training data used.

Ranking: Gemini > GPT-4o > Claude/v0 > text-only LLMs > diffusion.

Output Structure

Output structure determines parseability. Code and structured files win outright. v0 emits production React/Tailwind/shadcn source [8]; DeepSeek and Mistral emit clean CSS and markup [4][15]; Stitch emits Figma-compatible documents [9]; Recraft emits SVG paths [11]. All of these are diffable against a spec.

Pixels-with-text is the worst case. Ideogram’s 95% text accuracy claim exists precisely because every other image model fails at typography — and even at 95%, you still need an OCR round-trip to verify which 5% failed [10]. Pure pixels (Midjourney, DALL-E 3, SD3, Flux) require segmentation to extract any structure at all.

Ranking: code/structured > SVG > pixels-with-text > pixels.

Verifiability & Learnability

The learning loop closes only when an agent can diff model output against a spec — the core argument of our verifiable-output post. Editable files (Stitch, Recraft) enable iterative refinement. Code (v0, DeepSeek, Mistral, Claude) enables linting, build checks, and visual regression testing. Pixels enable only human eyeballs or expensive vision round-trips — and that expense compounds because each re-render at a new resolution reintroduces the artifact the resolution-bias post documented.

Midjourney’s human-preference loop trains the vendor, not the agent [5]. The agent learns nothing from a pixel output it cannot parse; the vendor learns aggregate taste. That asymmetry is the core reason diffusion models belong in exploration, never production.

Ranking: code/structured LLMs > design-specialized emitters > SVG > pixels.

Specialization, Openness & Cost

Three patterns emerge. First, narrow specialization beats general capability: v0’s design-tool focus outperforms general LLMs on production UI [8]. Second, cost-efficiency beats scale: DeepSeek’s MoE architecture (671B total, 37B active, ~2.788M H800 GPU-hours) delivers near-frontier code at a fraction of the compute [4]; Mistral’s efficient architecture makes it the default for high-volume code tasks [15].

Third, open weights compound value. SD3’s ControlNet/LoRA/IP-adapter community extends it far beyond its base capability, though note it’s not fully Apache-licensed — non-commercial weights with an Apache-2.0 autoencoder [7]. Flux’s flow-matching architecture leapfrogged scaling curves with open weights [12]. Llama 4’s fine-tuning enables brand-specific aesthetics [13]. Qwen’s 100+ language reach covers Asian web patterns general models miss [14].

Ranking: DeepSeek/Mistral > v0 > open diffusion (SD3/Flux) > flagships.

Verdict

The routing rule is one sentence: route each task to the model whose output medium you can parse and verify, and whose perception covers the artifact you’re critiquing; tie-break on cost per 1k output tokens. Concretely, five task classes:

CRITIQUE: text-only models score 0 on visual artifacts; screenshot-multimodal (GPT-4o-class) passes for static pages; video-native (Gemini-class) is required for interaction-flow analysis.
PRODUCE-CODE: use code-capable LLMs (DeepSeek/Mistral/v0/Claude); never accept raster-only output for production.
PRODUCE-RASTER: exploration/mood only; if text-critical, require a dedicated text encoder (Ideogram-class) and verify every rendered string by OCR round-trip.
PRODUCE-VECTOR: require SVG-emitting models (Recraft-class); accept only parseable vector paths.
PRODUCE-STRUCTURED: prefer Figma-format emitters (Stitch/Galileo-class).

The routing gate, in pseudocode:

def route(task, model, artifact):
    if not output_parseable(model, task):
        return reject(model)          # pixels for PRODUCE-CODE = fail
    if not perception_covers(model, artifact):
        return reject(model)          # text-only for CRITIQUE-visual = fail
    if task == "PRODUCE-RASTER" and is_text_critical(task):
        verify_ocr_roundtrip(model.output)   # Ideogram-class required
    if task in ("PRODUCE-CODE", "PRODUCE-VECTOR", "PRODUCE-STRUCTURED"):
        skip_raster_rerender()               # scale-free medium, no bias
    return select(min_cost_per_1k_tokens(candidates))

Quadrant verdicts in one sentence each: text-only LLMs for critique and code; multimodal for screenshot and interaction analysis; design-specialized for production UI and vector; diffusion for exploration only — never text-critical, never production.

The resolution-bias audit is the final gate: raster output must be re-rendered at target resolution (DPR ≥ 2, min width 375px) before evaluation per RAD-1; code, SVG, and token outputs skip raster re-render entirely because they’re scale-free.

An agent learns better when the model emits a medium it can verify at a resolution it chooses. That single constraint — not raw capability — is what separates models an agent can learn from and models an agent can only admire.