kombai.com

Kombai runs as a desktop app on macOS, Windows, and Linux, and as an extension inside VS Code and Cursor. For model choice, the site lists a selector with Auto plus named options: Kombai Fable 5.1, Anthropic Opus 5.5, Anthropic Grok 4.7, xAI Kimi K3, Moonshot AI GPT Image 2, and Image OpenAI. Because model lineups and platform builds change, treat the official site as the source of truth before you commit.

Platforms Kombai runs on

Kombai is distributed as a downloadable app and as editor extensions, so you can pick the environment that matches how you already work.

The site states 600K+ installs and counting, and lists availability across these five targets. If your team works entirely in one editor, the extension route keeps design and code in the same loop rather than switching apps.

Model options inside Kombai

Kombai exposes a model selector rather than locking you to a single backend. The listed choices are:

• Auto — lets Kombai pick, useful when you don't want to think about model routing per task.
• Kombai Fable 5.1 — Kombai's own option.
• Anthropic Opus 5.5
• Anthropic Grok 4.7
• xAI Kimi K3
• Moonshot AI GPT Image 2
• Image OpenAI

One practical note from the site's own framing: Kombai says you can "go beyond design slop, even with lower-cost models." That matters if you're choosing a model on cost — the claim is that design quality comes from Kombai's taste layer and repo context, not solely from the most expensive model. Treat that as a product claim to test on your own tasks, not a guarantee.

How to choose a model

There's no single correct pick. A workable approach:

1. Start with Auto so you can see baseline output without tuning.
2. When a task needs stronger reasoning or more polished design decisions, switch to a named model and compare on the same prompt.
3. Keep the model constant across a batch of similar tasks so differences you see come from the task, not the model.

The site doesn't publish per-model pricing or rate limits, so cost comparisons between models aren't something you can settle from the page alone.

What stays consistent across models

Model choice affects generation, but Kombai's stated differentiators sit outside the model:

• Creative Taste — identifies the key design decisions for each task and makes deliberate choices instead of AI defaults.
• Infinite Canvases — explore and iterate on ideas before they touch production code.
• Deep Product Context — reuses components, tokens, and hooks from your repo, npm package, or Storybook.
• Any Model — the model selector itself.

So switching models doesn't reset your design system or repo context; those carry into new work regardless of which model you pick.

Before you decide

Confirm two things on the official site, since both can change:

• The current model list — the selector shown here reflects what the page lists now.
• The current platform builds — download links and editor support are updated over time.

If your question is really "will it fit my stack," the platform table above answers the environment half, and the model list answers the generation half. For anything version-specific, check kombai.com directly rather than relying on a snapshot.

Kombai's infinite canvases give you a scratch space to try design ideas before they touch production code, and parallel agents let you run several of those explorations at once. According to Kombai's site, you can "try different ideas on canvas, before they touch your production code," "run parallel agents in one or many canvases," and "precisely edit text, styles, and layout of any element." This fits teams that want to explore multiple directions quickly while keeping their repo's components, tokens, and hooks intact.

What the canvas is for

The canvas is a design-and-iterate surface, not your codebase. Kombai describes it as a place to:

• Try different ideas before they reach production code
• Work with live HTML, states, and animations
• Create targeted variations or complete redesigns with AI

Because the canvas holds live HTML rather than static mockups, the states and animations you see are the ones you're actually working with. That matters when a design decision depends on how something behaves, not just how it looks.

Running parallel agents

Kombai lets you "run parallel agents in one or many canvases." In practice, that means you can point multiple agents at different explorations at the same time instead of iterating one idea to completion before starting the next.

• One canvas, several agents: compare variations of the same screen or section side by side.
• Many canvases: keep separate explorations isolated so a redesign in one doesn't disturb another.

The benefit is breadth: you can generate several directions, then narrow down, rather than committing to the first output.

Editing on the canvas

Once something is on the canvas, Kombai says you can "precisely edit text, styles, and layout of any element." The site's example controls include:

• Improve Structure
• Surprise me
• Rearrange layout
• Simplify
• Enrich
• Fix hierarchy
• Adjust density

These sit alongside "Generate variations" and the ability to create targeted variations or complete redesigns with AI. So the loop is: generate, adjust a specific element directly, or ask for a variation of the whole thing.

Why it stays consistent with your repo

The canvas is where ideas are explored, but Kombai carries your existing decisions into new work. Its site states it "consistently reuses components, tokens, and hooks from your repo, npm package, or Storybook." It also references a Design System that "remembers your key design decisions" and Context Graphs that let it "code with your components, tokens, and hooks."

That's the point of separating exploration from production: you can experiment freely on the canvas, but the output is meant to fit the patterns already decided in your codebase rather than introducing new ones.

A concrete scenario

Say you're redesigning a landing page hero. You could:

