# Mercury Coder Small Beta

Mercury Coder Small Beta is a speed-first diffusion language model built for code generation. It generates through parallel token refinement rather than sequential autoregressive decoding.

- **Model ID:** `inception/mercury-coder-small`
- **Type:** chat
- **Providers:** inception
- **Context window:** 32,000
- **Maximum output tokens:** 16,384
- **Pricing:** $0.25/1M input tokens, $1.0/1M output tokens
- **Canonical page:** https://vercel.com/ai-gateway/models/mercury-coder-small

## Supported parameters

Detailed capability metadata has not been reported for this model.

## Example

```ts
import { streamText } from 'ai'

const result = streamText({
  model: 'inception/mercury-coder-small',
  prompt: 'Why is the sky blue?'
})
```

## About

Mercury Coder Small Beta belongs to the Mercury family of diffusion large language models (dLLMs) from Inception Labs. Unlike transformer-based code models that emit tokens one at a time, Mercury Coder Small Beta uses a coarse-to-fine generation process. It produces a rough complete draft and refines all positions in parallel over a small number of passes. Mercury Coder Small Beta runs faster than autoregressive alternatives at comparable quality tiers. Live metrics on this page show current rates.

Mercury Coder Small Beta scores 90.0 on HumanEval and 84.8 on fill-in-the-middle (FIM) tasks. FIM maps directly to IDE autocomplete, where the model completes code surrounded by existing context on both sides. Its MBPP score of 76.6 and MultiPL-E score of 76.2 reflect results across Python-centric and multi-language coding evaluations.

The model targets high-frequency, latency-sensitive coding applications: inline completions, documentation generation triggered on keystrokes, and fast unit test synthesis. At $0.25 input / $1.0 output per million tokens, Mercury Coder Small Beta suits developers who need reliable code quality without the cost or latency overhead of frontier-scale models on every request.

## What to consider

Mercury Coder Small Beta's diffusion generation pattern differs from autoregressive streaming. Factor that in when you design editor integrations or autocomplete pipelines that depend on incremental token delivery.

## When to use

### Best For
- IDE inline autocomplete where sub-100ms response time matters
- Fill-in-the-middle code completions in editors with surrounding context
- High-volume coding pipelines where per-call cost is a significant factor
- Fast unit test and docstring generation triggered as part of a CI/CD workflow
- Lightweight coding agent loops that make many small inference calls per task

### Consider Alternatives When
- Tasks require deep multi-file reasoning across very large codebases
- LiveCodeBench-style competitive programming problems are the primary use case
- Your workload demands broad domain knowledge beyond code (e.g., long-form prose, complex math proofs)
- Maximum context window length is the binding constraint for the task

## Best for

- **IDE inline autocomplete:** Low response latency for keystroke-level completions
- **Fill-in-the-middle completions:** Editor completions surrounded by existing code context on both sides
- **High-volume coding pipelines:** Per-call cost is a significant factor at scale
- **CI/CD test generation:** Fast unit test and docstring generation triggered inside pipelines
- **Lightweight agent loops:** Coding agents that make many small inference calls per task

## Consider alternatives

- **Deep multi-file reasoning:** Tasks span very large codebases and demand cross-file analysis
- **Competitive programming benchmarks:** LiveCodeBench-style problems are the primary use case
- **Broad domain knowledge:** Workload includes long-form prose or complex math proofs beyond code
- **Maximum context window:** Context length is the binding constraint for the task

## Frequently asked questions

### How does Mercury Coder Small Beta's diffusion approach differ from standard code models?

It generates a full draft, then refines all token positions in parallel over iterative passes. Standard code models generate tokens left to right, one at a time. This parallel approach enables higher throughput on the same hardware.

### What is Mercury Coder Small Beta's fill-in-the-middle score?

84.8 on FIM benchmarks. FIM measures how well a model generates code that fits between an existing prefix and suffix, which maps to editor autocomplete.

### How does Mercury Coder Small Beta perform on HumanEval?

90.0 on HumanEval in Inception's published Mercury Coder tables.

### What throughput does Mercury Coder Small Beta achieve?

Live throughput metrics appear on this page.

### Is Mercury Coder Small Beta suitable for multi-language coding tasks?

Yes. Its MultiPL-E score is 76.2 across multiple programming languages beyond Python, with Python-centric benchmarks showing its strongest results.

### How does Mercury Coder Small Beta relate to Mercury 2?

Mercury Coder Small Beta is a smaller, coding-focused model from an earlier generation of the Mercury diffusion family. Mercury 2 is a later, broader reasoning model with a larger context window and tunable reasoning depth.

### Where are the benchmark numbers published?

Inception published HumanEval, FIM, MBPP, and MultiPL-E figures for Mercury Coder in its Mercury announcement. See https://platform.inceptionlabs.ai.

### What does Mercury Coder Small Beta cost?

Pricing appears on this page and updates as providers adjust their rates. AI Gateway routes traffic through the configured provider.

## Links

- [Model page](https://vercel.com/ai-gateway/models/mercury-coder-small)
- [AI Gateway documentation](https://vercel.com/docs/ai-gateway)
- [Provider model documentation](https://platform.inceptionlabs.ai/docs#models)
- [Provider pricing](https://platform.inceptionlabs.ai/docs#models)