Amazon Nova After 15 Months: Which Model for Which Job, and How to Check

On this page

Amazon announced the Nova models at re:Invent in December 2024. Fifteen months on, the family has two generations on Amazon Bedrock, prices that span two orders of magnitude, and a naming scheme that no longer maps neatly to capability: Nova 2 Lite, released in December 2025, does work that needed Nova Pro a year earlier, at a different price shape. Teams that picked a Nova model in early 2025 are now asking whether to move, and teams starting now are asking where to begin.

This article sets out what is available as of March 2026, where each model fits, and what changed with Nova 2. It does not rank the models with benchmark scores, because public scores rarely match a given set of prompts. Instead, the sample code runs your own labelled examples through several models and reports accuracy, latency and cost, which is the evidence a model choice should rest on.

What is available

Nova 1 models (Micro, Lite, Pro, Premier) and Nova 2 models (Nova 2 Lite generally available, Nova 2 Pro and Omni in preview, Nova 2 Sonic) with inputs, context windows and prices
Nova 1 is still on sale. Nova 2 Lite is the only generally available Nova 2 text model as of March 2026.

Nova 1 launched in December 2024 with three understanding models: Micro (text only, 128K-token context), Lite and Pro (text, images, video and documents, 300K context). Nova Premier followed on 30 April 2025 with a one-million-token context window, positioned both for complex tasks and as a teacher for Amazon Bedrock Model Distillation, which trains smaller Nova models on its outputs. On-demand prices in us-east-1 range from $0.035 per million input tokens for Micro to $2.50 for Premier.

Nova 2 arrived on 2 December 2025. Nova 2 Lite is generally available: it takes text, images, video and documents, has a one-million-token context, and adds extended thinking that you switch on per request with a reasoningConfig of low, medium or high effort, plus built-in web grounding and a code interpreter. It is served through cross-Region inference profiles such as global.amazon.nova-2-lite-v1:0. Nova 2 Pro is in preview with early access through Nova Forge, Amazon’s service for building custom Nova models; Nova 2 Sonic handles real-time speech; Nova 2 Omni, also in preview, accepts mixed inputs and can generate images as well as text.

⚠️
NOVA 2 LITE IS NOT A CHEAPER NOVA LITE

Nova 2 Lite lists at $0.30 per million input tokens and $2.50 per million output tokens, against $0.06 and $0.24 for Nova Lite: five times the input price and ten times the output price. It is cheaper than Nova Pro on both. With reasoning on, the thinking tokens are billed as output, so a short answer can carry hundreds of billed tokens. Treat it as a replacement for Nova Pro, not for Nova Lite, and turn reasoning on only where an evaluation shows it helps.

Which model for which job

Matrix of Nova Micro, Nova Lite, Nova 2 Lite and Nova Premier: inputs, context window, price, reasoning control and typical jobs
The cheapest model that passes your evaluation is the right one; the tier name is only a starting point.

Nova Micro fits short text tasks with a closed set of answers: intent classification, routing, sentiment, simple extraction. At its price, a routing step in front of a larger model costs little, and it pays off when most traffic can be answered without the larger model. It cannot read images or documents.

Nova Lite is the low-cost choice for high-volume multimodal work where the task is mostly reading rather than reasoning: pulling fields from invoices and forms, describing images, summarising short documents. Check it against your documents; layout-heavy or poor-quality scans may need a larger model or a dedicated service such as Amazon Bedrock Data Automation.

Nova 2 Lite is the default for new agentic and reasoning workloads, long inputs up to a million tokens, and anything that was on Nova Pro. Run it with reasoning off first and add effort only where accuracy improves enough to justify the extra output tokens.

Nova Premier is for the hardest tasks in the Nova family and for producing training data for distillation. Distillation is how its quality can reach production at Micro or Lite prices for a narrow task.

%%{init: {'theme': 'base', 'themeVariables': {'primaryColor': '#FFF3E0', 'primaryTextColor': '#232F3E', 'primaryBorderColor': '#FF9900', 'lineColor': '#232F3E', 'clusterBkg': '#F8FAFC', 'clusterBorder': '#CBD5E1', 'edgeLabelBackground': '#FFFFFF', 'nodeTextColor': '#232F3E'}}}%%
flowchart TD
    A["Request"] --> B["Nova Micro classifies<br/>intent and complexity"]
    B --> C{"Route"}
    C -- "Known intent,<br/>simple answer" --> D["Template or API call,<br/>no larger model"]
    C -- "Document or image" --> E["Nova Lite extraction"]
    C -- "Multi-step or long input" --> F["Nova 2 Lite,<br/>reasoning off or low"]
    E --> G{"Confidence or<br/>validation passed?"}
    G -- "No" --> F
    G -- "Yes" --> H["Return result"]
    F --> H
    D --> H
    classDef aws fill:#FFF3E0,stroke:#FF9900,stroke-width:2px,color:#232F3E
    classDef ok fill:#F0FFF4,stroke:#1D8102,stroke-width:2px,color:#145202
    class A,B,C,E,F,G aws
    class D,H ok

