Variant sets, designer talk, and video references

Variant sets — one brief, several directions, judged blind.

Pick 2–4 variants on Home and each option is planned as its own direction (with a risk label — safe, medium, bold), built in its own workspace, and floor-checked before it ever reaches you. A live Variant set card in chat tracks the lanes: queued → building → floor check → ready.

• Compare opens a blind side-by-side: the panes are Left and Right only — variant names stay hidden until the tally lands, so a label can't bias the pick. ←/→ picks a side, T ties, S skips. A pick asks for reason chips and an optional "the loser did X better" line that rides the refine turn; pairs where the swapped judgment disagreed come back as *uncertain*.
• Promote as is lands the winner in the project; Promote & refine starts a turn that borrows the element the loser did better. A per-lane peek previews one option outside the blind round.

Designer talk — the design explains itself.

A fourth preview mode (T) puts the agent's reasoning on the artifact: numbered notes anchored to the element each decision is about — what it did, why, what it traded, and the alternative it rejected.

• Disagree prefills that rejected alternative and lands as a comment pin on the same element, riding the ordinary comment turn back to the agent. Agree records the call and can graduate into a "Make this a project rule" knowledge card. Ask opens a question pin; Skip is a real, counted state.
• Notes are bounded and checked — one that names no rejected alternative is refused as narration, not a decision. On codebase projects they anchor to file:line instead of canvas markers. Answering needs an active licence.
• Each note carries the version it surfaced under, so decisions from an earlier direction stay readable in the rail under "From an earlier version" instead of vanishing.

Video references.

Attach an MP4, MOV or WebM and the studio probes the file, samples frames into a timestamped storyboard plus a short reference brief under .1design/video/, and reports coverage honestly ("Reviewed 16 frames across 00:00–00:42 — audio not analyzed") instead of claiming it watched every frame.

• A chip on the attachment shows the real state — Reading video → Extracting frames → Analyzing → Ready, or Needs input / failed — and the detail card offers bounded recovery: re-extract a range, switch reader, continue text-only, retry or remove — without re-uploading.
• Frames reach the agent only when the selected model can actually inspect images. Capability is resolved per agent × model × delivery path — a CLI that can *send* an image is not proof the model can *see* it — and when no usable route exists the turn says so and continues text-only rather than guessing at visuals nobody inspected.

Settings → MCP access — let an agent in another repo reach in.

The app now answers MCP over stdio: Claude Code, Codex or any MCP client can read a project's files and design system, and render it — screenshots and the kit gate — through a credential you issue.

• Presets scope the grant: *Inspect designs* (read + render) or *Read only*, per project. The credential is shown exactly once — only its hash is kept — and rotates or revokes from the same pane. Access is off until switched on, and revoking takes effect on the next call.
• The Setup tab generates the client snippet; the Tools tab narrows a grant switch-by-switch — the preset is the ceiling, a switch can only tighten it; the Activity tab lists what each credential actually called.

Infographic design type.

"Explain how our approval process works to a new hire" produces one self-contained visual explanation — process, comparison, anatomy, cause-effect, concept-map, or timeline — on a declared canvas (landscape, square, portrait, A4, or custom px). The artifact carries a 1design/infographic/1 semantic model (takeaway, nodes, typed relationships, reading order, simplifications) beside the render, with a built-in "Read the explanation" view. gate --type infographic runs a dedicated checker: model validity, relationship endpoints, reading-order ↔ DOM agreement, family obligations, evidence grounding, geometry, contrast, and delivery captures (native + 2× PNG dims, one-page PDF at the declared @page size, narrow reading capture). Exports pin to the declared canvas: PNG at 1×/2× (32 MP cap), PDF one page at print size, self-contained HTML, and a ZIP that now includes design-evidence/ claims and materials.

Six more coding CLIs in Settings → Agents: Cline, Hermes Agent, Pi, Oh My Pi, Kiro CLI and Aider. The roster now matches 1DevTool's delegation targets. Oh My Pi and Kiro CLI get the studio's MCP tools through a project-local config (.omp/mcp.json, .kiro/settings/mcp.json); the other four run without them and are verified by the host after the turn.

The preview stage is now a real device.

The viewport picker gained Responsive, Phone 390×844, Small phone 360×780, Tablet 768×1024 and Tablet landscape 1024×768 — each renders the artifact at exactly those CSS pixels, scale-to-fit and never cropped, with a W × H · scale% readout and a scroll indicator for the page the artifact's own scrollbar can't show.

