AWS · AI/ML · April 2026  ·  🕒 8 min read  ·  Published Apr 3, 2026

Ask any ML engineer who has tried to take an AI agent from notebook to production, and they'll describe the same nightmare: weeks burned on session management, memory stores, authentication layers, observability pipelines, and policy enforcement — before writing a single line of actual agent logic. AWS just declared war on that problem.

Amazon Bedrock AgentCore — now generally available and shipping major updates at a pace that would make a startup blush — is a fully managed, modular platform that handles all the undifferentiated infrastructure required to deploy and operate AI agents at enterprise scale. No infrastructure management. Framework-agnostic. Pay only for what you use.

"Previously, deploying agents took weeks. Now, with AgentCore we can create and deploy an agent or MCP server within minutes." — S&P Global Market Intelligence

Why This Matters Now

The shift from chatbots to agents is not subtle. Agents don't just respond — they reason, plan, call tools, write code, browse the web, and take actions with real-world consequences. That power introduces a new set of production concerns that traditional cloud patterns simply don't cover:

• How do you isolate one user's session from another when the agent is long-running?
• How do you give an agent persistent memory without exposing it to other users?
• How do you enforce which tools an agent can call, and under what conditions?
• How do you monitor correctness and goal-success rates — not just latency — in production?

AgentCore answers every one of these, and recent weeks have seen a flurry of GA announcements that show the platform is maturing fast.

The AgentCore Architecture at a Glance

Think of AgentCore as a set of composable, independently usable services that snap together around your agent code — regardless of whether that code uses LangGraph, CrewAI, LlamaIndex, Strands Agents, or anything else.

What's New: March 2026 Shipping Log

The pace of AgentCore updates this month alone tells you everything about AWS's commitment to this platform.

Mar 25 — Managed Session Storage (Preview)

Agents can now persist their entire filesystem state across stop/resume cycles. Files, installed packages, build artifacts, git history — all automatically retained for up to 14 days. No checkpoint logic needed; your agent just picks up where it left off with the same session ID.

Mar 13 — AG-UI Protocol Support

AgentCore Runtime now speaks the Agent-User Interaction (AG-UI) protocol, enabling real-time streaming of reasoning steps, tool results, and UI state updates directly to frontends. The third pillar after MCP (tools) and A2A (agent-to-agent): AG-UI brings agents into the user interface layer.

Mar 12 — Streaming Notifications for Long-Term Memory

No more polling. Memory record creation and updates now push to Amazon Kinesis in real time, enabling downstream workflow triggers and automatic application state refresh.

Mar 10 — Stateful MCP Servers

AgentCore Runtime now supports elicitation (server-initiated multi-turn conversations), sampling (LLM-generated content requests from clients), and progress notifications for long-running operations. Each session runs in a dedicated microVM with a persistent Mcp-Session-Id.

Mar 3 — Policy GA

Policy in AgentCore is now generally available across 13 AWS Regions. Write a rule like "Block all refunds greater than $1,000" in plain English and it converts automatically to a Cedar policy that intercepts and evaluates every agent-tool request.

The Protocol Trifecta: MCP + A2A + AG-UI

One of the under-appreciated aspects of AgentCore is how AWS has positioned it around emerging open protocols rather than proprietary abstractions.

Together, these protocols mean you can build multi-agent systems that are observable, interactive, and connected to your entire existing tool ecosystem — without locking into AWS-only abstractions.

Policy: Natural Language Governance for Agents

Enterprise adoption of agentic AI has been slowed by a fundamental tension: agents need autonomy to be useful, but businesses need guardrails to be responsible. Policy in AgentCore elegantly threads this needle.

The key insight is that policies live outside your agent code. Security teams, compliance officers, and operations leads can define and update what an agent is allowed to do — without touching the agent itself, and without understanding prompt engineering. Natural language input is automatically compiled to Cedar, AWS's open-source policy language, and every agent-to-tool call is evaluated in milliseconds at the Gateway layer.

💡 Real-world example: A policy like "Only allow read operations on customer records for agents authenticated with a support role token" can be authored in plain English, automatically enforced across every MCP tool call, and audited without grep-ing through agent logs. This is governance-as-infrastructure.

Getting Started: Faster Than You Think

AWS has made the developer experience genuinely low-friction. The AgentCore Starter Toolkit provides a CLI that can configure, containerize, and deploy an agent in a few commands:

