Amazon Bedrock Explained: Claude, Nova, Llama and GPT-6 on One AWS API

Human Verified

Share to: , and

A wide, calm illustration of a large cloud marketplace hall where many different AI model stalls sit under one roof, one platform, many models. No text, no logos.

Amazon Bedrock Explained: Claude, Nova, Llama and GPT-6 on One AWS API

Amazon Bedrock is Amazon’s way of selling you every major AI model through a single AWS bill. Instead of signing up separately with Anthropic for Claude, Meta for Llama, Moonshot for Kimi and OpenAI for GPT-6 — four accounts, four API keys, four pricing pages, four sets of terms — you call them all through one AWS service, with one authentication method, one set of logs, and one invoice. You pay per token, you run no servers, and you can swap the model behind your app by changing a single identifier in your code. That is the whole idea, and it is a good one. Checked 19 November 2026 against AWS’s own Bedrock pricing page, FAQ and documentation, which the researcher read in full, and against Anthropic’s published Claude prices as reported by six consistent secondary reads.

Bedrock is not a model. It has no brain of its own. It is a managed platform — a marketplace hall, a switchboard, a billing layer — that sits between your application and the foundation models built by other companies and by Amazon itself. The models do the thinking. Bedrock does everything around the thinking: access control, logging, cost tracking, safety filters, connecting the model to your company’s documents, and running agents that can call your business systems. If you understand that split, the rest of this guide falls into place.

Two corrections belong at the top, because most explainers written even a few months ago get them wrong. First, the idea file for this guide promised “Claude, Llama, Titan and Other Models” — but Titan, Amazon’s first text model, is gone. As of November 2026, Titan’s text-generation models no longer appear in the Bedrock catalogue; only Titan embeddings remain. Amazon’s own text line is now Nova, and the current generation is Nova 2. Second, this is no longer a simple model menu. In 2026 Bedrock became an agent platform: AgentCore for running agents, managed knowledge bases for company data, guardrails for safety, and OpenAI’s frontier models sitting alongside Claude on the same endpoint. This guide covers the whole platform as it stands on 19 November 2026, with prices date-stamped, because the catalogue changes every few weeks and the pricing page is always the authority.

A wide, calm illustration of a large cloud marketplace hall where many different AI model stalls sit under one roof, one platform, many models. No text, no logos.

What Amazon Bedrock Actually Is — One API, Many Models

<img src="

A single control panel with many different model doors opening from it, one API, many models. Abstract shapes only, no words.

” alt=”A single control panel with many different model doors opening from it, one API, many models. Abstract shapes only, no words.”>

Amazon Bedrock is a fully managed service that offers a choice of industry-leading foundation models along with the capabilities needed to build generative AI applications, in AWS’s own words from its Bedrock FAQ. “Fully managed” and “serverless” are the two words that matter. There are no servers to provision, no GPUs to rent, no models to download and host. You send a request, you get a response, and you pay for what you use. When traffic spikes, AWS scales the service; when traffic stops, the bill stops too.

The practical shape of that is simple. Your application talks to one endpoint, bedrock-runtime, using AWS’s standard signing method, SigV4, with the same IAM credentials your team already uses for the rest of AWS. The request names a model — say, global.anthropic.claude-sonnet-5-5 — and carries your prompt. The response comes back in a standard shape no matter which provider built the model. Change the model identifier and the rest of your code stays the same. That is the point of the Converse API, covered in full in section 3: one interface, many models, minimal rewiring when you change your mind.

What you get around the model is as important as the model itself. Bedrock includes a playground in the AWS console for trying models without writing code; Knowledge Bases for connecting a model to your documents; Guardrails for blocking harmful content and checking answers against your sources; fine-tuning and continued pre-training for adapting models to your data; model evaluation tools for comparing models on your own tasks; and AgentCore for running agents in production. None of these is a model. All of them are the reason a team picks Bedrock over calling a provider’s API directly — the subject of the final section.

Bedrock is also, deliberately, a boring enterprise purchase. It is in scope for SOC and ISO standards, is HIPAA-eligible, can be used in compliance with GDPR, is FedRAMP High in scope, and is CSA STAR Level 2 certified, according to AWS. Your content is not used to improve the base models and is not shared with any model provider, AWS states in its FAQ. Data is encrypted in transit and at rest, you can bring your own encryption keys, and AWS PrivateLink lets you connect to Bedrock from inside your own virtual private cloud without traffic crossing the public internet. For a bank, a hospital or a government department, those sentences matter more than any benchmark score.

Our short introduction to the service, “What Is Amazon Bedrock? AWS’s Model Marketplace In Plain English”, covered the basic idea in 744 words. This guide is the durable reference: the full catalogue as of November 2026, the pricing with worked examples, a first working app, and an honest verdict on when Bedrock is the right choice and when it is not.

A Short History: From 2023 Preview to the 2026 Agent Platform

A timeline road running from a small launch gate in 2023 to a large platform city skyline in 2026. No text on signs.

Amazon announced Bedrock on 13 April 2023, as part of a set of new tools for building with generative AI on AWS. At the time the pitch was narrow: a managed way to call foundation models from AI21 Labs, Anthropic, Cohere, Stability AI and Amazon itself through a single API. The service became generally available on 28 September 2023, with Meta’s Llama 2 joining as the first open model of note. Agents and Knowledge Bases were still in preview at that point; the platform was a gateway, not yet a workshop.

Through 2024 and 2025 the gateway grew into a platform. Guardrails became generally available in April 2024. Prompt caching arrived in April 2025. Amazon launched its own Nova model family at re:Invent in December 2024, giving Bedrock a first-party text line to sit beside Claude and Llama. Agents for Bedrock — managed agents that break a task into steps, call company systems through APIs, and carry out multi-step work — moved from preview toward production use. By the end of 2025 the question Bedrock answered had changed: it was no longer “which model should I use?” but “how do I get agents into production safely?”