1. Open a canvas and generate a few hero variations.
2. Run parallel agents to explore a split layout, a centered layout, and a scroll-reveal treatment at the same time.
3. Use element-level edits to tune type scale, accent contrast, and hover interactions.
4. Pick the direction that fits, knowing Kombai will reuse your repo's components and tokens when it moves into production code.

What to check before relying on it

Kombai lists availability for macOS, Windows, Linux, VS Code, and Cursor, and cites "600K+ installs and counting." It also notes support for multiple models (including Anthropic, xAI, Moonshot AI, and OpenAI options). For pricing and plan limits, check the pricing page directly, since the site's public description doesn't state cost or usage caps.

Kombai avoids generic AI design by inserting a "taste agent" between the task and the output. Instead of letting the model fall back on statistical defaults, the taste agent identifies which design decisions actually matter for a given task — type scale, accent contrast, hero composition, hover behavior, scroll reveals — and makes deliberate choices for each one. The result is meant to be creative on open decisions while staying consistent with your brief and repo. This applies when you're generating websites or product UIs and want output that doesn't look like every other AI-generated page.

The mechanism: decide first, generate second

The core problem Kombai names is that AI outputs "repeat generic design choices across very different tasks." A landing page for a fintech product and one for a game studio tend to converge on the same layout, spacing, and color instincts because the model reaches for the most probable answer.

Kombai's approach is to break that pattern at the decision level:

• Identify the key decisions for the specific task rather than generating the whole page in one pass.
• Make a high-quality choice for each instead of accepting the AI default.
• Stay creative on open decisions — the parts your brief doesn't constrain.
• Stay consistent with your brief and repo — the parts that are already decided.

The page describes this as "Creative on open decisions. Consistent with your brief and repo." That split is the whole idea: freedom where nothing is fixed, discipline where something already is.

What the taste agent actually considers

Kombai states the taste agent weighs five dimensions when making those choices:

The page illustrates this with concrete decisions pulled from different sources — "Setting the type scale" from a design system, "Checking accent contrast" from WCAG, "Composing the hero section" from inspirations, "Tuning hover interactions" from the repo, "Choosing the scroll reveals" from inspirations. Each decision draws on the source that should govern it, rather than one blanket style.

Where the inspiration comes from

Kombai draws on 20k+ curated pages and sections for design inspiration. This is the counterweight to "AI defaults" — instead of regressing to the mean of its training data, it references a curated set of pages and sections when composing things like hero sections and scroll reveals.

Why this matters beyond aesthetics

The same page frames the problem as two-sided: AI outputs "repeat generic design choices across very different tasks, while missing the code patterns already decided in large repos." So generic output isn't only a visual problem — it's also a consistency problem. Kombai addresses the second half by reusing components, tokens, and hooks from your repo, npm package, or Storybook and carrying them into new work, and by understanding decisions already made in your repo, Figma, Storybook, or websites.

That's why the tagline is "Designed to stand out. Built to fit in." Standing out is the taste agent's job on open decisions; fitting in is the repo-context job on decided ones.

What this means in practice

If you're evaluating Kombai for this specific concern, the useful question isn't "does it produce good design" in the abstract — it's whether the decisions it treats as open match the ones you'd want varied, and whether the sources it pulls from (your design system, repo, Storybook, Figma) are ones you've actually set up. The taste agent can only be consistent with decisions that exist somewhere it can read.

Kombai is available for macOS, Windows, Linux, VS Code, and Cursor, with 600K+ installs reported on the page. Pricing details are listed at kombai.com/pricing.

Kombai reuses your existing components, tokens, and hooks by reading the decisions already made in your repo, Figma, Storybook, or a reference website, then carrying those decisions into new work instead of generating from AI defaults. It does this through two mechanisms named on its site: a Design System that remembers your key design decisions, and Context Graphs that let it code with your components, tokens, and hooks. This matters most when you already have a design system and a large codebase, and least when you are starting from nothing.

The two mechanisms

Design System: remembering design decisions

Kombai's Design System layer stores the design decisions that define your product's look — things like type scale, accent contrast, and component styling. When it generates new UI, it pulls from those stored decisions rather than inventing a fresh visual language for each task.

The site illustrates this with a set of decisions it says it makes per task, each sourced from a different place:

The pattern: decisions that should stay consistent with your product come from your design system or repo, while open creative decisions draw on a curated inspiration library (the site cites 20k+ curated pages and sections).

Context Graphs: coding with your components, tokens, and hooks

Context Graphs are how Kombai connects generated code to what already exists in your codebase. The site states it "consistently reuses components, tokens, and hooks from your repo, npm package, or Storybook, and carries them into new work."

Concretely, the page shows a Context Graph surfacing items like:

• MatchCard · useMatchPolling — a component and a hook from your repo
• @acme/ui — an internal package
• DataGrid · Combobox · +46 — additional components
• Storybook: 12 stories · real props — stories with their actual props
• matches/[id]/page.tsx — a real route in the app

