Models

Coderblock lets you choose which AI model builds your app. Every model strikes its own balance between quality, speed and cost: this page lists the models you can pick today, what each one is generally good (and less good) at, and how to choose.

[!INFO] The list reflects the models available at the time of writing. The exact set in your model picker may vary: we add, update or temporarily pause models, and some are reserved to paid plans. The picker in the editor is always the source of truth.

Auto and Frontier

Besides the individual models, the picker offers two options where the platform chooses for you (see Model picker):

• Auto splits the work into four areas and uses cost-efficient open models, at the quality levels you set. Available on every plan.
• Frontier works the same way but uses premium frontier models selected by our team. Highest quality, more credits. Paid plans only.

Models at a glance

Relative cost is indicative: it compares how many credits the same task tends to use, from $ (cheapest) to $$$$$ (most expensive). Actual usage depends on the task, on how much the model reasons and on your plan.

Anthropic

Claude Sonnet 5

Anthropic's fast frontier model: complete code generation across frontend and backend, and very good at planning and carrying out multi-step work.

• Strengths: a reliable all-rounder for everyday development; quick for a frontier model.
• Weaknesses: uses clearly more credits than the open models.

Claude Opus 5.5

Anthropic's flagship model for code, among the strongest options here for coding and agentic work. Reasoning is always on.

• Strengths: top quality on complex interfaces, architecture and hard bugs; the best pick when getting it right the first time matters.
• Weaknesses: slower, and about twice the per-token price of Claude Sonnet 5, so it uses more credits.

Claude Fable 5

Anthropic's premium tier, with the deepest reasoning in its lineup.

• Strengths: the deepest reasoning.
• Weaknesses: the most credit-hungry model (twice the credits of Claude Opus 5.5). On coding and agentic work, published benchmarks put Claude Opus 5.5 ahead at less than half the price, so for most building work Opus 5.5 is the better value.

OpenAI

GPT-6 Sol

OpenAI's frontier model, strong on reasoning and agentic, multi-step work. It's our recommended pick for the hardest reasoning problems.

• Strengths: reasoning on hard problems, tool use and long tasks; it's notably honest when a tool breaks, reporting the problem instead of hiding it.
• Weaknesses: on pure coding it isn't better than its predecessor; credit usage in the same range as Claude Sonnet 5.

GPT-5.6 Terra

OpenAI's balanced mid tier: good everyday quality at a lower per-token price than the flagships.

• Strengths: questions, analysis and shorter tasks.
• Weaknesses: in third-party tests on long coding tasks it succeeded less often and used many more tokens per task, so a long build can cost more than expected. Not the first choice for generating a whole app.

GPT-6 Luna

The fastest and cheapest OpenAI option.

• Strengths: short, well-scoped tasks: reading code, small edits, quick fixes.
• Weaknesses: weaker on long, complex tasks and on recalling details across long conversations. Not suited to building a whole app.

Open models

GLM 5.3 Flash (Z.ai)

Natively multimodal (it can read screenshots) agentic coding at a fraction of the price of frontier models. It's preselected when you create a new project.

• Strengths: very low cost, reliable tool use, reads images and PDFs page by page; holds up well on long tasks (in our tests it completed builds of over 15 minutes and dozens of files). It's our recommended pick for everyday development.
• Weaknesses: it always reasons before answering, which can make some replies slower.

GLM 5.3 FlashX (Z.ai)

The same model as GLM 5.3 Flash, served by Z.ai on a faster tier: same capabilities (images, tools, reasoning levels), with runs about three times quicker in our tests.

• Strengths: speed; otherwise identical to GLM 5.3 Flash.
• Weaknesses: it costs about 2.5× GLM 5.3 Flash, though it stays among the cheapest models.

GLM 5.2 (Z.ai)

A strong open model for autonomous, long-horizon agentic coding, close to the frontier on coding and tool orchestration.

• Strengths: long multi-step tasks, refactoring, backend work.
• Weaknesses: rougher UI than DeepSeek V4 Pro or Claude Opus (it can't visually check its own work); on the very longest runs it still trails the frontier models; the most expensive open model.

DeepSeek V4 Pro

The best value among open models and the strongest open model for frontend generation.

• Strengths: clean frontend and backend code at a low cost.
• Weaknesses: weaker than GLM and the frontier models on hard real-world engineering and very long multi-step tasks.

DeepSeek V4 Flash

Cheap and quick, with a very large context window.

• Strengths: reading code, questions and small tasks.
• Weaknesses: UI quality below DeepSeek V4 Pro; endurance on long runs less proven.

DeepSeek V4.1 Flash

The newest DeepSeek Flash, available alongside V4 Flash: 1-million-token context, native tools and reasoning, and a much cheaper cache.

• Strengths: short and medium tasks at a very low cost; in long conversations, the parts already seen cost almost nothing thanks to the cache.
• Weaknesses: newly added, so official benchmarks aren't published yet and its endurance on long runs is still to be proven in the field.

Kimi K2.6 (Moonshot AI)

A strong open model for reasoning and research that holds up well in long tool-using sessions.

• Strengths: reasoning, research, planning.
• Weaknesses: pricier output than the other open models, so code-heavy work costs more than with DeepSeek V4 Pro or GLM; smaller context window than most models here; slower.

MiMo 2.5 Pro (Xiaomi)

Experimental: a token-efficient coder with a good quality/price ratio.

• Strengths: low cost, efficient code generation.
• Weaknesses: slow generation; its published results are mostly the vendor's own; experimental.

Which model should I choose?

[!TIP] You can switch model whenever you like. A common pattern: build with a cost-efficient model, then switch to Claude Opus 5.5 or GPT-6 Sol for the pages or bugs that need extra care. Before sending, the in-app estimate (Auto and Frontier) and afterwards your usage history show the real credit cost.