$ pip install bedrock-agentcore bedrock-agentcore-starter-toolkit
$ agentcore configure --entrypoint my_agent.py
$ agentcore deploy
# Auto-creates IAM role, ECR repo, and deploys to AgentCore Runtime

New AWS customers get up to $200 in Free Tier credits to start, and pricing is purely consumption-based — no pre-allocated compute, no minimum fees. If your agent is waiting on I/O, you're not being billed for CPU.

Who Should Pay Attention

AgentCore isn't just for ML engineers. Its modular design means different personas get different value:

• ML/AI Engineers — Stop rebuilding memory, session management, and tool-calling plumbing. Focus on agent quality.
• DevOps/Platform Engineers — AgentCore Runtime plugs into your existing VPC, PrivateLink, CloudFormation, and OpenTelemetry setups.
• Security & Compliance Teams — Policy gives you enforcement at the infrastructure layer, not the prompt layer. Finally, real governance.
• Product & Platform Leads — The AG-UI protocol means your product team can build real-time, agent-driven UIs without waiting for backend reimplementation.

"In 2026, the bottleneck in agentic AI is no longer model capability — it's the production infrastructure around the model. AgentCore is AWS's bet that they can own that layer."

The Bottom Line

Amazon Bedrock AgentCore represents a genuine architectural leap for production agentic AI. The combination of serverless isolation, persistent memory, open-protocol gateway, natural language policy enforcement, and deep observability — all independently composable, all GA or near-GA — gives teams a legitimate path from prototype to production without building a platform team first.

The March 2026 updates (session storage, AG-UI, stateful MCP, streaming memory, Policy GA) aren't incremental patches. They're filling the remaining gaps that enterprises have cited as blockers. If you've been waiting for AgentCore to be "enterprise-ready," the wait is over.

AWS Summit Bengaluru is on April 23–24, 2026 — expect a deep dive on AgentCore there. Register here →

AWS Amazon Bedrock AgentCore Agentic AI MLOps MCP Generative AI Cloud DevOps

Written by Ramakrishnan Sakthivel — SVP · Cloud Infrastructure Architect (SRE) @ JPMorganChase · 12+ years in Cloud Migration, Cloud-Native Architecture & Modernization · Building AI/ML solutions for risk prediction & capacity management.

LinkedIn · Infra Intelligence on Hashnode

AWS · Amazon Bedrock · April 2026  ·  🕒 7 min read

You've been fine-tuning models the hard way. Collecting thousands of labeled examples. Running expensive annotation pipelines. Managing GPU infrastructure for training jobs. Getting mediocre results because your dataset was never large enough.

Amazon Bedrock just made all of that optional.

Reinforcement Fine-Tuning (RFT) — now generally available on Amazon Bedrock — is a fundamentally different approach to model customization. Instead of learning from fixed labeled examples, models learn from feedback on their own responses. The result? An average of 66% accuracy gains over base models, using a fraction of the data traditional fine-tuning requires.

"Instead of showing a chess player every possible move, you let them play and tell them which moves led to winning positions."

That's exactly how RFT works — and AWS has made it fully managed, so you don't need to understand RL theory to use it.

What's Wrong With Traditional Fine-Tuning

Traditional supervised fine-tuning (SFT) has a fundamental problem: it requires you to know the exact right answer before training. For every prompt, you need a perfect, labeled response. That means:

• Hiring human annotators — expensive and slow
• Building data pipelines — weeks of engineering work
• Large datasets — thousands of examples minimum
• Static knowledge — the model only learns what you showed it

For tasks like math reasoning, code generation, or complex instruction following, defining the "exact correct output" is often impossible. There are dozens of valid ways to write good code. There's no single correct way to explain a concept. SFT can't handle that nuance.

How RFT Actually Works

RFT flips the training paradigm entirely.

Instead of learning from labeled examples, the model:

1. Generates multiple candidate responses to each prompt
2. A reward function scores each response — measuring quality against your criteria
3. The model updates to favor patterns that produced higher-scoring outputs
4. Repeats until it consistently produces high-quality responses

The magic is in the reward function. AWS supports two types:

AWS runs this using GRPO (Group Relative Policy Optimization) — a state-of-the-art RL algorithm that compares responses within a group to determine relative quality, making training stable and efficient.

The Numbers That Matter

Supported Models

At launch, RFT supported Amazon Nova 2 Lite. AWS has since expanded to open-weight models including:

