Overview
If AI agents are going to learn to design, they first need to perceive design — and how a tool stores its work determines what an agent can see. Compared through that lens, Penpot’s open, structured file format is a stronger machine-readable foundation for design agents than Figma’s proprietary binary. That is an architectural advantage, not a guarantee of autonomous design quality. One honesty note up front: this comparison is based on official documentation and pricing pages — we did not run either tool hands-on.
The agent-perception problem
Rendered pixels are a poor first interface for design reasoning. A screenshot shows an agent approximately what a design looks like, but not what anything is. Recovering a hex value or a 24px gap from pixels means vision models, approximation, and hallucinated numbers.
Structured data flips the equation. When an agent reads the file itself, contrast ratios, spacing rhythm, and token consistency become deterministic computations — exact values, no rendering, no vision. The real question is which tool hands the agent that data.
What Penpot exposes
A .penpot file is a ZIP archive, and unzipping it reveals a readable hierarchy: a manifest.json table of contents; a files/ directory containing file-metadata.json and a file-data/ folder with pages/, colors/, components/, typographies/, and — crucially for agents — tokens.json holding design tokens; plus objects/ for images and binary assets. Penpot’s docs describe the export as essentially a ZIP archive containing binary assets alongside a readable JSON structure, built on standard languages.
Three further signals matter to a machine:
- Design tokens use named semantic values with light and dark modes — design-system constraints an agent can actually check.
- An Open API targets external rendering, workflow automation, and enhanced app functionality, alongside a plugin system.
- Penpot is free and open source under GPL/MPL licensing, with code on GitHub and hosted or self-hosted options.
Penpot vs. Figma, dimension by dimension
Figma is not automation-poor — its APIs and plugin ecosystem are mature — but its native .fig file is a proprietary binary, so raw-file analysis is largely off the table.
| Dimension | Penpot | Figma |
|---|---|---|
| File openness | Open .penpot ZIP archive with readable JSON (docs) |
Proprietary binary .fig |
| SVG access | SVG-oriented data model, standard formats | SVG export supported; native format closed |
| Raw geometry inspection | Direct from JSON (coordinates, sizes, fills) | Requires API or plugins; opaque in raw file |
| Token/theme analysis | tokens.json; semantic values, light/dark modes |
Via variables and API; not in file dump |
| Contrast computation | Deterministic from stored color values | Needs API queries or rendering |
| Automation surface | Open API + plugin system | Mature API + large plugin ecosystem |
| Ecosystem maturity | Smaller, growing | Larger, mature; deeper Dev Mode and handoff |
A practical agent experiment
What would an agent audit look like against a .penpot file, with no rendering and no vision? Roughly this:
- Unzip the archive and read
manifest.jsonto locate the file data. - Load
tokens.jsonandcolors/, then compute WCAG contrast ratios for every text/background pair found in the pages and flag failures. - Extract spacing values from page geometry and measure them against the token scale — how many magic numbers deviate from the system?
- Use
components/data to measure reuse: which components recur, and which screens bypass the design system entirely?
Every step is deterministic work over JSON — numbers, names, and references. The same audit against a raw .fig file is not possible without routing through Figma’s API. This is a blueprint, not a benchmark, but it shows what the format makes plausible.
What Penpot teaches us
For the wider question — how can AI agents learn to design better? — the lesson is that perception precedes intelligence. Design-as-data lets an agent verify instead of guess: contrast is computed, spacing is checked against tokens, reuse is measured. Feedback loops built on computable signals beat loops built on screenshots.
But a format is a substrate, not a skill. An open archive does not make an agent a good designer; it makes the agent’s mistakes legible, correctable, and automatable at scale.
Limits and conclusion
The limits are real. Penpot’s plugin ecosystem is smaller and less mature than Figma’s, which pairs its APIs with deeper Dev Mode handoff and broader integrations. An open format conveys structure, not semantic intent — the JSON says a button is 24 pixels tall, never why. And “machine-readable” still means work: agents may need custom parsers and wrappers before anything is turnkey.
Still, the direction is clear. For an AI design agent, Penpot offers the stronger foundation for reasoning directly over design files today; Figma offers the stronger platform for team-scale design work around a closed core. If agents are to learn to design, they will learn fastest on files they can genuinely read.