• Dragging the stage's right edge pulls any width into custom:W×H, snapping to a device preset within 10 px.
• Compare tiles the three verify bands — narrow, medium, wide — side by side, scrolling in lockstep; a toggle unlinks them.
• These are the same sizes the gate shoots, so the layout you judge in the panel is the layout that was verified.

Code and Split panes.

The result panel's Code view is now a real read-only editor surface: a file picker over the project, line numbers, syntax colors for the languages artifacts ship (HTML, CSS, JS, TSX, JSON, Markdown), copy and soft-wrap — and it re-reads the open file as the agent writes, so the code follows the build. Split keeps the preview beside it.

Any turn can become a version.

The turn bubble's Make a version menu offers the honest conversions: Mark splits the current version so this turn becomes the next version's head (the source keeps its pre-turn state — no file writes), Fork result seeds a new version from the turn's output, and Fork before seeds one from the state just before the prompt ran.

Responsive verify.

The gate now shoots web artifacts at five widths — 1440, 1024, 768 portrait, 390 and 360 — plus a 320→1440 sweep, and document, research and resume gained the tablet shot.

• It also *uses* the narrow layout: every nav or menu toggle it finds is clicked, and a "Menu" button that opens nothing fails the check — the most common responsive defect, invisible in a static shot.
• The plan asks what each section does at narrow (reflow / reorder / reduce / replace), and the critique quotes that stated intent back against the band shots.
• A failing check row that carries a width is clickable — it snaps the preview stage to that exact size — and Fix at this width sends a repair scoped to that band.

A real quality pipeline for 3D.

A brief that names a 3D deliverable gets a requirements sidecar (subject family, quality target, direction pick), and the kit ships versioned 3D directions — flat low-poly, lacquer toy, papercraft, soft clay, stylised PBR product, toon cel, voxel, blueprint technical — each with tested recipes, proportions, materials, a light rig and stated limits, plus a shared scene kit of parts and motion helpers.

• The check is staged, not vibes: construction lint → standard shots from named views and clip times → calibrated critique → a four-domain verdict (technical / requirements / visual / delivery). The 3D inspector's new Review section shows the verdict and the evidence behind it — an unverified domain reads as unverified, never as a pass.
• Findings separate what was observed from the likely cause, and a visual finding only closes when the same view is re-captured and reviewed — a green automatic check can't quietly close it.

Blender as an optional backend.

If Blender is installed, the studio detects it and can run pinned kit recipes — beveled product, organic curved, stylized character — headless, returning the .glb and .blend it actually produced rather than trusting an exit code. The 3D inspector's Backend section reports the capability state; a missing Blender is a route that isn't there, never an error that blocks the procedural path.

Imported 3D assets keep their materials and motion.

GLB textures in the scene editor resolve through the glTF conventions (color maps in sRGB, data maps linear), imported clips scrub on the same playhead as native animation, and skinned meshes clone correctly. A texture that fails to resolve shows an unmistakable checker instead of silently rendering as an untextured surface.

Conversations carry project thumbnails — and name their maker.

Each row in the Home conversation list previews the project's artifact and shows the agent and model that built it, so "which CLI made this one" is answered at a glance. Long lists window 25 rows at a time instead of mounting every card.

"3D Interactive Website" is now "Interactive Website".

The template's name, prompt prefix and description stopped promising 3D the brief may not ask for — the Three.js runtime still ships when the design calls for it.

Version compare scrolls in lockstep.

The two panes link proportionally — scrolling either moves the other through its own range — with a toggle to unlink.

npm-installed agents couldn't start a turn on Windows at all.

Those CLIs land on PATH as .cmd shims, and Windows refuses to hand a batch file a multi-line argument — the prompt is always multi-line — so every run died at spawn with "batch file arguments are invalid". The studio now reads through the shim to the program it wraps. Agents installed under the user profile were also invisible to detection, because ~/ search paths never resolved on Windows.

Antigravity turns landed outside the project.

agy runs its agent tools inside its own CLI project (~/.gemini/antigravity-cli/scratch) no matter which cwd it was spawned with — a turn's first pwd reports the scratch dir. The prompt said "write it in the current working directory", so the whole design went there: entry file, plan, assets. The project got nothing, the preview answered 404, the file picker was empty, and the kit the host had installed at .agents/skills/design-kit was invisible, so the agent searched the disk and used whatever other copy it found. Every turn now names the absolute project root, and agy gets --add-dir <project> on fresh and resumed runs alike.

A quota-stopped Antigravity run said "done" in 0.0s.

agy reports the stop on result.error while the process still exits 0 with empty stderr, and it reports time as duration_seconds, not duration_ms — both were dropped. The turn now fails with the real card ("Individual quota reached…", matched as a rate limit) and its real duration.