2026 is the year that second question took over. Managed Knowledge Bases became generally available in July 2026. AgentCore, the end-to-end platform for deploying agents built with any framework and any model, became the centrepiece of the Bedrock story, and in April 2026 it added a managed harness in preview — you define an agent by specifying just a model, a system prompt and tools, with no orchestration code. OpenAI’s models arrived on Bedrock, including the GPT-6 family, and Managed Agents powered by OpenAI entered public preview. Amazon’s own Nova line moved to its second generation at re:Invent on 2 December 2025. And the scale changed: AWS says more than 100,000 organisations now use Bedrock, and in its Q3 2026 earnings Amazon said Bedrock had become the fastest-growing multibillion-dollar service in AWS history, with Fortune 500 spending on Bedrock nearly seven times the year before and total token volume up almost seventeen times. Those are Amazon’s figures, reported here as Amazon’s figures — but they explain why Bedrock, once a quiet corner of AWS, is now one of its most important services.

The Amazon AI picture is wider than Bedrock, of course. Alexa+ runs on it, Nova is built for it, and the whole stack fits together in a way our short overview “Amazon’s AI Stack Explained: Alexa+, Bedrock And Nova” sketches in 857 words. This guide stays on Bedrock itself — the platform, not the whole Amazon AI empire.

How Bedrock Works: The Converse API and Inference Profiles

Hands typing on a laptop beside a soft cloud shape, one interface reaching many models behind it. No readable code on the screen.

The core of Bedrock is an API call, and the modern form of that call is the Converse API. You create a Bedrock Runtime client — in Python, that is boto3.client("bedrock-runtime", region_name="us-east-1") — and you call client.converse() with three things: a model identifier, a system prompt, and a list of messages. The response comes back with the model’s reply and a usage block telling you how many tokens the call consumed, which is what your bill is built from. The same call works for Claude, Llama, Nova, Kimi and GPT-6; only the model identifier changes.

That uniformity is the whole engineering argument for Bedrock. Without it, every provider’s API is a slightly different dialect: different request shapes, different streaming formats, different error handling, different authentication. With the Converse API, switching from Sonnet to Nova 2 Lite or from Llama to Kimi is a one-line change in most applications. It also means your guardrails, logging and cost tracking work identically for every model, because they sit on the Bedrock side of the call, not the provider side. You can test five models against the same prompt and the same test set in an afternoon, and pick the winner on your data rather than on a vendor’s benchmark chart.

There are two wrinkles a beginner should know before the first call. The first is inference profiles. Newer models, including the current Claude models, cannot be called by their bare model ID. They must be invoked through an inference profile — an identifier with a prefix such as global. or us. that tells AWS how to route the request. The example AWS itself publishes uses global.anthropic.claude-sonnet-5-5 as the model ID for Claude Sonnet 5.5. A global profile routes across regions for higher throughput; a regional profile keeps the request inside one region, which matters if you have data-residency requirements. You can list the available profiles with aws bedrock list-inference-profiles, and the console shows them too. If a call fails with an access error, the first thing to check is whether you used the profile form of the ID.

The second wrinkle is model access. Access to serverless models is enabled automatically for most models, but Anthropic models require a one-time use-case form the first time you request access, and some models are gated entirely — AWS notes, for example, that access to the Claude Mythos models requires approval from your Anthropic account team. Model availability also varies by region: not every model runs in every AWS region, and some models are only available through cross-region inference profiles. Before you design around a model, check that it is available in the region you plan to use. The catalogue page in the AWS documentation, “models at a glance”, is the place to check.

The other way in is the console playground, which needs no code at all: pick a model, type a prompt, compare responses side by side. It is the right first step for a product manager or a founder who wants to feel the difference between models before an engineer writes anything. And for the command line, aws bedrock list-foundation-models shows what your account can call — a useful habit, because the catalogue changes and the API will always tell you the truth about your own account and region.

The Model Catalogue in November 2026: Who Is on Bedrock

A vast library catalogue hall with tall shelves marked only by coloured symbols, many providers under one roof. No legible labels.

As of 19 November 2026, Bedrock lists models from AI21 Labs, Amazon, Anthropic, Cohere, DeepSeek, Google, Luma AI, Meta, MiniMax, Mistral AI, Moonshot AI, NVIDIA, OpenAI, Qwen, Stability AI, TwelveLabs, Writer, xAI and Z AI, with poolside listed as coming soon — that provider list is from AWS’s own FAQ and pricing page, read first-hand for this guide. AWS describes the total as “hundreds” of foundation models. No precise count is given here, because the catalogue moves every few weeks and any exact number would be out of date by the time you read it; the pricing page and the “models at a glance” catalogue page are the authority.

The catalogue covers every modality, not just text. There are text and chat models, image generation models (including Amazon Nova Canvas and Stability AI’s models), video generation, speech-to-speech models (Nova Sonic and Nova 2 Sonic), embedding models for search and retrieval (including Titan Text Embeddings V2 and Nova Multimodal Embeddings), rerankers (Cohere Rerank 3.5, billed per 1,000 queries at $2.00), and video-understanding models from TwelveLabs. A single Bedrock application can therefore mix modalities — generate text with Claude, embed documents with Titan, generate a product image with Nova Canvas, and transcribe a call with Nova Sonic — all on one bill and one set of credentials.

Two absences are worth stating plainly, because readers assume otherwise. First, Gemini is not on Bedrock. Google’s open Gemma models are listed (Gemma 3 and Gemma 4, from $0.04 per million input tokens for the smallest), but Google’s flagship Gemini models are not available through AWS — they live on Google’s own platform. Our explainer of the Gemini family, “Gemini Models Explained”, covers what Gemini itself offers. Second, Claude Mythos models are gated: AWS states plainly that access requires approval, so do not plan a product around them without that approval in hand.

