Models

Kiro gives you access to frontier and open weight AI models from OpenAI, Anthropic, and other providers. GPT-5.6 brings OpenAI models to Kiro for the first time, with three tiers that balance agentic performance and cost. Pick the right model for the job, or select Auto to let Kiro route each task to the optimal model automatically.

Cost is relative to Auto (1.0x baseline). For example, a task that costs 10 credits on Auto would cost 22 credits on Opus, 4 credits on Haiku, or 0.5 credits on Qwen3 Coder Next.

While models may be available in multiple regions, where your requests are processed depends on your account type and, if applicable, your region selections. See here for more information.

Use the model dropdown in the chat interface, or set your default from the command line. If for some reason a model from the list above does not show up in the drop down, restart your client and that should resolve the issue.

kiro-cli settings chat.defaultModel claude-opus-4.8

To save your current model as the default for all future sessions:

> /model set-current-as-default

This stores your preference in ~/.kiro/settings/cli.json. New sessions automatically use this model.

Model availability can vary by country or region. Kiro's model offerings align with each provider's usage and geographic requirements. For more information, see supported countries and regions: OpenAI, Anthropic, MiniMax, Zhipu AI (GLM), DeepSeek, and Qwen.

Choose Sol for your hardest multi-step work, especially spec-driven implementation, long-horizon refactors, and complex terminal tasks. It is OpenAI's flagship GPT-5.6 tier for frontier reasoning, coding, long-horizon planning, and workflows that require iteration and tool coordination. Sol scores 80 on the Coding Agent Index and 88.8% on Terminal-Bench 2.1, above Claude Fable 5 on both while using less than half the output tokens and taking less than half the time. Sol has a 2.4x Kiro credit multiplier.

Choose Terra for routine multi-step development when you want a middle ground between Sol's maximum capability and Luna's speed and Kiro credit efficiency. Terra scores 77.4 on the Coding Agent Index, compared with Claude Fable 5's 77.2. OpenAI separately describes Terra as GPT-5.5-competitive at half the API cost. That API comparison does not determine Kiro credit use; Terra has a 1.2x Kiro credit multiplier.

Choose Luna for high-frequency agentic tasks where speed, throughput, and Kiro credit efficiency matter more than maximum capability. OpenAI describes Luna as its fastest and lowest-cost GPT-5.6 API tier. Luna scores 74.6 on the Coding Agent Index, compared with Claude Opus 4.8's 72.5. Luna has a 0.6x Kiro credit multiplier, one-quarter of Sol's 2.4x multiplier.

All three GPT-5.6 tiers have a 272K context window. Kiro provides experimental support in us-east-1 and eu-central-1 with cross-region inference. Learn more.

Kiro's model router. Auto combines multiple frontier models with optimization techniques to deliver the best quality-to-cost ratio, automatically choosing the optimal model for each task. Free tier users get Claude Sonnet 4.5-class quality or better, while paid tiers get Claude Opus 4.6-class quality or better with enhanced traffic routing. Auto maintains a high quality bar to ensure results compare to or exceed the individual models available to you.

Auto is treated as its own selectable option under model governance: administrators can allow or block Auto for their users. However, when Auto is enabled, it does not restrict its internal routing to the models an administrator has approved; it may route requests to any model available in Kiro in that region. Customers who need to guarantee that only approved models process their requests should block Auto and set an approved model as the default.

Anthropic's most honest Opus model. Around 4x less likely than its predecessor to let flaws in generated code pass unremarked — it flags uncertainties and pushes back when evidence is thin rather than confidently claiming progress. Tool calling is meaningfully more efficient, using fewer steps for the same intelligence. Early testers report stronger judgment on when to act vs. when to ask, and better follow-through on long-running agentic tasks. Ships with 1M context window and 128K max output. Available in us-east-1 and eu-central-1 with cross-region inference. Learn more.

Introduces adaptive thinking: the model automatically scales its internal reasoning based on task complexity. Simple questions get fast responses; complex architectural problems get deeper analysis, without you configuring anything. Beyond that, Opus 4.7 follows instructions more precisely, verifies its own outputs before reporting back, and supports 3x higher resolution vision for working with dense screenshots and diagrams. Available in us-east-1 and eu-central-1 with cross-region inference. Learn more.

Top scores on Terminal-Bench 2.0 and SWE-bench Verified for agentic coding. Stays productive over longer sessions without context drift and handles multi-million-line codebases, planning upfront and adapting as needed. Strong debugging and code review capabilities let it catch its own mistakes through careful planning and self-correction. Learn more.

Handles tradeoffs and ambiguity well when working across multiple systems. Strong single-shot accuracy on complex problems where you need a correct answer on the first attempt, without iterative back-and-forth. Well suited for sophisticated software development challenges that span service boundaries. Learn more.

Anthropic's most agentic Sonnet model. Performance approaches Opus 4.8 on reasoning, tool use, coding, and knowledge work, at Sonnet-class pricing. Plans before it edits, runs longer without supervision, and checks its own output without being asked. Early testers consistently describe it as finishing complex tasks where prior Sonnet models would stop short. Well suited for spec-driven workflows where you need higher-fidelity implementation across broad changes, and for multi-step agentic tasks in the CLI and Web that run to completion with less supervision. Learn more.

A full upgrade from Sonnet 4.5 that approaches Opus 4.6 intelligence while being more token efficient. Excels at iterative development workflows and maintains context across long sessions. Handles both lead agent and subagent roles in multi-model pipelines, making it well-suited for teams using Kiro powers and custom subagents. Learn more.