A routed design like this keeps most traffic on the cheapest model that can handle it and escalates only when a check fails. It is worth building only if an evaluation shows the cheap path is accurate enough for the share of traffic it takes; otherwise the routing step adds latency and a failure point for nothing.

Evaluate on your own examples

The sample sends the same labelled examples to each model through the Converse API, with the same system prompt and temperature 0, and reports accuracy, p50 and p95 latency from the response metrics, token usage and cost per thousand cases. Reasoning blocks are skipped when scoring but their tokens are counted, because Bedrock bills them. Throttling is retried with backoff; other errors are counted separately from wrong answers.

Python164 lines
"""Compare Bedrock models on YOUR labelled examples: accuracy, latency and cost.

Each line of the JSONL test set is {"input": "...", "expected": "LABEL"}.
Every model gets the same system prompt and inference settings through the
Converse API, so the comparison is like for like. Prices are per million
tokens and must be filled in from the Amazon Bedrock pricing page for the
Region and inference profile you use.

Usage:
    python evaluate.py --cases cases.jsonl --system "Classify ... Reply with one word." \
        --model us.amazon.nova-micro-v1:0 --model global.amazon.nova-2-lite-v1:0
"""
from __future__ import annotations

import argparse
import json
import statistics
import time
from dataclasses import dataclass, field

import boto3
from botocore.config import Config
from botocore.exceptions import ClientError

# USD per 1M tokens (input, output). Check the Bedrock pricing page before use;
# these are us-east-1 on-demand list prices as of March 2026.
PRICES = {
    "us.amazon.nova-micro-v1:0": (0.035, 0.14),
    "us.amazon.nova-lite-v1:0": (0.06, 0.24),
    "us.amazon.nova-pro-v1:0": (0.80, 3.20),
    "us.amazon.nova-premier-v1:0": (2.50, 12.50),
    "global.amazon.nova-2-lite-v1:0": (0.30, 2.50),
}

RETRYABLE = {"ThrottlingException", "ServiceUnavailableException", "ModelNotReadyException"}


@dataclass
class ModelReport:
    model_id: str
    cases: int = 0
    correct: int = 0
    errors: int = 0
    latencies_ms: list[int] = field(default_factory=list)
    input_tokens: int = 0
    output_tokens: int = 0
    mistakes: list[dict] = field(default_factory=list)

    @property
    def accuracy(self) -> float:
        answered = self.cases - self.errors
        return self.correct / answered if answered else 0.0

    @property
    def p50_ms(self) -> float:
        return statistics.median(self.latencies_ms) if self.latencies_ms else 0.0

    @property
    def p95_ms(self) -> float:
        if not self.latencies_ms:
            return 0.0
        ordered = sorted(self.latencies_ms)
        return ordered[min(len(ordered) - 1, int(round(0.95 * (len(ordered) - 1))))]

    def cost_usd(self, prices: dict = PRICES) -> float | None:
        if self.model_id not in prices:
            return None
        pin, pout = prices[self.model_id]
        return (self.input_tokens * pin + self.output_tokens * pout) / 1_000_000


def answer_text(response: dict) -> str:
    """Join the text blocks of a Converse response, skipping reasoning blocks."""
    blocks = response["output"]["message"]["content"]
    return "".join(b["text"] for b in blocks if "text" in b).strip()


def normalise(label: str) -> str:
    return label.strip().strip(".").upper()


def converse(client, model_id: str, system: str, text: str, max_tokens: int,
             reasoning: str | None, attempts: int = 4) -> dict:
    kwargs = {
        "modelId": model_id,
        "system": [{"text": system}],
        "messages": [{"role": "user", "content": [{"text": text}]}],
        "inferenceConfig": {"maxTokens": max_tokens, "temperature": 0.0},
    }
    if reasoning:
        # Nova 2 only. Reasoning tokens are billed as output tokens, so leave
        # room for them; temperature is omitted (see the Nova 2 user guide
        # for the inference parameters allowed with each effort level).
        kwargs["additionalModelRequestFields"] = {
            "reasoningConfig": {"type": "enabled", "maxReasoningEffort": reasoning}
        }
        kwargs["inferenceConfig"] = {"maxTokens": max(max_tokens, 4000)}
    delay = 1.0
    for attempt in range(1, attempts + 1):
        try:
            return client.converse(**kwargs)
        except ClientError as exc:
            code = exc.response["Error"]["Code"]
            if code not in RETRYABLE or attempt == attempts:
                raise
            time.sleep(delay)
            delay *= 2