The catalogue also has a lifecycle. Models enter, models retire, and old versions quietly become legacy. Titan’s text models are the most important retirement of 2026 — see section 6. Claude’s older generations remain available for existing users but are not where new work should start. The practical rule is to build on the current generation of whichever family you choose, to pin the exact model identifier in your code rather than an alias that can move under you, and to re-check the catalogue every quarter. Bedrock rewards that habit: because switching models is a one-line change, a retirement is an afternoon’s work, not a rewrite.

Claude on Bedrock: Fable, Opus, Sonnet and Haiku, Priced

Three tiers of abstract figures side by side, a small fast one, a mid-sized worker, and a large thoughtful one, model tiers. No text.

Claude is the reason many teams come to Bedrock in the first place, and it is the family where the catalogue has moved fastest in 2026. The current line, as of 19 November 2026, is the 5.5 generation, all with a one-million-token context window: Claude Fable 5.2 at the top, then Opus 5.5, Sonnet 5.5 and Haiku 5.5. The older 5.0 generation — Fable 5, Opus 5, Sonnet 5 — remains available, and the 4.x line (Opus 4.8, Sonnet 4.6, Haiku 4.5) is still listed for existing users. New work should start on the 5.5 line.

The prices below are Anthropic’s published rates, which Bedrock matches dollar-for-dollar — AWS does not mark up Claude tokens. They are confirmed by six consistent secondary reads of Anthropic’s pricing page in November 2026, because the Anthropic table on AWS’s own pricing page is JavaScript-rendered and did not appear in the text fetch; the pricing page remains the authority if these figures have moved.

ModelInput / 1M tokensOutput / 1M tokensReleased
Claude Fable 5.2$8.00$40.002026
Claude Fable 5.1$10.00$50.002026
Claude Opus 5.5$4.00$20.0022 Sep 2026
Claude Opus 5$5.00$25.002026
Claude Sonnet 5.5$2.00$10.0028 Sep 2026
Claude Sonnet 5$2.00$10.002026
Claude Haiku 5.5$0.10*$0.50*7 Oct 2026
Claude Haiku 4.5$1.00$5.002025

* Haiku 5.5 is priced by prompt length: $0.10 in / $0.50 out for prompts up to 100,000 tokens, and $0.50 in / $2.50 out when the prompt passes 100,000 tokens. A request that crosses the line re-prices the whole request, so watch long prompts. Batch inference costs half the standard rate on Claude models, and cache reads are a fraction of input price — for Sonnet 5.5, $0.10 per million tokens, after AWS cut the Sonnet 5.5 cache-read price by 50% starting 7 October 2026.

The tiers map to jobs, not to quality in the abstract. Fable is Anthropic’s most capable and most expensive model — the one for the hardest reasoning, long-horizon research and agentic work where the answer is worth $8 per million input tokens. Opus 5.5 is the flagship for long-running agents and difficult coding, at $4/$20 — notably cheaper than the Opus 5 it replaced. Sonnet 5.5 is the everyday workhorse: the default for chatbots, coding assistants, document work and most production apps, at $2/$10. Its $2/$10 rate began as an introductory price and became permanent on 1 September 2026, when a planned rise to $3/$15 was cancelled. Haiku 5.5 is the fast, cheap tier for classification, summarisation, extraction and high-volume simple tasks — at $0.10/$0.50 it costs one-twentieth of Sonnet per input token, which changes what is economical to automate.

Two details matter in practice. First, Claude on Bedrock must be called through inference profiles, as section 3 explains — global.anthropic.claude-sonnet-5-5 is the form AWS publishes. Second, Claude’s context window is now one million tokens across the current line, with up to 128,000 tokens of maximum output. The old comparison in which Claude trailed on window size is out of date. For the Claude family in depth — the tiers, the safety approach, the company behind it — our explainer “Claude Models Explained” covers the whole family.

Amazon’s Own Models: Nova 2 and the End of Titan Text

A sunrise over a new generation of model shapes, older faded shapes behind, a new era. No logos, no text.

Amazon’s first-party models are the Nova family, and they are the cheapest way to do most things on Bedrock. Nova launched at re:Invent on 3 December 2024 with Micro, Lite and Pro for text and multimodal understanding, plus Canvas for images and Reel for video, and Sonic for speech. Premier, the largest Nova 1 model, followed on 30 April 2025. Then, at re:Invent on 2 December 2025, Amazon announced the second generation: Nova 2 Lite generally available, Nova 2 Pro and Nova 2 Omni in gated preview, and Nova 2 Sonic for real-time speech.

ModelContextInput / 1MOutput / 1MStatus
Nova Micro128K$0.035$0.14GA
Nova Lite300K$0.06$0.24GA
Nova Pro300K$0.80$3.20GA
Nova 2 Lite1M$0.30$2.50GA
Nova 2 Pro1M$1.25$10.00Gated preview
Nova 2 Omni1M$0.30$2.50Gated preview

Nova 2 Lite is the model to understand. It is the default Amazon model to reach for in 2026: a one-million-token context window, adjustable extended thinking, built-in web grounding and a code interpreter, at $0.30 per million input tokens on the global cross-region profile — the geo/in-region rate is slightly higher at $0.33/$2.75, so the global profile is the cheaper route where data residency allows. It is roughly seven times cheaper per input token than Sonnet 5.5, and for many jobs — summarisation, classification, extraction, drafting — it is good enough that the saving is pure profit. Nova 2 Pro, in gated preview, is Amazon’s frontier reasoning model for long-horizon planning and hard agentic work, at about four times the input cost of 2 Lite; justify it only where 2 Lite measurably fails. Nova 1 Premier, the largest of the first generation, is deprecated — do not build on it, and do not quote a price for it, because published prices conflict and the model is being wound down along with the original Nova Omni, Reel and Canvas. One small caveat on the table above: published Nova Micro input rates differ slightly by source — $0.035 in most trackers against $0.04 in one catalogue snapshot — because regional routing changes the rate; the pricing page is the authority for your region.

