Launching soon. Founders pricing locked in.

A desktop builder for Qwen Code.

I tuned the harness. You take the reins.

Real prompt. Real plan. Real Build it.

A native desktop app for macOS, Windows, and Linux, built around Alibaba's Qwen Code. The agent plans, builds, runs your tests, and iterates while you steer. Live browser preview, local project index, and GitHub and Supabase MCPs already wired in.

Notify me at launch

macOS · Windows · Linux. Launching soon.

Founders offer

$79one-time

First 1,000 buyers get Qwentin for $49. After that, the price moves to $79. No subscription, ever.

14-day free trial on launch

Try Qwentin free for two weeks the moment it ships. Lifetime v1.x updates included.

Bring your OpenRouter account. Pay-as-you-go for the model calls themselves, no subscription, and a few dollars of credit goes a long way. Free tiers aren't supported, because their rate limits break autonomous multi-step runs.

Autonomous builder

It plans, writes, tests, then iterates.

Describe what you want. Qwentin breaks it into a plan, builds it, runs your tests, and works through whatever broke. Most things it fixes on its own. The rest it brings back to you with a question. You steer instead of typing.

No copy-pasting between a chat window and your editor. The agent has your project and your terminal.

Live preview

Click an element. Tell Qwentin what to change.

Click any element in the preview and Qwentin tags it for your next prompt. Say “make this round” or “change the wording” and the agent already knows which one you mean. No long descriptions, no DOM-spelunking.

Browser console capture works the same way. A runtime error lands in the next turn without you pasting it. Hot reload too, by default.

Knows your project

Local context, no round-trips.

Qwentin indexes your project the moment you open it. Embeddings on your machine, stored on your machine. The agent searches it directly, so it knows where things live before you finish typing the question.

Multi-threaded. Resumes if you close mid-index. A small progress toast tells you what file it's on and how much is left.

Queue, force, iterate

Stack up your next thoughts.

While the agent's running, type the next message. And the one after. Qwentin queues them and runs each as soon as the current turn ends, so you don't have to babysit.

Hit force-send to cut in. The card collapses out of the way when you don't need it.

Zero to first build

Install, paste key, build.

Install, accept the EULA, paste your OpenRouter key, open a folder. That's the whole onboarding. No dashboard to learn, no account to create.

Works offline once installed, except for the actual AI calls to OpenRouter.

Everything else

Built for the people directing the build.

All the polish you'd expect from a paid app, without the subscription.

Tuned for Qwen, by design

Qwen is the engine underneath, so the harness is shaped around how Qwen behaves. Open-source alternatives like DeepSeek and Kimi run through the same harness via OpenRouter as first-class second seats. Swap any specialist over to them per row.

Auto-review

When the builder auto-commits, a separate cross-family reviewer scans the diff. It flags what it spots and leaves clean turns alone. Swap the reviewer's model from Settings → Specialists.

Self-driving UI

The agent can open the right settings panel, switch to the preview, or refresh the dev server, with the same shortcuts you use.

MCP, batteries included

Browser preview, git, web search and fetch, project index, GitHub, and Supabase are pre-wired. Add any other MCP server in two clicks.

MCP debug overlay

Opt-in panel showing every tool call, duration, and verdict. Off by default; built for the day something feels wrong.

Your API key, your call

Bring your OpenRouter key. Prompts and source go straight to OpenRouter, never through me.

Local first

Projects, sessions, settings, and keys live on your machine. No cloud. No accounts. No lock-in.

Keychain crypto

Your API key sits in the OS keyring on macOS (Keychain) and Linux (Secret Service). On Windows, AES-256-GCM in a local file inside your user profile.

Auto updates

Signed updates over the Tauri updater. You see what's new and choose when to install. New versions roll out when there's a real fix or feature, never on a fixed cadence.

And a hundred small things

The boring details, handled.

Quietly running underneath the polish, so you don't notice them until you need them.

Plan, default, auto-edit & yolo modes
Planner subagent
Skills (per-project + global)
Memory (per-project + global)
Native /compress, /clear, /stats, /memory
Auto-continue on long turns
Auto-compress when context fills
Git checkpoints
Worktree-aware sessions
Live cost & token usage
Cache-discount aware
Click-to-edit element picker
Browser console capture
Auto-retry on transient errors
Tool-hang watchdog
Crash-safe recovery
OS keychain (with encrypted fallback)
Offline license activation

Worth knowing about Qwentin

What it is, and what it isn't.

Qwen is the engine. The prompts, the planner, the auto-review pass, the sub-agents, all of it has been shaped around how Qwen behaves. If you run on Qwen, you're running Qwentin the way it was built to be used.

Open-source alternatives are first-class second seats. DeepSeek and Kimi run through the same harness, sub-agents, and discipline via OpenRouter. They don't get the same careful tuning Qwen does on the harness side, but every specialist is overridable per row. Mix and match. Closed-source picks stay available in the picker for users who want them.

Cloud first, local as a backup. OpenRouter pay-as-you-go is what most days look like. Local mode through Ollama, LM Studio, or vLLM works, and I keep improving it, but unless your GPU is doing real work, the cloud path is faster, cheaper, and the one I'd point you at to start. Setting that expectation up front so nobody gets caught out.

Next milestone

Local mode that holds its own.

Local Ollama is already built in. Once Qwentin ships, point it at any model on your machine and the agent runs there, no keys, no per-token cost, nothing leaving your hardware. The catch is honest: unless your GPU is doing real work, builds are slower than the cloud path, and the harness was built around cloud throughput.

The next push is making local feel as natural as cloud. Better prompts for smaller models, leaner tool loading, smarter context handling. Some of it has already landed. Once we're past 200 license sales after launch, the rest of the engineering time gets committed and the polished local mode lands free for every v1.x license holder.

Count me in$49 founders license, one-time.

From the developer

One person. No servers. No surveillance.

Qwentin is a one-person project. No startup, no investors, no support team. That means your prompts and source never pass through any server I run, because I don't run any.

What's here today is solid. I use Qwentin every day to build Qwentin. Once it's out, every license sale will fund whatever ships next, in that order.

If it doesn't take off after launch, founders keep what they bought either way. Every v1.x release is yours for life.

Not yet released

Drop your email. I'll tell you when it's ready.

One email when Qwentin opens to buyers. No newsletter, no drip sequence, no sharing your address. Unsubscribe with one click whenever.