• qwen.qwen3-32b — Alibaba's powerful open model
• openai.gpt-oss-20b — GPT OSS via OpenAI-compatible APIs

And coming soon: NVIDIA Nemotron models via the AWS-NVIDIA collaboration announced at GTC 2026.

Getting Started in 5 Steps

# Step 1: Prepare your training data (JSONL format)
{
  "id": "sample-001",
  "messages": [
    {"role": "system", "content": "You are a financial analyst"},
    {"role": "user", "content": "Analyze this quarterly report..."}
  ],
  "reference_answer": {
    "key_metrics": ["revenue_growth", "margin_compression"],
    "recommendation": "hold"
  }
}

# Step 2: Create the RFT job via boto3
import boto3
bedrock = boto3.client(service_name='bedrock')

response = bedrock.create_model_customization_job(
    jobName="my-rft-job",
    customModelName="my-custom-model",
    customizationType="REINFORCEMENT_FINE_TUNING",
    baseModelIdentifier="amazon.nova-2-lite-v1:0:256k",
    roleArn="arn:aws:iam::123456789012:role/BedrockRFTRole",
    trainingDataConfig={"s3Uri": "s3://my-bucket/training-data.jsonl"},
    outputDataConfig={"s3Uri": "s3://my-bucket/rft-output/"},
    customizationConfig={
        "rftConfig": {
            "graderConfig": {
                "lambdaGrader": {
                    "lambdaArn": "arn:aws:lambda:us-east-1:123456789:function:my-grader"
                }
            },
            "hyperParameters": {
                "batchSize": 64,
                "epochCount": 2,
                "learningRate": 0.00001,
                "reasoningEffort": "high"
            }
        }
    }
)

# Step 3: Monitor training
# Track via Amazon Bedrock console or CloudWatch

# Step 4: Deploy with one click (console) or via API
# Step 5: Invoke via OpenAI-compatible API
from openai import OpenAI
client = OpenAI(
    base_url="https://bedrock-mantle.<your-region>.api.aws/v1"
)
response = client.chat.completions.create(
    model="my-custom-model",
    messages=[{"role": "user", "content": "Your prompt here"}]
)

When to Use RFT vs Traditional Fine-Tuning

💡 Decision rule: If you can measure whether a response is good but can't always write the perfect response yourself — use RFT.

RFT is ideal for:

• Mathematical reasoning and problem-solving
• Code generation and optimization
• Complex multi-step instruction following
• Subjective tasks like content moderation and creative writing
• Any task where multiple valid answers exist

Stick with SFT when:

• You have thousands of high-quality labeled examples already
• The task has a single, deterministic correct answer
• Your baseline model gets 0% rewards (establish basics with SFT first)
• Your baseline already scores above 95% (RFT unnecessary)

The Enterprise Angle: Why This Changes Everything for FinOps Teams

RFT doesn't just improve accuracy — it changes the economics of model deployment.

The traditional path: use a large, expensive model because smaller ones aren't accurate enough for your use case.

The RFT path: fine-tune a small, fast, cheap model with RFT until it outperforms the large model on your specific task.

Example: Amazon Nova 2 Lite fine-tuned with RFT on your domain-specific task can match or beat a much larger general-purpose model — at a fraction of the inference cost, with lower latency, and better alignment to your specific requirements.

For teams running thousands of inferences per day, that cost delta is significant.

The Bottom Line

Reinforcement Fine-Tuning on Amazon Bedrock is one of the most practically significant ML capabilities AWS has launched in years. It democratizes advanced model customization — no labeled datasets, no RL expertise, no GPU management. Just define what "good" looks like, provide a few hundred examples, and let Bedrock handle the rest.

With the 66% average accuracy improvement and expanding model support including open-weight models and soon Nemotron, the case for RFT is compelling for any team that has struggled with traditional fine-tuning.

The era of "use the biggest model you can afford" is giving way to "fine-tune the right-sized model precisely for your task." RFT is how you get there on AWS.

AWS Summit Bengaluru — April 23–24, 2026 — will feature deep dives on Bedrock customization. Register here →

AWS Amazon Bedrock Reinforcement Learning Fine-Tuning MLOps Generative AI Machine Learning LLM

Written by Ramakrishnan Sakthivel — SVP · Cloud Infrastructure Architect (SRE) @ JPMorganChase · 12+ years Cloud · AI/ML LinkedIn · Infra Intelligence