And then there is Titan, the correction this guide exists partly to make. Titan was Amazon’s first foundation-model line on Bedrock: Titan Text Express, Titan Text Lite and Titan Text Premier for text, plus Titan Image Generator and Titan Embeddings. As of September–November 2026, the Titan text models no longer appear in the Bedrock model catalogue at all. The Titan section of AWS’s own pricing page now covers embeddings only — Titan Text Embeddings V2 and Titan Multimodal Embeddings. If a tutorial, a course or an older guide tells you to call Titan Text on Bedrock, it is out of date. The replacement is Nova, and any Titan Text code needs migrating, not just a model-ID swap, because the two families have different capabilities and different pricing.

There is one more Nova fact worth knowing before you plan. In 2026 Amazon began winding down several Nova 1 models into maintenance-only mode and redirecting engineers to a new Frontier Model Research division, aiming at a frontier model to rival the top labs. The Nova line is in transition: Nova 2 is the present, and something bigger may arrive around re:Invent 2026, which runs 30 November to 4 December. That is a reason to build on Nova 2 Lite, which is current and cheap, and a reason not to over-invest in Nova 1-only features.

Llama, Kimi, GPT-6 and the Rest: The Open and Rival Models

A meeting table of distinct abstract model characters from different families, open and closed side by side. No logos, no text.

Beyond Claude and Nova, the catalogue is where Bedrock’s “one API, many models” promise is most visible — and most useful. The families below are the ones that matter for a first build. Prices are given only where they were verified from AWS’s own pricing page or from two consistent sources; where a price could not be verified, this guide names the model and says so, rather than guessing.

Meta Llama. Llama is the open-weight workhorse of the catalogue: Llama 4 Maverick and Llama 4 Scout, Llama 3.3 70B Instruct, Llama 3.1 in 405B, 70B and 8B sizes, and Llama 3.2 in 1B and 3B sizes are all listed. Llama on Bedrock is for teams that want an open model with a managed API — no self-hosting, but the same weights the open-source community uses, fine-tunable on Bedrock, and cheap enough to run at volume. Llama on-demand prices were not verified from two consistent sources for this guide, so no Llama prices are quoted here; check the pricing page before budgeting. The retrieval and embedding ideas behind Llama are covered in the Knowledge Bases section below.

Moonshot Kimi. Kimi arrived on Bedrock on 6 November 2026, when Amazon added Kimi K3.1 Pro (Highspeed) with cross-region inference in all Bedrock regions — a story our news post “Moonshot’s Kimi K3.1 Pro Lands on Amazon Bedrock” covered on the day. The price, read first-hand from AWS’s pricing page, is $4.00 per million input tokens and $20.00 out on the Global CRIS profile, with cache reads at $0.20. Kimi K3 is $3.00/$15.00 on the same profile, and the older K2 Thinking and K2.5 are $0.60/$2.50 and $0.60/$3.00 in US regions. Kimi’s selling point on Bedrock is its one-million-token context window at a price below Claude’s top tiers — the long-document specialist, now rentable by the token. Our full guide, “Kimi Explained”, covers the whole Kimi family, including the K2 retirement that makes K3.1 Pro the model to use.

OpenAI GPT-6. The most surprising arrival of 2026 is OpenAI’s frontier models on Bedrock: the GPT-6 family — Astra, Sol and Luna — plus GPT-6.1 Terra, generally available on Bedrock since 26 October 2026, and the open gpt-oss-20b and gpt-oss-120b models. GPT-6.1 Terra is reported at $1.00 per million input tokens and $5.00 out — a single-source figure from a pricing roundup checked 27 October 2026, stated here as reported, not AWS-confirmed. OpenAI models on Bedrock run on the same bedrock-runtime endpoint, so their usage shows up in the same invocation logs, CloudWatch metrics and cost reports as every other model — which is the point: an AWS team can adopt OpenAI’s models without leaving AWS governance behind. Managed Agents powered by OpenAI, covered in section 13, go further.

DeepSeek, Mistral, Qwen and the rest. DeepSeek v3.2 is $0.62 per million input tokens and $1.85 out in US regions, read first-hand from AWS’s pricing page — the budget reasoning model, and the cheapest way to get strong reasoning on Bedrock. Mistral Large 3 is $0.50/$1.50 in US regions, also read first-hand, with smaller Ministral and Devstral models below it for code and edge work. Qwen’s family is on Bedrock too — Qwen3 Coder, Qwen3 32B and 235B, and the Qwen 3 Next line — covered in our explainer of the Qwen models, and DeepSeek in our explainer of DeepSeek. MiniMax’s M2.5 is $0.30/$1.20 in US regions. Google’s Gemma open models, NVIDIA’s Nemotron models, Cohere’s Command and Rerank models, AI21’s Jamba models, Writer’s models, TwelveLabs’ video-understanding models and xAI’s Grok 4.6 and 4.7 round out a catalogue that, in practice, means you will rarely need to leave Bedrock to find a model — with the single notable exception of Gemini.

What Bedrock Costs: On-Demand, Batch, Flex and Priority

A pricing meter beside token jars of different sizes, pay per token, tiers as jars. No numbers, no text.

Bedrock has no subscription and no mandatory monthly fee. The default is on-demand pricing: you pay per token processed, input and output billed at different rates, with no upfront commitment and no instance to provision. That is the whole cost model for most users, and it is why a side project can cost pennies while a production app costs thousands — the bill follows usage, not a plan.

