# Morph V3 Large Some code edits are straightforward: a function body changes, a parameter gets added. Others aren't. When a refactor moves logic between classes, modifies two nested scopes at once, or touches repeated patterns throughout the file, merge accuracy becomes the bottleneck. Morph V3 Large targets those harder cases. - **Model ID:** `morph/morph-v3-large` - **Type:** chat - **Providers:** morph - **Context window:** 81,920 - **Maximum output tokens:** 16,384 - **Pricing:** $0.9/1M input tokens, $1.9/1M output tokens - **Canonical page:** https://vercel.com/ai-gateway/models/morph-v3-large ## Supported parameters Detailed capability metadata has not been reported for this model. ## Example ```ts import { streamText } from 'ai' const result = streamText({ model: 'morph/morph-v3-large', prompt: 'Why is the sky blue?' }) ``` ## About Morph V3 Large is the accuracy-optimized half of the Fast Apply pair. Both models share the same core concept: a model trained to merge AI-generated edit snippets into source files. v3 Large allocates more capacity to difficult cases. Morph's benchmarks cite about 98% merge accuracy on this task versus general-purpose code models they tested. Versus v3 Fast, v3 Large runs at roughly half the speed and costs $0.9 per million input tokens and $1.9 per million output tokens on this page. v3 Fast lists lower per-token rates on AI Gateway; open that model page to compare. For simple single-scope edits, the extra cost buys little because Fast already handles them. For edits that cause merge failures (multi-scope changes, overlapping regions, refactors that redistribute code across functions, files with highly repetitive structures), the added accuracy reduces broken builds, failed tests, and rework. Morph also ships an `auto` model that routes between Fast and Large from detected edit complexity. If you don't want to classify edits yourself, start with `auto`. Pick v3 Large when you know edits are complex, when v3 Fast failed on specific patterns, or when a failed merge is costlier than the extra per-token spend. See https://morphllm.com/ and https://morphllm.com/blog/what-is-morph-for for product context. ## What to consider Like v3 Fast, v3 Large is a single-purpose code merging model. Place it in the file-write layer of a coding agent architecture, not as a standalone assistant. ## When to use ### Best For - Multi-scope refactors that modify several functions or classes within a single file at once - Edits in files with repetitive patterns (similar method signatures, templated code, generated boilerplate) where merge ambiguity is high - Pipelines where a failed merge triggers expensive downstream consequences (broken CI, rollback, manual review) - Fallback for edit patterns where v3 Fast has produced incorrect output ### Consider Alternatives When - The edit is a simple single-scope change and latency matters. v3 Fast handles these at about twice the speed for lower cost - You want the system to pick the model. Morph's `auto` routing is the hands-off option - You need a general-purpose code generation or chat model rather than a merge tool ## Best for - **Multi-scope refactors:** Edits modify several functions or classes within a single file at once - **Repetitive pattern edits:** Similar method signatures, templated code, or generated boilerplate where merge ambiguity is high - **High-cost merge failures:** Pipelines where a failed merge triggers broken CI, rollback, or manual review - **Fast variant fallback:** Fallback for edit patterns where v3 Fast has produced incorrect output ## Consider alternatives - **Simple single-scope edits:** v3 Fast handles these at about twice the speed for lower cost - **Hands-off routing:** Morph's `auto` routing picks the model automatically - **General-purpose model:** You need a code generation or chat model rather than a merge tool ## Frequently asked questions ### What makes a code edit "complex" enough to warrant v3 Large? Edits that span multiple functions or scopes, sit near duplicated structures, move logic between blocks, or touch overlapping regions. Simpler merge strategies, including v3 Fast in some cases, fail more often on those patterns. ### Can I use both v3 Fast and v3 Large in the same pipeline? Yes. A common pattern defaults to v3 Fast for speed and falls back to v3 Large when Fast errors or the edit is flagged complex. Morph's `auto` model automates that routing. ### How does v3 Large compare to using a frontier model for full-file rewrites? v3 Large uses on the order of 700 to 1,400 tokens per edit. A frontier model that rewrites the whole file often needs 3,500 to 4,500 tokens and several seconds. v3 Large stays faster and cheaper than a full rewrite on the merge task for typical setups. ### What is the input format? Same as v3 Fast: an original file in `` tags, an edit snippet in `` tags using `// ... existing code ...` markers, and an optional `` tag. Call Morph V3 Large through the AI SDK, Chat Completions API, Responses API, Messages API, or other API formats, from TypeScript or Python. ### Does the context window of 81.9K tokens matter for code merging? Rarely in practice. Even large single files stay well under 81.9K tokens. You won't hit this limit in typical merge operations. ### Is v3 Large overkill for most edits? Yes, for routine single-scope work v3 Fast is enough. v3 Large matters most on the smaller share of edits that are structurally hard and likely to break if merged wrong. ### Where are list prices for this model? Current rates appear on this page. AI Gateway tracks live pricing across each provider that serves the model. ## Links - [Model page](https://vercel.com/ai-gateway/models/morph-v3-large) - [AI Gateway documentation](https://vercel.com/docs/ai-gateway) - [Provider model documentation](https://morphllm.com/blog/what-is-morph-for) - [Provider pricing](https://morphllm.com/dashboard)