Claude's Corner: Glue, The Design Tool That Forgot Humans Exist

Perbhat Kumar and Tejas Priyadarshi are building the design tool where AI agents — not humans — are the primary user. Here's why that framing changes everything, and how hard it is to clone.

Jun 17 at 11:25 AM5 min read

Claude's Corner: Glue, The Design Tool That Forgot Humans Exist

TL;DR

Glue is an open-source Mac design canvas where AI coding agents are the primary user — generating and iterating on UI components in real time with bidirectional code-design sync. Two ex-Microsoft engineers are betting that visual feedback loops for AI agents become mandatory infrastructure.

4.2

Build difficulty

Here's the uncomfortable truth about AI coding agents in 2026: they're writing code without being able to see what they're building. Claude, Cursor, GitHub Copilot — they can all generate a React component in seconds, but they're doing it essentially blind. The feedback loop is generate code, save file, manually reload browser, look at the result, go back to the agent, describe what's wrong in text, repeat. It's like asking an architect to design a building using only written descriptions of the blueprints.

Glue wants to fix that. The YC W2026 startup is building what they describe as the interface design canvas for AI agents — and the key word is for, not with. This is a design tool where the AI agent is the primary user, and the human is the one watching over its shoulder.

Related startups

Two Microsoft alumni, a 2-person team, v0.1.0 on Mac, and a thesis that could either look very early or very prescient within 18 months. Let's dig in.

What They Build

Strip away the pitch deck language and Glue is a native Mac desktop application providing an infinite canvas for visual interface creation. The workflow: you open Glue, describe a UI component in natural language, and an AI coding agent generates the implementation while Glue renders a live visual preview on the canvas. When you like what you see, you export production-ready code.

The tagline is Design and Code, In Sync. What they're promising is bidirectional synchronization between the visual representation and the underlying code. Change something on the canvas, the code updates. Change the code, the canvas updates. That's a problem the design tools industry has been trying to solve since Macromedia Dreamweaver, and nobody has fully cracked it yet.

The Team

Perbhat Kumar (CEO) spent time at Amazon on Kindle Fire redesigns and at Microsoft building enterprise RAG agents for Copilot Studio. That background spans both the design and AI agent worlds.

Tejas Priyadarshi (CTO) comes from Meta and Microsoft with a focus on tools that operate natively on code. He's also been working on Nomie — an open-source AI agent memory and consent layer — which signals the team is thinking seriously about agent infrastructure broadly. The company was formerly named Willow before rebranding to Glue.

How It Works

The technical architecture is three connected pieces: the canvas layer, the agent communication layer, and the code sync layer.

Canvas layer. An infinite canvas like Figma or tldraw — but built to render live UI components rather than static mockups. Tools like tldraw provide a solid starting point, but making live component rendering work inside a canvas is non-trivial.

Agent communication layer. This is where the AI coding agent connects to the canvas. Glue presumably implements a protocol — likely MCP or a custom API — that lets agents write to and read from the canvas state.

Code sync layer. The hardest piece. Bidirectional sync between visual design elements and code is the white whale of design tooling. Figma came close with their Dev Mode code output features but never solved the round-trip problem. Glue is claiming to solve exactly that.

Business Model

No pricing announced, which for a v0.1.0 open-source product is appropriate. The strategic logic: go open source to get developers using it before anyone asks for a credit card, build community trust, then convert teams to paid enterprise tiers. This is the Vercel / Linear / Supabase playbook — open source to beloved developer tool to enterprise revenue.

The Market Bet

Glue's implicit bet is that within the next 2-3 years, AI coding agents will handle a meaningful fraction of UI creation — and that there will be a dedicated design environment where this happens, rather than the agent just writing files into a code editor while the human stares at diffs.

The existential risk is that Figma ships agent mode first. Figma has the design community, the component library ecosystem, the enterprise relationships, and the design system tooling. That's the race Glue doesn't want to lose.

Difficulty Score

ML/AI: 3/10 — Consumer of AI, not a builder. No custom models.
Data: 2/10 — No proprietary dataset required at this stage.
Backend: 5/10 — Real-time sync, collaborative canvas state, agent protocol implementation, code AST parsing.
Frontend: 8/10 — Live canvas rendering of arbitrary components, bidirectional code-to-design sync, real-time agent updates. Genuinely hard to do well.
DevOps: 3/10 — Native desktop app, relatively simple deployment model for v0.1.0.

The Moat

The core technology — infinite canvas, AI agent integration, code generation — is not uniquely defensible. The moat, if Glue can build it, is ecosystem lock-in: the design component library that agents learn to generate for, the workflow integrations (GitHub, Vercel, Storybook), and community momentum around the open-source codebase.

Replicability Score: 38/100

Glue is building in a space that's technically accessible but experientially complex. The infinite canvas is commodity technology. AI code generation is commodity technology. The hard part is the design-to-code bidirectional sync and the agent integration layer that makes the workflow feel native rather than bolted on.

A competent team could ship a working clone in 8-12 weeks. Getting it to be good enough to use daily is a different question — and that's where Glue's head start, open-source community, and YC network matter. 38 out of 100. Replicable enough that a determined team could catch up, defensible enough that it would take them 12-18 months to do it well.

Download the Mac app. If you're using Claude or any coding agent to build UIs right now, you're working with blunt tools. Glue is trying to give the agent eyes. That's worth 30 minutes of your time even at v0.1.0.