On top of on-demand sit four service tiers. Standard is the default. Flex costs 50% less than Standard, for workloads that can tolerate slower or deprioritised handling. Priority costs 75% more than Standard, for latency-sensitive work that must jump the queue. Reserved is an account-level commitment for steady, predictable volume. The tier you pick changes the price of the same model by as much as threefold, so “what does Sonnet cost on Bedrock” has no single answer until you name a tier — the prices in this guide are Standard on-demand unless stated otherwise.

Batch inference is the cheapest way to run non-urgent work: select foundation models cost 50% less than on-demand when you submit jobs in batches rather than one request at a time. It is the right choice for overnight jobs — classifying a backlog, summarising a document store, generating a catalogue — and the wrong choice for anything a user is waiting on. Prompt caching is the other big lever: when you send the same long context repeatedly — a system prompt, a document, a set of examples — Bedrock charges a fraction of the input price to read it back from the cache. For Sonnet 5.5, cache reads are $0.10 per million tokens against $2.00 for fresh input, and AWS cut that rate by half from 7 October 2026. Cache writes cost more than reads (for Sonnet 5.5, $2.50 for a five-minute cache and $4.00 for an hour), so caching pays when the same context is reused several times, not once.

Provisioned Throughput is the third lever, and the most expensive to get wrong: you reserve model units by the hour and pay whether you use them or not. It buys guaranteed capacity and lower latency for a production app that cannot tolerate throttling — and it is billed per model unit per hour, with rates that vary by model and commitment length. For Anthropic models, provisioned throughput goes through your account team rather than the console. If your app is small, you do not need it; if your app is large enough to need it, your AWS account team will tell you.

Finally, the bill has lines beyond tokens. Guardrails charge per text unit, Knowledge Bases charge for storage and retrieval, Data Automation charges for transforming documents, model evaluation charges $0.21 per completed human task, fine-tuning is billed by the hour, and custom-model storage is $1.95 per model per month. None of these is large on its own, but they are the lines that surprise people who budgeted only for tokens. Section 9 works through the full math, including those lines.

Pricing Math: What a Real App Costs per Month

A calculator and a monthly bill on a desk beside a small potted plant, working out costs. No readable figures.

Token prices only make sense as monthly costs, so here are three worked examples, all using Standard on-demand rates as listed on 19 November 2026. The formula is always the same: cost = (input tokens ÷ 1,000,000 × input rate) + (output tokens ÷ 1,000,000 × output rate). Every figure below can be re-derived from the tables in sections 5 to 7.

Example 1: a customer-support chatbot on Sonnet 5.5. Suppose it answers 100,000 questions a month, each answer using 3,000 input tokens (the question plus retrieved help-centre text) and 500 output tokens. Input: 100,000 × 3,000 = 300 million tokens × $2.00 = $600. Output: 100,000 × 500 = 50 million tokens × $10.00 = $500. Model cost: $1,100 a month, or about $0.011 per answer. Add Guardrails content filters: each query is about 200 characters (1 text unit) and each answer about 1,500 characters (2 text units), so 300,000 text units × $0.15 per 1,000 = $45 a month. Total, roughly $1,145 a month before caching — and with prompt caching on the repeated help-centre context, the input line falls further.

Example 2: the same chatbot on Haiku 5.5. Same volumes, prompts under 100,000 tokens. Input: 300 million × $0.10 = $30. Output: 50 million × $0.50 = $25. Model cost: $55 a month — one-twentieth of Sonnet. If Haiku answers your support questions well enough, the saving is $1,045 a month for the same product. That is why the first pricing decision is not which tier to buy, but which model is good enough. Evaluate Haiku on your real questions before assuming you need Sonnet; evaluate Sonnet before assuming you need Opus. The evaluation tools in Bedrock exist for exactly this test.

Example 3: a document-classification pipeline on Nova Micro. Suppose you classify 1 million documents a month, each using 500 input tokens and 50 output tokens. Input: 500 million × $0.035 = $17.50. Output: 50 million × $0.14 = $7.00. Model cost: $24.50 a month. Run it as a batch job and the model line halves to about $12. That is the economics that makes it possible to put AI on every document in a company, not just the important ones.

Three rules follow from the math. First, output tokens cost roughly five times input tokens on most models, so a model that writes long answers is expensive even when its input price looks cheap — keep outputs short and you keep the bill short. Second, measure cost per task, not per token: a $2-per-million model that answers in one call beats a $0.10 model that needs five calls and a retry loop. Third, cache and batch before you upgrade: prompt caching and batch inference each cut the bill by half or more on the right workloads, and they cost nothing to try. The most expensive mistake on Bedrock is not picking the wrong model. It is running the right model without caching, without batching, and with prompts ten times longer than they need to be.

Your First Working App: A Chatbot in an Afternoon

A first chatbot app on a laptop screen with a friendly speech bubble, a beginner building it. No readable text on the screen.

Enough theory. Here is the shortest honest path from an AWS account to a working Bedrock app, using the Converse API and Claude Sonnet 5.5 — the combination AWS itself publishes as its getting-started example.

Step 1: set up access. Create an AWS account if you do not have one — new customers get up to $200 in AWS credits to try AWS AI, according to AWS. Install the AWS CLI and run aws configure with your credentials, then install Python 3 and boto3 with pip install -U boto3. Open the Bedrock console, go to Model access, and request access to the models you want. For Anthropic models, submit the one-time use-case form the first time. Check the model is available in your region — us-east-1 (N. Virginia) has the widest catalogue — and note the inference-profile form of the model ID.

Step 2: try it in the playground first. In the Bedrock console, open the playground, pick Claude Sonnet 5.5, and type a question. Compare it with Nova 2 Lite and Haiku 5.5 on the same prompt. This takes five minutes and tells you more than any benchmark: how each model writes, how fast it answers, and whether the expensive one is worth it for your use case. Do not skip this step and go straight to code.