So the reuse is not just visual matching. It resolves the actual component names, hook names, and props that exist in your project, including those exposed through npm packages and Storybook stories.

What "fits in" means in practice

The site frames the problem as two-sided: AI outputs tend to repeat generic design choices across very different tasks, and they miss the code patterns already decided in large repos. Kombai's stated fix is to be "creative on open decisions" while staying "consistent with your brief and repo."

That translates to behavior like:

• Reusing existing components instead of writing new ones that duplicate them
• Applying your tokens rather than hardcoded values
• Calling your hooks rather than reimplementing data logic
• Following the conventions of your stack, with the site claiming built-in best practices for 400+ libraries

Where the reuse inputs come from

Kombai reads decisions from several sources, and you can point it at whichever you have:

• Your repo — components, tokens, hooks, and existing page patterns
• Figma — design decisions captured in design files
• Storybook — stories and their real props
• Websites — reference sites for inspiration on open decisions

If you have a design system and a component library, most of the consistency comes from the repo and Storybook inputs. If you only have Figma, the design side is covered but code reuse depends on what exists in the codebase.

How to verify it's actually reusing your code

Because the value depends on correct reuse, check the output rather than assuming:

1. Generate a piece of UI that overlaps with something you already have (for example, a card that resembles an existing MatchCard).
2. Inspect the generated code for imports from your packages and paths (e.g., @acme/ui) rather than newly defined components.
3. Confirm tokens appear as references, not literal hex values or spacing numbers.
4. Check that data-fetching logic calls your existing hooks instead of new fetch code.
5. If something is missed, the likely cause is that the relevant component, token, or story wasn't available to the context — add it to the repo, package, or Storybook and retry.

When this approach fits

Kombai's reuse model is most useful when you have an established design system and a non-trivial codebase, since that is exactly the situation where generic AI output clashes with existing patterns. It is less relevant for greenfield projects with no components or tokens to reuse, where there is nothing to stay consistent with yet.

The site also notes Kombai is available for macOS, Windows, Linux, VS Code, and Cursor, with 600K+ installs cited on the page. Pricing details are not covered in the provided material, so check the pricing page directly if cost matters for your decision.

Kombai is an AI design engineer for building websites and product UIs. It handles design and production-ready frontend code in the same loop, and it's aimed at developers and product teams who need to both design an interface and ship it. It runs on macOS, Windows, Linux, VS Code, and Cursor, and reports 600K+ installs.

The problem it targets is specific: AI outputs tend to repeat generic design choices across very different tasks, while also missing the code patterns already established in large repositories. Kombai claims to fix both ends of that.

What Kombai actually does

Two capabilities define the product:

• Design that stands out. A "taste agent" identifies the important design decisions for each task and makes deliberate choices instead of falling back on AI defaults. It considers information architecture, structure, style, content, and motion, and draws on a gallery of 20k+ curated pages and sections for inspiration.
• Code that fits in. Kombai reuses components, tokens, and hooks from your repo, npm package, or Storybook, and carries them into new work. It supports 400+ libraries with built-in best practices.

The stated principle is "creative on open decisions, consistent with your brief and repo" — meaning it improvises where nothing is decided yet, and conforms where your codebase already has an answer.

How the workflow is structured

Canvas-based iteration

You try different ideas on a canvas before anything touches production code. From there you can:

• Run parallel agents in one or many canvases
• Edit text, styles, and layout of any element precisely
• Generate targeted variations or complete redesigns with AI
• Work with live HTML, states, and animations

Following what's already decided

Kombai reads design and code decisions from your repo, Figma, Storybook, or websites, and carries them forward. Two mechanisms do this:

Model flexibility

You're not locked to one model. The interface lists options including Anthropic Opus, Anthropic, xAI's Grok, Moonshot AI's Kimi, and OpenAI's image model, plus an "Auto" setting. Kombai states its approach works "even with lower-cost models," so model choice is a cost/quality dial rather than a hard dependency.

Who it's for

Kombai fits you if:

• You need to design a website or product UI and ship the frontend, not just produce mockups
• You work in a large repo where consistency with existing components, tokens, and hooks matters more than novelty
• You want to explore several design directions in parallel before committing to one
• You use VS Code or Cursor as your primary editor

It's a weaker fit if you only need static design files with no code output, or if you're working outside a codebase with established patterns to conform to.

What to check before adopting

• Pricing and plan limits aren't covered here — see the pricing page for current terms.
• Platform support is broad (macOS, Windows, Linux, VS Code, Cursor), but confirm your specific editor and OS combination.
• Repo integration is central to the value proposition, so the practical test is whether it correctly picks up your components and tokens on a real task, not a demo one.

The fastest way to judge it is to point it at one real feature in your own repo and see whether the output reuses your existing patterns or invents new ones.