Kombai
Kombai is an AI design engineer that designs standout UIs and writes code that fits your existing repo.
Kombai is the tool we'd reach for when AI-generated frontend has to land in a real repo, not a throwaway prototype. Context Graphs plus the taste agent genuinely attack the two failure modes that make AI UI obvious: default-looking design and code that ignores your design system. It is not the fastest path to a one-off mockup, and the setup isn't trivial.
Verified 5h ago · liveness 81/100 · cite: rightaichoice.com/tools/kombai
- Frontend developers who want AI-generated UI that reuses their components, hooks, tokens, and types
- Design engineers collapsing design and code into one canvas-to-repo workflow
- Teams standardizing design-to-code with shared rules, shared credit pools, and role-based permissions
- Agencies shipping client sites that need high design quality plus stack-matching code
- Non-technical designers who want a no-code visual builder with no repo or IDE involved
- Teams on frameworks outside the 400+ libraries Kombai carries best practices for
- Anyone who just needs a quick Figma-to-code export without codebase indexing or IDE setup
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip Kombai if you want a no-code visual builder or a five-minute Figma export and have no interest in indexing your repo, IDE, or design system into the tool.
Pro caps at 2,000 credits/month, and going past it means buying one-time credit packs rather than a cheaper usage rate — heavier weeks cost more than the sticker price.
Free covers hobbyists and small experiments at 300 credits/month. Pro at $20/mo fits solo developers shipping real products. Team at $40/user/month (up to 20 seats) is where shared rules, shared design systems, external package indexing, and a shared credit pool unlock — that's the real entry point for a team standardizing design-to-code. Enterprise is for large orgs needing SSO/SAML, audit logs, a custom context engine, and custom SLAs. Compared with a raw Figma MCP setup or a single
In short
Kombai — Kombai is an AI design engineer that designs standout UIs and writes code that fits your existing repo. Best for Frontend developers who want AI-generated UI that reuses their components, hooks, tokens, and types, Design engineers collapsing design and code into one canvas-to-repo workflow, Teams standardizing design-to-code with shared rules, shared credit pools, and role-based permissions. Free to start; paid plans from $20/mo.
What's new in Kombai
Checked todayAcross the latest 5 updates: 3 feature updates and 2 changelog entries.
Kombai 2.0.140: faster Canvas screenshots and previews
Kombai 2.0.140 speeds up Canvas screenshots and previews, fixes page previews flashing between wrong and right heights, and stops the Designs gallery from leaking memory on reopen.
Kombai 2.0.138 reworks canvas nodes
Canvas nodes get full title tabs with Mobile, Desktop and Content-height viewport controls plus a Focus button; tall pages get a scrubber and Kombai auto-decides fixed-scroll vs full-height rendering.
Kombai adds Agent Memory per project
Kombai's assistant now keeps per-project long-term memory of coding preferences, build/test quirks and project facts, carried across chats. Toggle in Settings, with created/recalled memory shown in chat.
Kombai lets you queue follow-ups mid-task
Kombai 2.0.137 lets users send a follow-up while the agent is working; it queues until the current task finishes, with a Steer option available per message.
Kombai 2.0.137 adds canvas quick-edit
Selecting a canvas element now opens a floating toolbar for fonts, spacing, borders, corners, backgrounds, links and alignment with instant preview, plus Save/Discard/Undo at the top of the canvas.
What people actually say about Kombai — is it worth it?
We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.
44 mentions across 3 sources (Hacker News, YouTube, Product Hunt) · researched Aug 29, 2026.
Average across the 3 sources that answered — each source counts once, not each post.
- +Deep codebase understanding with Context Graphs for native-feeling code.
- +Reuses your components, hooks, tokens, and types — no rewrite from scratch.
- +Auto-applies best practices for 400+ frontend libraries.
- +Curated design inspiration library — avoids generic AI looks.
- +Figma import is native and parses complex files without MCP.
- −Perceived as a 'vibecoded HTML page with live server' by senior devs.
- −Pricing can feel 'absurd for a wrapper with ui' at $40/user/mo for teams.
- −Risk of generating technical debt, especially without deep codebase review.
- −Steeper learning curve than simpler design-to-code tools like Anima.
- −Some users question whether it truly adds value over prompting an LLM.
- • Credits may run out quickly if you generate many designs or heavy animations.
- • Team tier costs $40/user/month, which adds up fast for larger teams.
- • Extra credits beyond your plan likely cost extra — not specified in the data.
Viability Score
How well maintained and how widely used is Kombai? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: October 2026
How we score →Key Features
- Taste agent makes design decisions (IA, type scale, WCAG accent contrast, structure, content, motion) instead of AI
- Infinite canvas design mode with frame nodes, curated design inspirations, and variations and passes
- Parallel agents across one or many canvases to explore design directions at once
- Generate Versions and Generate Variations for targeted edits or complete redesigns
- Canvas quick-edit toolbar for fonts, spacing, borders, corners, backgrounds, links, and alignment with instant preview
- Context Graphs index components, hooks, tokens, and types from your repo, npm packages, and Storybook
- Index external and private npm packages for reuse as components, tokens, and hooks
- Agent Memory retains per-project coding preferences, build/test quirks, and project facts across chats
- Queue follow-up messages mid-task with a Steer option per message
- Native Figma import that parses complex files, fixes messy grouping and invisible layers, extracts icons and assets —
- Editable browser with live HTML, states, and animations synced back to your codebase
- Autonomous browser testing to verify generated and edited UI flows
- Generate images, videos, and animations from chat with Veo, Seedance, Nano Banana, and more
- Model picker across 50+ models including Anthropic Opus 5.5, Grok 4.7, Kimi K3, Kombai Fable 5.1, GPT Image 2, Seedance
- Kombai Auto router trades cost against creative diversity per task
About Kombai
Kombai is an AI design engineer for frontend teams who are tired of AI output that looks like every other AI page. It ships as a desktop app for macOS, Windows, and Linux plus an IDE extension for VS Code, Cursor, Antigravity, Trae, and Kiro, with 700K+ installs claimed on the homepage. Two modes matter: Design mode gives you an infinite canvas where you generate versions and variations, run parallel agents across one or many canvases, and refine type, spacing, borders, and layout with a quick-edit toolbar before anything touches production. Code mode is where it separates from a design-to-code exporter. Context Graphs index components, tokens, and hooks from your repo, external and private npm packages, and Storybook, then carry them into new work with built-in best practices for 400+ frontend libraries. A native Figma import parses complex files, fixes messy grouping and invisible layers, and pulls out icons and assets without MCP. Rounding it out: an editable browser that syncs live HTML, states, and animations back to your codebase, autonomous browser testing to verify flows, per-project Agent Memory for coding preferences and build quirks, and Git-based versioning of .canvas files. The taste agent is the pitch. It identifies the design decisions a task actually needs, then makes calls on IA, type scale, accent contrast per WCAG, structure, content, and motion instead of falling back on model defaults, drawing on 20k+ curated page and section references. Kombai's own routers pick across 50+ models including Anthropic Opus 5.5, xAI Grok 4.7, Moonshot Kimi K3, and Kombai Fable 5.1, plus image and video models like Veo and Seedance, so you can trade cost against creative range per job. Positioning: against Anima or a plain Figma MCP setup, Kombai indexes your repo rather than exporting markup. Against Cursor or Claude Code alone, it adds a design-first layer plus a built-in frontend agent. That depth is also the cost: setup and a genuine learning curve.
Behind the Verdict
Where Kombai earns its keep is the repo. If your team already has a design system, a component library, and opinions about spacing and type, Context Graphs turn those from suggestions into constraints. We'd pick it for design-heavy frontend work on an existing product, especially if you're already in Cursor or Claude Code and want a design layer alongside your coding agent rather than a replacement for it. When to pass: if you're a designer who wants a no-code visual builder, this isn't that. Repo, IDE, and setup are all part of the deal. Same if your stack sits outside the 400+ libraries Kombai carries best practices for, or if you only need a fast Figma-to-code export and nothing else. The closest alternative depends on what you're buying. For raw design-to-code conversion, Anima or a Figma MCP setup is a lighter lift. For agentic coding, Cursor and Claude Code are broader. Kombai's bet is that the hard part isn't writing code, it's writing the right code with the right design decisions already made. Recent releases tell you where the team is investing: Agent Memory per project (2.0.138+, October 2026) now persists coding preferences and build/test quirks across chats, canvas nodes gained viewport controls and a focus button, and 2.0.137 added queued follow-ups mid-task plus a floating quick-edit toolbar for fonts, spacing, borders, corners, backgrounds, and links. In practice, plan for a real onboarding period. Indexing your repo and Storybook is the step that pays off, and skipping it leaves you with prettier slop. The credit model is worth understanding too: Free gives 300 credits a month, Pro 2,000, and rollover caps differ by plan, so heavy parallel-agent use can burn through an individual allowance faster than expected. The vendor's own comparison claims
Researching Kombai? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas Kombai actually fits — and what changes day-one when you adopt it.
You import a Figma file into the Kombai extension, let Context Graphs index your components, tokens, and Storybook stories, then generate the page in Code mode; you refine spacing and hover states in the editable browser.
Outcome: A production-ready page that imports your existing MatchCard and DataGrid components rather than new lookalike markup, with browser testing catching the broken state before you open a PR.
You open an infinite canvas, run parallel agents to generate three layout directions plus variations, then right-click the winning node to send it to chat for implementation.
Outcome: You compare passes on canvas before anything touches production code, and only the chosen direction becomes a branch in the repo.
You use the Clone URL skill on a reference site the client liked, then apply the client's design system and run the SEO and accessibility audits on the generated page.
Outcome: A client-ready landing page in their stack with audit findings you can hand over alongside the code.
Use Cases
- Generate a production-ready landing page from a Figma design that reuses your existing React components and tokens.
- Create a design variation of a product page by describing a style change, then compare both passes side by side on canvas.
- Recreate a reference website's structure and look with the Clone URL skill before adapting it to your own design system.
- Edit rendered UI in the Kombai Browser — text, layout, states, animations — and sync the changes back into your codebase.
- Autonomously test and debug a checkout flow in a Vue + Nuxt e-commerce app.
- Build a design system from your code or Figma files and apply it across multiple projects.
- Manage several projects side by side in the desktop app without opening an editor.
- Run parallel agents on one canvas to explore several layout directions before picking the one to code.
Models Under the Hood
as of 2026-09-24
Limitations
- Everything runs on credits: Free gives 300/month (150 on sign-up, 50 daily top-up capped at 300) with rollover capped at 0.5x, while Pro stacks 2,000/month with 5x monthly or 12x annual rollover.
- Team (from $40/user/month) and Enterprise gate shared rules/commands, shared design systems, shared credit pool, unlimited rollovers, centralized billing, usage analytics, and custom context engine for large repos (Enterprise).
- The model lineup rotates frequently — the September 2026 changelog added Claude Opus 5.5, GPT 6 Sol/Luna, Grok 4.7, and MiMo V2.6 series while older versions were retired — so pinning a specific third-party model long term is unreliable.
- It is an agent you onboard into your repo, so expect a real setup and learning curve before output matches your stack, and offline use is not indicated (requires desktop app, VS Code, or Cursor).
as of 2026-09-14
Verification history
We have re-verified Kombai 8 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
Showing the 6 most recent of 8 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Kombai tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Free
$0/mo
Ideal for
Hobbyists and solo builders experimenting with ideas and small projects before committing budget.
What this tier adds
Free entry point: 300 credits/month, 150 credits on sign-up, 50 credits daily, rollover capped at 0.5x, 1 seat.
Pro
$20/mo
Ideal for
Solo developers and individual builders turning ideas into polished products who need more than a free hobby allowance.
What this tier adds
Adds 2,000 credits/month, 5x monthly rollover (12x on annual), one-time credit packs, email support, no AI training on your data, SOC 2, and the full model router lineup.
Team
$40/user/mo
Ideal for
Smaller teams building and shipping frontend in sync, up to 20 members including unbilled administrators.
What this tier adds
Adds seats, a shared credit pool with unlimited rollovers, shared rules and commands, shared design systems, external package indexing, role-based permissions, centralized billing, and team usage analytics.
Enterprise
Custom
Ideal for
Larger companies with complex tech stacks and compliance requirements that need a formal contract and security review.
What this tier adds
Adds a custom context engine for large repos, custom credit allowance, SSO/SAML, audit logs, custom data retention and DPA, dedicated support with a shared Slack channel, custom SLAs, and onboarding services.
Where the pricing makes sense
The company stage and team size where Kombai's pricing actually pencils out — and where peers do it cheaper.
Free covers hobbyists and small experiments at 300 credits/month. Pro at $20/mo fits solo developers shipping real products. Team at $40/user/month (up to 20 seats) is where shared rules, shared design systems, external package indexing, and a shared credit pool unlock — that's the real entry point for a team standardizing design-to-code. Enterprise is for large orgs needing SSO/SAML, audit logs, a custom context engine, and custom SLAs. Compared with a raw Figma MCP setup or a single
Setup time & first value
How long it actually takes to get something useful out of Kombai — broken out by persona, not the marketing-page minute.
Solo developer: install the IDE extension or desktop app and expect same-day first value — but budget a few hours to configure your tech stack, index Context Graphs, and connect Storybook before output reflects your repo. Team: add a day for shared rules, shared design systems, and package indexing on the Team tier, plus time for admin setup of shared credit pools and role-based permissions.
Switching to or from Kombai
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From Anima or a one-off Figma exporter: install the Kombai extension, import the same Figma files natively, then add Context Graphs so output reuses your components instead of exported markup.
- →From a raw Figma MCP setup in Cursor: keep Cursor as your editor and add Kombai as the extension so Figma parsing and codebase context come from one place rather than a hand-wired MCP server.
- →From Cursor or Claude Code alone: start with Kombai alongside your existing agent for design-heavy frontend tasks, then move implementation into Kombai's built-in coding agent once Context Graphs are indexed.
- →From hand-coded UI: point Context Graphs at your repo, npm packages, and Storybook stories so Kombai's output inherits the design system you already ship.
- →From a design tool with no code output: export or import your designs into Kombai's canvas, and use the desktop app to manage projects side by side before wiring the extension into the repo.
- ↗To a plain Figma-to-code exporter like Anima: export your canvas designs as PNG or HTML (bundle page images with the Include assets toggle) and hand the markup to the exporter.
- ↗To Cursor or Claude Code alone: your code already lives in git, so commit and branch the generated work, remove the Kombai extension, and keep your repo as the source of truth.
- ↗To a no-code builder: export canvas designs as HTML with bundled assets, then rebuild the layout in the builder outside the repo.
- ↗To a self-hosted or in-house design-to-code pipeline: use the documentation and API/developer entry points to script the flow, and export canvas designs as assets for your own renderer.
Integrations
Resources & Guides
- Documentationkombai.com
Docs · Kombai
Full product docs from kombai.com
- Documentationkombai.com
Welcome · Kombai
Full product docs from kombai.com
- Documentationkombai.com
Figma To Code · Kombai
Full product docs from kombai.com
- Documentationkombai.com
Context Graphs · Kombai
Full product docs from kombai.com
- Resourcekombai.com
Changelog · Kombai
Helpful link from kombai.com
Tutorials & Learning
YouTube returned 6 videos for “Kombai”, and we withheld 6: 6 could not be judged, because “Kombai” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about Kombai.
Official links
Tools that pair well with Kombai
Common stack mates teams adopt alongside Kombai, with the specific reason each pairing earns its keep.
Subframe
Subframe is a design tool for your codebase — a visual canvas plus a coding agent that outputs React and Tailwind code you can edit.
Tempo Labs
Tempo Labs is an AI IDE for React teams: prompt components into existence, then refine them on a visual canvas both designers and engineers share.
Hue
Open-source skill that turns any brand into a full design system for Claude Code and Codex
Featured Head-to-Head Comparisons
Kombai vs Bito
Choose Bito if your team uses AI coding agents like Cursor or Claude Code and needs cross-repo context, architectural planning, and Jira/Linear integration. Choose Kombai if you're a frontend developer or design engineer who wants an AI that understands your codebase, generates production-ready UI code, and visually edits in-browser. Bito excels at backend/system-level context; Kombai excels at design-to-code handoff.
Kombai vs Cognition Ai
Choose Cognition AI if you need an enterprise-grade autonomous software engineer that handles multi-step coding tasks, bug triage, and legacy modernization with a financial guarantee. Choose Kombai if you're a frontend developer or design engineer who wants AI-assisted design-to-code generation that deeply understands your existing codebase and design systems. For most individual devs or small teams, Kombai's lower barrier and design focus are more accessible; for large engineering organizations, Devin's autonomy and integrations are unmatched.
Kombai vs Polycam
Polycam and Kombai serve completely different needs—one captures the real world in 3D, one generates frontend code from designs. If you're an architect, engineer, or forensic professional needing precise 3D scans and floor plans, Polycam is the clear choice. If you're a frontend developer or design engineer shipping production UIs, Kombai's deep codebase understanding and design taste make it a powerful AI partner. Choose based on your domain: physical vs. digital creation.
Alternatives to Kombai
View all
Subframe
Subframe is a design tool for your codebase — a visual canvas plus a coding agent that outputs React and Tailwind code you can edit.
Tempo Labs
Tempo Labs is an AI IDE for React teams: prompt components into existence, then refine them on a visual canvas both designers and engineers share.
Frequently Asked Questions
Categories
Best-of guides
Used Kombai? Help shape our editorial sentiment research.