Step 3: make the first API call. The code below is adapted from the example AWS publishes on builder.aws. It creates a Bedrock Runtime client, calls the Converse API with the global inference profile for Sonnet 5.5, and prints the reply plus the token usage — the two numbers your bill is built from.

import boto3

client = boto3.client("bedrock-runtime", region_name="us-east-1")

MODEL_ID = "global.anthropic.claude-sonnet-5-5"

response = client.converse(
    modelId=MODEL_ID,
    system=[{"text": "You are a helpful assistant. Answer briefly and clearly."}],
    messages=[{"role": "user", "content": [{"text": "What is Amazon Bedrock in one paragraph?"}]}],
    inferenceConfig={"maxTokens": 800},
)

for block in response["output"]["message"]["content"]:
    if "text" in block:
        print(block["text"])

print(response["usage"])

Step 4: turn the call into an app. Wrap the call in a function that takes a user question and returns an answer. Add a system prompt that describes your product and its rules. Add conversation history by passing earlier messages in the messages list. Then add the two production features that separate a demo from an app: a guardrail, by adding guardrailConfig={"guardrailIdentifier": "<your-guardrail-id>", "guardrailVersion": "1"} to the call, and cost tagging, by tagging the AWS resources and enabling model invocation logging so you can see spend per model in CloudWatch. The guardrail section below explains what to configure.

Step 5: swap the model and measure. Change MODEL_ID to global.amazon.nova-2-lite-v1:0 — or the equivalent profile for the model you want — and run the same questions again. Nothing else in the code changes. That is the test that justifies Bedrock: five models, one afternoon, your questions, your data. Pick the cheapest model that answers well enough, not the most capable model you can afford. And set a billing alarm in AWS before you leave the console: Bedrock bills per token, and a runaway loop that calls the API thousands of times is the classic first bill shock. A $10 alarm costs nothing and has saved many beginners an unpleasant month.

Knowledge Bases: Giving Bedrock Your Company’s Data

A company document library feeding into a single answering brain, retrieval-augmented generation. No readable document text.

A foundation model knows the public internet up to its training date. It does not know your company’s price list, your support history, your internal policies, or last quarter’s sales figures. Knowledge Bases are Bedrock’s managed way of closing that gap — retrieval-augmented generation (RAG) without building the retrieval system yourself. You point Bedrock at your data sources, it chunks and embeds the documents, stores the vectors, and at query time retrieves the relevant passages and hands them to the model with your question. The model answers from your documents, not from its memory.

Managed Knowledge Bases became generally available in July 2026, and the managed version now includes native connectors for ServiceNow, Confluence Data Center, Salesforce and Zendesk, plus scheduled automatic syncs — daily, weekly or monthly — so the knowledge base stays current without manual re-indexing. You can also use Bedrock Data Automation as the parsing method when you set up a knowledge base, so that figures, charts and diagrams inside documents are extracted and used in retrieval rather than lost. For the background ideas — embeddings, retrieval, and why long context does not replace retrieval — our explainer of BERT, Llama, Whisper and RAG covers the concepts.

The pricing is separate from model tokens, and AWS publishes worked examples. Index storage costs $5.00 per gigabyte per month. Standard retrieval costs $1.00 per 1,000 queries. Agentic retrieval — where the model decides what to retrieve and makes multiple retrieval calls per question — costs $4.00 per 1,000 agentic calls, plus $1.00 per 1,000 underlying retrieval calls. AWS’s own example: a support chatbot indexing 50 GB of SharePoint content (about 100,000 documents) and handling 100,000 standard retrieval queries a month costs $250 for storage plus $100 for retrieval — $350 a month, with parsing, embedding generation and re-ranking included. The agentic version of the same workload, at 100,000 agentic calls each making two underlying retrievals, costs $250 + $400 + $200 = $850 a month. Those are AWS’s examples, and they show the shape of the decision: standard retrieval for straightforward question-answering, agentic retrieval when questions need multi-step research.

Two practical warnings. First, a knowledge base is only as good as the documents in it: out-of-date, contradictory or badly written source documents produce out-of-date, contradictory answers, and no retrieval system fixes that — the fix is in the documents. Second, retrieval has limits: the model can only use what was retrieved, and for a very large corpus a million-token context window does not replace retrieval, because a company’s whole document store is far larger than any window. Knowledge Bases and long context are complements, not substitutes.

Guardrails and Automated Reasoning: Safety You Can Configure

A guardrail fence and shield standing around a chat conversation, safety filters in place. No text.

The question every team asks before putting a model in front of customers is what happens when it goes wrong — when it repeats something harmful, leaks something private, or confidently invents a fact. Bedrock Guardrails are the configurable answer: a set of filters you apply to prompts and responses, independent of which model you use, so the same safety policy covers Claude, Nova, Llama and everything else behind the same API.

A guardrail is built from filters you switch on as needed, and you pay only for the filters you use. Content filters block harmful content across categories such as hate, insults, sexual content, violence and misconduct. Denied-topics filters block subjects you name — a bank might block investment advice, a retailer might block competitor pricing. Sensitive-information filters detect and redact personally identifiable information such as names, addresses and account numbers, or block the response entirely. Word filters block specific terms. And a prompt-attack filter guards against jailbreak attempts that try to override your instructions. Each filter is optional, and charges are incurred only for the safeguards you enable.

The pricing is per text unit, where a text unit is up to 1,000 characters: content filters and denied topics cost $0.15 per 1,000 text units, sensitive-information filters cost $0.10, and the newer Automated Reasoning checks cost $0.17. AWS’s own worked example makes the scale concrete: a support chatbot serving 1,000 queries an hour, each query 200 characters and each answer 1,500 characters, processes 3,000 text units an hour — and content filters plus denied topics on that volume cost $0.90 an hour. For most applications, guardrails are a small line on the bill, not a large one.