def evaluate(client, model_id: str, cases: list[dict], system: str,
             max_tokens: int = 10, reasoning: str | None = None) -> ModelReport:
    report = ModelReport(model_id)
    for case in cases:
        report.cases += 1
        try:
            resp = converse(client, model_id, system, case["input"], max_tokens, reasoning)
        except ClientError as exc:
            report.errors += 1
            report.mistakes.append({"input": case["input"], "error": exc.response["Error"]["Code"]})
            continue
        got = normalise(answer_text(resp))
        report.latencies_ms.append(resp["metrics"]["latencyMs"])
        report.input_tokens += resp["usage"]["inputTokens"]
        report.output_tokens += resp["usage"]["outputTokens"]
        if got == normalise(case["expected"]):
            report.correct += 1
        else:
            report.mistakes.append({"input": case["input"], "expected": case["expected"], "got": got})
    return report


def load_cases(path: str) -> list[dict]:
    with open(path, encoding="utf-8") as fh:
        cases = [json.loads(line) for line in fh if line.strip()]
    for i, c in enumerate(cases, 1):
        if not {"input", "expected"} <= c.keys():
            raise ValueError(f"line {i}: needs 'input' and 'expected'")
    return cases


def main() -> None:
    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
    ap.add_argument("--cases", required=True)
    ap.add_argument("--system", required=True)
    ap.add_argument("--model", action="append", required=True)
    ap.add_argument("--reasoning", choices=["low", "medium", "high"], help="Nova 2 models only")
    ap.add_argument("--region", default="us-east-1")
    args = ap.parse_args()

    client = boto3.client("bedrock-runtime", region_name=args.region,
                          config=Config(retries={"mode": "standard", "max_attempts": 3},
                                        read_timeout=120))
    cases = load_cases(args.cases)
    for model_id in args.model:
        r = evaluate(client, model_id, cases, args.system,
                     reasoning=args.reasoning if "nova-2" in model_id else None)
        cost = r.cost_usd()
        per_1k = f"${cost / r.cases * 1000:.4f}" if cost is not None and r.cases else "price unknown"
        print(f"{model_id:<34} accuracy={r.accuracy:.1%} errors={r.errors} "
              f"p50={r.p50_ms:.0f}ms p95={r.p95_ms:.0f}ms cost per 1k cases={per_1k}")


if __name__ == "__main__":
    main()

A few hundred real examples, labelled by the people who own the process, are enough to separate the models for most classification and extraction tasks. Keep the wrong answers the report lists, because the pattern in them (a missing category, an ambiguous field) often matters more than the accuracy figure.

💡
MOVING FROM NOVA 1 TO NOVA 2

Change the model ID to a Nova 2 inference profile, run the same evaluation with reasoning off, then at low effort, and compare accuracy and cost per case with your current model. Check that your IAM policies allow the new inference profile and the Regions it routes to, and that output parsing ignores reasoningContent blocks.

⚖️
WHERE THE REQUEST IS PROCESSED

Global cross-Region inference profiles can process a request in any supported commercial Region. If your data must stay in a geography, use a geographic profile (such as US or EU) where the model offers one, restrict the allowed Regions in IAM, and record the choice. Turn on model invocation logging if you need an audit trail of prompts and responses, and treat that log as sensitive data.

📝
HOW THIS WAS CHECKED

evaluate.py was tested with Python 3.13, boto3==1.42.55 and pytest==9.0.2: five tests cover scoring, latency percentiles, token and cost totals, reasoning blocks, retries on throttling and error counting, with every Converse request validated by botocore’s Stubber against the Bedrock Runtime API model. No model was called and no accuracy figures are claimed. Prices are us-east-1 on-demand list prices from the Bedrock pricing page.

Key takeaways

  • Nova 1 (Micro, Lite, Pro, Premier) and Nova 2 (Lite GA; Pro and Omni in preview; Sonic) are both on Bedrock as of March 2026.
  • Nova 2 Lite replaces Nova Pro for most work, with a 1M-token window and optional reasoning; it costs several times more than Nova Lite.
  • Use Micro and Lite where they pass your evaluation: they remain the cheapest options for routing and high-volume extraction.
  • Reasoning tokens are billed as output. Turn reasoning on only where it measurably helps.
  • Choose models with your own labelled examples, and check where cross-Region profiles may process your data.

Which Nova model ended up in your production path, and what did your own evaluation show? Share it in the comments.

Glossary

Amazon Nova
Amazon’s own family of foundation models, offered through Amazon Bedrock.
Converse API
The Bedrock Runtime API that sends messages to any supported model with one request shape.
Extended thinking
Nova 2 reasoning before answering, controlled by reasoningConfig effort levels.
Inference profile
A Bedrock model ID that routes requests across a set of Regions, such as global or US.
Model distillation
Training a smaller model on a larger model’s outputs for a specific task.
Nova Forge
Amazon’s service for building custom Nova models from early checkpoints.
p95 latency
The time within which 95 per cent of requests complete.

References & Further Reading


Discover more from C4: Container, Code, Cloud & Context

Subscribe to get the latest posts sent to your email.

Written by

Nithin Mohan TK

Hello Namaste! 👋🏻 I'm an accomplished Enterprise Solution Architect & Engineering Leader with 20+ years of progressive experience architecting, building, and scaling transformative enterprise solutions. ⚜️ Solution Architect / AI & Cloud 📌 Galway, Ireland

Leave a comment

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.