Skip to content
Inception

Mercury Coder Small Beta

Mercury Coder Small Beta is Inception's compact diffusion coding model. Mercury Coder Small Beta scores 90.0 on HumanEval and 84.8 on fill-in-the-middle (FIM).

View API reference
Input and output price
Input $0.25, Output $1, Per 1M tokens
24h uptime
Loading AI Gateway uptime
Get API keyRead the docs
import { streamText } from 'ai'


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

Copy link to headingPlayground

Try out Mercury Coder Small Beta by Inception. Usage is billed to your team at API rates. Free users (those who haven't made a payment) get $5 of credits every 30 days.

inception logo
inception logo

Mercury Coder Small Beta

Copy link to headingProviders

Route requests across multiple providers. Copy a provider slug to set your preference. Visit the docs for more info. Using a provider means you agree to their terms, listed under Legal.

Provider
Context
Max Output
Latency
Throughput
Input
Output
Cache
Web Search
Capabilities
ZDR
No Training
Free Tier
Release Date
Inception
Legal:Terms•Privacy
32K16K0.4 s
$0.25/M
$1/M
—
02/26/2025

Copy link to headingUptime

Direct request success rate on AI Gateway and per-provider. Visit the docs for more info.

Copy link to headingThroughput

P50 throughput on live AI Gateway traffic, in tokens per second (TPS). Visit the docs for more info.

Copy link to headingLatency

P50 time to first token (TTFT) on live AI Gateway traffic, in milliseconds. View the docs for more info.

Getting started

Call Mercury Coder Small Beta through AI Gateway with the AI SDK generateText and streamText functions, or through the OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages APIs by changing the base URL. AI Gateway authenticates the request and routes it to an available provider.

Install the AI SDK (pnpm add ai dotenv), create an API key from the API Keys page, and set it as AI_GATEWAY_API_KEY in your environment. Full setup is covered in the text generation quickstart.

index.ts
import { generateText } from 'ai';
import 'dotenv/config';


async function main() {
  const result = await generateText({
    model: 'inception/mercury-coder-small',
    prompt: 'Why is the sky blue?',
  });


  console.log(result.text);
}


main().catch(console.error);

Top-level parameters

The same Mercury Coder Small Beta request in each API format AI Gateway supports.

top-level-params.ts
import { generateText } from 'ai';
import 'dotenv/config';


async function main() {
  const result = await generateText({
    model: 'inception/mercury-coder-small',
    system: 'You are a concise technical assistant.',
    prompt: 'Summarize the tradeoffs between static generation and SSR.',
    maxOutputTokens: 1024,
    temperature: 0.5,
  });


  console.log(result.text);
}


main().catch(console.error);

Standard parameters like prompt, messages, temperature, and tools work as documented in the AI SDK docs. These are the parameters with model-specific behavior.

ParameterTypeRequiredDescription
modelstringYesModel ID in the form creator/model, e.g. inception/mercury-coder-small. AI Gateway routes the request to an available provider.
maxOutputTokensnumberNoHard cap on generated tokens. Mercury Coder Small Beta supports up to 16,384 output tokens.
providerOptionsRecord<string, JSONValue>NoAI Gateway routing options under gateway, plus any provider-native options under the provider’s own namespace — see the table below.

Input limits

InputFormatsSourcesMax countMax sizeLimits
Text————Prompt and response share the 32K-token context window

Provider options

Set AI Gateway routing options under providerOptions.gateway. For provider-specific options, pass them under the provider’s namespace as documented by the AI SDK.

Learn more in the AI SDK provider docs.

provider-options.ts
import { generateText } from 'ai';
import 'dotenv/config';


async function main() {
  const result = await generateText({
    model: 'inception/mercury-coder-small',
    prompt: 'Why is the sky blue?',
    providerOptions: {
      gateway: {
        only: ['inception'],
      },
    },
  });


  console.log(result.text);
}


main().catch(console.error);

These AI Gateway routing options apply to every model. Provider-specific options pass through under the provider’s own namespace (for example providerOptions.anthropic) exactly as documented by the AI SDK.

ParameterTypeRequiredDescription
providerOptions.gateway.onlystring[]NoRestrict routing to these provider slugs. Requests fail over only within the listed providers.
providerOptions.gateway.orderstring[]NoPreferred provider order. Listed providers are tried first; unlisted providers remain available as fallbacks.
providerOptions.gateway.sort'cost' | 'ttft' | 'tps'NoRank candidate providers by price, time to first token, or tokens per second instead of the default routing order.
providerOptions.gateway.zeroDataRetentionbooleanNoRoute only to providers with a zero-data-retention policy for this model.

Routing across providers

AI Gateway serves the same model through multiple providers and fails over automatically. order expresses a preference while keeping every provider eligible; only is a hard allowlist — if none of the listed providers are available the request fails instead of falling back.

Options under a provider's own namespace (for example providerOptions.anthropic) are forwarded to that provider with the request. Providers ignore option namespaces that don't apply to them, so it is safe to set provider options alongside gateway routing options.

Tool calling

Expose tools the model can call. Define each tool’s inputs with a Zod schema.

tool-calling.ts
import { generateText, tool } from 'ai';
import { z } from 'zod';
import 'dotenv/config';


async function main() {
  const result = await generateText({
    model: 'inception/mercury-coder-small',
    prompt: 'What is the weather in San Francisco?',
    tools: {
      getWeather: tool({
        description: 'Get the current weather for a location',
        inputSchema: z.object({ location: z.string() }),
        execute: async ({ location }) => ({ location, temperatureC: 18 }),
      }),
    },
  });


  console.log(result.text);
}


main().catch(console.error);

Copy link to headingMore models by Inception

Model
Context
Latency
Throughput
Input
Output
Cache
Web Search
Capabilities
Providers
ZDR
No Training
Free Tier
Release Date
inception/mercury-2.5
260K1.4 s
$0.04/M
$0.15/M
Read$0.004/M
—
inception logo
09/08/2026
inception/mercury-2
128K0.4 s
$0.25/M
$0.75/M
Read$0.03/M
—
inception logo
02/24/2026

Copy link to headingAbout Mercury Coder Small Beta

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.

Copy link to headingWhat To Consider When Choosing a Provider

  • Configuration: 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.
  • Zero Data Retention: Zero Data Retention is offered on a per-provider and model basis. See the documentation for details.
  • Authentication: AI Gateway authenticates requests using an API key or OIDC token. You do not need to manage provider credentials directly.

Copy link to headingWhen to Use Mercury Coder Small Beta

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 when

  • 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

Copy link to headingConclusion

Mercury Coder Small Beta brings diffusion-based code generation to contexts where speed and throughput matter most. Its FIM score is 84.8 and HumanEval is 90.0 in Inception's published benchmarks, so it fits teams balancing quality against cost and latency in IDE experiences and high-frequency agent loops.

Copy link to headingFrequently 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.

Your use is subject to Inception's Terms & Privacy Policies.