Automated Reasoning is the more interesting filter, and the one most often misunderstood. It does not check whether an answer “sounds right”. It checks whether an answer is logically entailed by a source you supply — your policy document, your price list, your medical guideline — and it can identify correct model responses with up to 99% accuracy, according to AWS. That is a vendor claim, stated as a vendor claim, but the mechanism is what matters: it turns “did the model follow the document?” from a human judgement into a check you can run on every answer. AWS also claims Guardrails can block up to 88% of harmful content — again, a vendor claim, and the honest reading is that guardrails reduce harm, they do not eliminate it.

The operational advice is simple and comes from AWS itself: turn Guardrails on from day one, not as a patch after the first incident. Configure them in the console, test them with adversarial prompts before launch, log blocked requests so you can see what your users are actually trying, and remember that a guardrail is a filter on the model’s output, not a substitute for choosing a model that behaves well in the first place. The two work together; neither replaces the other.

Agents on Bedrock: AgentCore and Managed Agents

A team of small robot agents working at desks, coordinated by a central hub. No text.

A chatbot answers questions. An agent does things: it plans a multi-step task, calls tools, reads the results, remembers what happened, and carries on without a human steering every step. 2026 is the year agents moved from pilot to production on Bedrock, and AgentCore is the layer that makes them deployable rather than just demonstrable.

AgentCore is not one service but a set of capabilities that work together or independently. Runtime is a secure, serverless runtime built for deploying and scaling agents and tools. Memory lets agents remember context across sessions without you building the memory infrastructure. Gateway turns your APIs, Lambda functions and existing services into agent-compatible tools, with automatic authentication. Policy gives deterministic control over what an agent can do, with fine-grained rules written in natural language or Cedar that authorise every tool call at the gateway. Browser provides a fast, secure cloud browser so agents can interact with websites at scale. Code Interpreter lets agents write and execute code in sandboxed environments. Identity lets agents access AWS services and third-party tools on your behalf, with pre-authorisation. Observability gives tracing and debugging with OpenTelemetry-compatible telemetry, and Evaluations runs continuous quality assessment against production traffic. There is also an Agent Registry — a central catalogue for discovering and reusing agents, tools and skills across an organisation.

The scale is real: according to Amazon, tens of thousands of customers now use AgentCore, and in the third quarter of 2026 they deployed twice as many agents as in the previous three quarters combined. In April 2026 AgentCore added a managed harness in preview — define an agent with just a model, a system prompt and tools, and AWS handles the orchestration — and the AgentCore CLI launched at the same time. For teams that already build agents with frameworks such as LangGraph or CrewAI, AgentCore is infrastructure: deploy your agent, with your framework and your model, and get production security, identity and observability from day one, with no infrastructure to manage.

Alongside AgentCore sits a second agent offer: Managed Agents, powered by OpenAI, now in public preview. It combines OpenAI’s frontier models and harness with AWS infrastructure, so you build agents with OpenAI models while keeping data inside AWS, reusing your IAM permissions, and keeping auditability through CloudTrail. It includes durable sessions and built-in human-approval workflows — the two features that matter most when an agent can spend money or change records. Which to choose is a framework question, not a quality question: AgentCore if you want any framework and any model, Managed Agents if you want OpenAI’s harness on AWS rails.

One caution belongs here, because agents are where the bills and the risks both grow. An agent that loops — calling a model, calling a tool, calling the model again — multiplies token usage with every cycle, and a badly designed agent can spend in an hour what a chatbot spends in a month. Set token budgets, set step limits, require human approval for irreversible actions, and watch the first week of production traffic closely. AgentCore’s observability and evaluations exist for exactly this reason; turn them on before you need them.

Bedrock vs Direct APIs: When to Use Which — and the Verdict

A crossroads signpost in a landscape with two paths, a direct road and a managed road, a choice. Blank signposts, no words.

The question this guide has been building toward is simple: if you can call Claude directly from Anthropic, Llama from Meta, or GPT-6 from OpenAI, why go through Bedrock at all? The answer is that it depends on what you are building, who you are building it for, and what you value most.

Choose Bedrock when you want one bill, one login and one set of logs for many models; when you work inside AWS already and your data, your identity system and your compliance posture live there; when you need Guardrails, Knowledge Bases, AgentCore or model evaluation as managed services rather than things you build yourself; when your organisation requires SOC, HIPAA, GDPR or FedRAMP-shaped controls and wants its AI spend visible in CloudWatch and Cost Explorer alongside everything else; and when you want to switch models without rewriting your application. Bedrock’s strongest argument is not any single model — it is that the platform around the models is the same for all of them.

Choose direct APIs when you need a provider’s newest feature on the day it ships, because providers always ship to their own API first and Bedrock follows; when you need a model that is not on Bedrock at all — Gemini is the obvious example; when you want the provider’s own tooling, such as Anthropic’s Claude Code or OpenAI’s Agents SDK, in its native form; or when you are a small team with one model, one use case, and no need for AWS governance. A startup building one chatbot on one model will often be simpler and faster going direct. A company building five AI features on four models, in a regulated industry, will usually be safer and cheaper going through Bedrock — cheaper not per token, but per feature shipped.

There are also honest limits to name. Bedrock’s catalogue lags the providers’ own releases by days or weeks, and some models are gated or region-limited. Cross-region inference can complicate data-residency requirements if you are not careful about which profile you use. Provisioned throughput for some models requires an account-team conversation rather than a console click. And Bedrock is, unapologetically, a way to go deeper into AWS: the more of it you use, the more sense it makes to keep everything else on AWS too. That is a lock-in to weigh with open eyes, not a trap to discover later.