The Code pane's file picker, Screens and Share menus opened in the corner of the window.

.popover is position: fixed, but those three placed themselves with a local top/left inside a relative wrapper, so the offsets were measured against the viewport. They now dock to their button through the anchored <Popover>, which portals and stays on screen.

The preview no longer renders a bare not found as the design.

When the entry file isn't in the project folder the panel says so and offers to reveal the folder, instead of framing the preview server's 404 body.

The result toolbar no longer sheds a stray button.

Once the controls outgrew the panel width the bar wrapped, dropping the last icon — usually Present — alone on the far left of a second row. The controls are now one right-aligned cluster: a long file path ellipsizes instead of shoving them out, and anything that still doesn't fit wraps with its neighbours at the right edge.

A failed first run no longer passes the starter template off as your design.

copy_starter lands the kit's fixture page before the agent writes; if the turn failed, stopped or was interrupted without a write, the preview went back to showing that template ("Meridian Marking Co.") as the result. The panel now says the entry is still the untouched starter copy and how the run ended, with a "Show the starter anyway" opt-in for inspecting the scaffolding.

Codex runs again.

Its web_search config key became an enum (disabled | cached | indexed | live), and the old web_search=false was rejected at config load. That value rode every run, so every Codex turn failed before it started.

Codex lists the models your install actually has.

It now reads the account catalog (codex debug models) instead of a curated list that had gone stale — three hardcoded names, none of which this account could pick. The reasoning ladder follows the selected model (GPT-6 reaches ultra, GPT-5.5 stops at xhigh), because passing one a model doesn't support is a hard 400 that fails the turn.

Model lists no longer truncate.

The host's CLI probe kept 256 KiB of output by capping the reader, which made the child take SIGPIPE mid-write — enough for a version string, not for a 350 KiB model catalog. It now reads to the end.

Kimi Code runs again.

kimi -p takes the prompt as its value, so the old argv handed it --output-format and then read stream-json as a subcommand (unknown command 'stream-json').

Antigravity runs again.

agy 1.2.7 turned -p into a value-taking flag, so the old argv made it read --output-format as the prompt and ignore the real one (Error: -p took "--output-format" as its prompt). The prompt is now -p's value and always comes last.

Claude Code turns died at launch when the studio's tools were attached.

--allowedTools takes a variable number of values, so it read the bare trailing prompt as one more tool pattern and the run ended with "Input must be provided either through stdin or as a prompt argument". The prompt now goes after a -- separator the flag can't swallow.

A too-old OpenCode probed "ready", then failed on its own usage text.

The permission flag the studio passes (--auto) only exists since 1.17.12; below it every turn ended with the CLI's help dump and nothing to act on. Settings → Agents now reports "Needs 1.17.12 or newer" against the install it found.

Hermes writes into the project, not your home directory.

Its tools resolve their working directory from TERMINAL_CWD, which neither the spawn directory nor --in overrode — a run in a project folder wrote its file to $HOME. Runtimes can now declare the environment their CLI needs to honour the spawn contract, and Hermes is the one that does.

A finished turn could lose its after-state.

Turn-end events synthesized from the exit code carried a blank turn id, which sanitized to the hidden file .json — the after-capture landed there instead of on the turn that ran, so the real turn kept only its "before" and could never be diffed, forked or restored. Blank ids are now rejected at the write, and the stray an older build left is skipped when listing.

A gate FAIL reported "0 errors, 0 warnings" — and named nothing.

The checker's rows arrived as label + status and were never counted, so a failing verdict showed no findings, and the fix-it turn asked the agent to "see design-check/gate.json" instead of listing what failed. Each row is now counted and named: fail and exception land as errors, warn stays a non-blocking warning, skipped/not-applicable aren't findings.

Gemini CLI.

Google stopped supporting individual-tier accounts in it (IneligibleTierError), so the row could never clear its sign-in state for most users. Antigravity is the same model family, reads the same GEMINI.md, and stays. Projects that already hold a .gemini/settings.json keep it excluded from exports and snapshots.

MCP access is a door you open, not a port we open.

External access is off by default. When you switch it on, an agent in another repository reaches this app over stdio — it launches the app's own binary, no network listener is created — and only with a credential you issue, scoped to read and render on the projects you picked. The credential is shown once and stored as a hash, revoking takes effect on the next call, and every call is listed in the pane's Activity tab.

Everything else stays local-first.

Video storyboards are extracted by local processes under the project's .1design/ folder, Blender recipes run your own Blender install, and projects, exports and agent accounts never leave your disk — nothing is proxied through StoicSoft.