Strong agentic coding with extended autonomous operation — can work independently for hours with effective tool usage. Improved planning, system design, and security engineering compared to Sonnet 4.0. Learn more.

Direct access to Anthropic's Claude Sonnet 4.0 for users who prefer consistent model selection. Same model for all interactions with no routing or optimization layers. Full control and complete transparency, with predictable behavior for workflows that depend on specific model characteristics. Learn more.

Anthropic's fastest model with near-frontier performance. Matches Sonnet 4 performance across reasoning and coding at more than twice the speed. Near-frontier intelligence at one-third the cost, and the first Haiku model with extended thinking capabilities. Learn more.

Open weight model that matches frontier-class coding performance at a fraction of the cost. Trained with reinforcement learning across hundreds of thousands of real-world environments, delivering strong results across the full development lifecycle from system design to code review. 0.25x credit multiplier with inference running in US East (N. Virginia) and EU (Frankfurt). Learn more.

Open weight sparse mixture-of-experts model with a 200K context window, designed for complex systems engineering and long-horizon agentic tasks. Excels at processing repository-scale context and maintaining coherence during multi-step tool use across large codebases. Well suited for cross-file migrations, full-stack feature development, and legacy refactoring where the model needs to hold the full picture. 0.5x credit multiplier with inference running in US East (N. Virginia). Learn more.

Open weight model best suited for agentic workflows and code generation. Handles long tool-calling chains, stateful sessions, and multi-step reasoning well. 0.25x credit multiplier with inference running in US East (N. Virginia). Learn more.

Open weight model best suited for multilingual programming and UI generation. Delivers strong results across Rust, Go, C++, Kotlin, TypeScript, and others. 0.15x credit multiplier with inference running in US East (N. Virginia) and EU (Frankfurt). Learn more.

Open weight model purpose-built for coding agents with 256K context and strong error recovery. Works especially well for long agentic coding sessions in the CLI. 0.05x credit multiplier, the most cost-effective option available, with inference running in US East (N. Virginia) and EU (Frankfurt). Learn more.

Each model family brings a distinct working style. Understanding these differences helps you pick the right one for the task.

GPT-5.6 models can write lightweight programs that coordinate tools and process intermediate results instead of making separate round-trips for each step. This reduces token use and dead ends, especially for spec implementation, terminal workflows, and multi-file refactors. All three tiers support longer unsupervised execution and use hidden chain-of-thought, so you see the final output rather than internal reasoning steps. Choose Sol for the hardest long-horizon work, Terra for balanced routine development, and Luna when speed and Kiro credit efficiency matter most.

Opus models plan thoroughly before acting, considering multi-step approaches and edge cases upfront. They catch their own mistakes through careful review and flag uncertainty rather than confidently claiming progress. Starting with Opus 4.7, reasoning depth scales automatically based on task complexity — simpler prompts get fast responses while harder problems receive deeper analysis without you configuring anything. Opus excels at sustained multi-file work, complex debugging, and architecture decisions where self-verification matters.

Sonnet models balance strong agentic performance with lower Kiro credit use (1.3x versus 2.2x for Opus). Sonnet 5 plans before editing, runs longer without supervision, and checks its own output — approaching Opus-class results for spec-driven workflows and multi-step CLI and Web tasks. Earlier Sonnet models are more conservative and stick closer to what you asked for, making them predictable choices for focused, well-scoped work.

Open weight models offer frontier-competitive coding at the lowest Kiro credit multipliers (0.05x–0.5x). They are well suited for long sessions, high-throughput agentic work, and tasks where credit efficiency matters more than peak single-turn capability. MiniMax M2.5 delivers near-Opus results across the development lifecycle. GLM-5 handles repository-scale context for cross-file migrations and full-stack work. DeepSeek 3.2 handles long tool-calling chains and multi-step reasoning. Qwen3 Coder Next is the most cost-effective option with strong error recovery for extended CLI sessions.

For models that support configurable reasoning effort, you can control how much reasoning the model applies to your prompts. Lower effort levels produce faster, shorter responses and use fewer credits. Higher levels spend more tokens on deeper analysis, multi-step reasoning, and thorough code generation.

Use the /effort command to change the reasoning level:

# Open interactive picker
/effort

# Set directly
/effort high

The picker only shows levels available for your current model:

See Effort for detailed documentation on per-model defaults and persistence.

• Bump up when the agent is giving shallow answers, missing edge cases, or producing incomplete implementations
• Bump down when you need quick answers and don't want to wait for extended reasoning
• Use the highest level for security reviews, complex debugging sessions, or when you need the agent to consider many interacting constraints

Models in Kiro go through two stages. Each stage reflects the model's maturity and the level of support you can expect.

• Start with Auto for most work. It optimizes both quality and cost automatically.
• Use GPT-5.6 Sol for the hardest multi-step work — spec-driven implementation, long-horizon refactors, and complex terminal tasks where you need state-of-the-art agentic performance.
• Use GPT-5.6 Terra or Luna when you want strong agentic capability with throughput or cost as the primary concern. Terra for balanced performance, Luna for maximum efficiency.
• Switch to Opus when you hit a wall on a complex problem or need sustained multi-file work with strong self-verification.
• Use Sonnet 5 when you want strong agentic behavior at a lower cost than Opus, especially for multi-step tasks that need to run to completion.
• Use Haiku for quick iterations, simple fixes, or when you want to conserve credits.

• Monitor your usage in your account settings to understand how model choice affects consumption.
• Factor model cost into your tier: If you primarily use Opus, consider Pro+, Pro Max, or Power for more credits. See plans and billing for details.