Your situationPickWhy
First chatbot, one model, learningBedrock playground, then Sonnet 5.5 or Haiku 5.5Free to try, one bill, swap models in one line
Support bot at volumeHaiku 5.5 or Nova 2 Lite, with Guardrails$55 vs $1,100 a month at 100K answers (see §9)
Long documents, research, coding agentsSonnet 5.5 or Opus 5.5; Kimi K3.1 Pro for long context1M context across the current line; test on your docs
Classifying or extracting at scaleNova Micro, batch inference$24.50 a month per million documents (see §9)
Answers from your own documentsKnowledge Bases + Sonnet 5.5Managed RAG; $350 a month at AWS’s example scale
Agents in productionAgentCore, or Managed Agents for OpenAI modelsIdentity, policy, observability built in
Need Gemini, or a provider’s day-one featureDirect APINot on Bedrock; providers ship to themselves first

The verdict is this. Amazon Bedrock in November 2026 is no longer the simple model menu it was at launch in 2023. It is a platform: hundreds of models behind one API, with managed retrieval, configurable safety, cost controls that genuinely work, and an agent layer that is seeing real production use. Its weaknesses are real — catalogue lag, regional gaps, AWS lock-in — but for most teams building AI inside AWS, they are smaller than the cost of building the same platform themselves. Start in the playground, test three models on your own questions, do the pricing math in section 9 with your own volumes, and let the numbers decide. For the decision framework itself — what speed, cost, reasoning depth and context actually trade off against each other — our guide to choosing an AI model sets out the method. And re-check the catalogue before you build: re:Invent 2026 runs 30 November to 4 December, and Bedrock is the service most likely to change there. Checked 19 November 2026.

Sources

All sources below were read on 19 November 2026, except where noted. Facts, dates and prices in this guide come from these pages. Prices are as listed on 19 November 2026; the AWS pricing page is the authority if they have moved. No competitor or comparison-site pages were used as sources for facts, except where a price table is explicitly flagged as a consistent secondary read.

  • AWS — Amazon Bedrock pricing (tiers, Batch 50%, Flex −50%, Priority +75%, DeepSeek v3.2, Mistral Large 3, MiniMax M2.5, Kimi K3.1 Pro Highspeed $4/$20 Global CRIS, Kimi K3 $3/$15, Guardrails per-filter pricing, Knowledge Bases pricing, Prompt Routing $1/1,000 requests, Model Evaluation $0.21/human task) — read in full, 2,127 lines — https://aws.amazon.com/bedrock/pricing/
  • AWS — Amazon Bedrock FAQ (definition, provider list, five reasons, playground, compliance, “content is not used to improve the base models”, AgentCore components) — read in full — https://aws.amazon.com/de/bedrock/faqs/
  • AWS — Amazon Bedrock main page (100,000+ organisations, AgentCore, Managed Agents powered by OpenAI, Robinhood case, $200 new-customer credits) — read in full — https://aws.amazon.com/bedrock/
  • AWS docs — Supported foundation models in Amazon Bedrock (catalogue moved to “models at a glance”) — read — https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
  • builder.aws — “Amazon Bedrock in 2026” (published 7 Nov 2026; GA dates, Q3 2026 earnings claims, new model arrivals, Managed KB GA July 2026, Guardrails 88% / Automated Reasoning 99% vendor claims, AgentCore scale, Converse API example with global.anthropic.claude-sonnet-5-5) — read in full — https://builder.aws.com/content/3LlMUuNbeK5mH99UZEdSJw5MpqG/amazon-bedrock-in-2026-why-it-became-the-foundation-for-building-with-generative-ai-and-agents
  • Claude 5.5 pricing (Fable 5.2 $8/$40, Fable 5.1 $10/$50, Opus 5.5 $4/$20, Sonnet 5.5 $2/$10, Haiku 5.5 $0.10/$0.50 ≤100K prompt) — Anthropic pricing page via six consistent secondary reads (infro.io, octomind.run, sentra.app, morphllm.com, barside.space, ssdnodes.com), Nov 2026; AWS pricing page table JS-rendered and not visible in text fetch
  • Nova catalogue and pricing (Nova 2 announced 2 Dec 2025; Nova 2 Lite $0.30/$2.50 global, 1M context; Nova Micro $0.035/$0.14, Lite $0.06/$0.24, Pro $0.80/$3.20; Nova 1 Premier deprecated) — seminal.ai, aiwiki.ai, toolglade.com, ssdnodes.com — consistent
  • Titan text-model retirement (absent from Bedrock catalogue Sep–Nov 2026; embeddings only) — ssdnodes.com catalogue check 5 Nov 2026, corroborated by AWS pricing page structure
  • Bedrock history (announced 13 Apr 2023; GA 28 Sep 2023) — en.wikipedia.org/wiki/Amazon_Bedrock; aboutamazon.com GA announcement 28 Sep 2023
  • Bedrock catalogue snapshot (Llama 4 Maverick/Scout, Llama 3.3/3.1/3.2; Claude Opus/Sonnet/Haiku 5.5; Nova 2) — developersdigest.tech/rate-limits/bedrock (verified 5 Nov 2026)
  • GPT-6.1 Terra generally available on Bedrock 26 Oct 2026; reported $1/$5 — omidsaffari.com pricing roundup — SINGLE SOURCE, flagged in the text
  • Kimi K3.1 Pro added to Bedrock 6 Nov 2026 — geroundtable.com news post 4867 (our own coverage)

Share to: , and

Faheem R. Khattak

Senior automation engineer and AI marketing journo covering LLMs, algorithms, analytics, core updates, Bing search, and technical SEO.

0 Comments

Leave a Reply

Optional Take Tag:

🛡️ Spam protection: Honeypot + Time-Trap Active

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