/AI agents
AI agents with Amazon Bedrock and AgentCore in production
We build AI agents that do real work inside your systems: they query data, call APIs, make decisions within clear limits and ask a human when they should. Built on Amazon Bedrock and AgentCore, with tools over MCP, Knowledge Bases, identity, memory and observability for every step.
/Diagnosis
Signs it is time
Processes full of manual work
Support, operations or back office teams handle repetitive tasks that require reading documents, checking several systems and making simple decisions.
A fragile agent prototype
You built an agent with a popular framework, but it fails unpredictably, you cannot tell why it made each decision, and you do not dare give it access to real systems.
Security and permissions left open
The agent needs to act on behalf of users in your CRM, ERP or internal APIs, and there is no clear model for identity, credentials or audit.
Many tools, no standard
Every agent integration is hand-written with no reuse across teams, and you want to standardize on the Model Context Protocol.
/What we deliver
Concrete deliverables, in your repository
Agent design and boundaries
Goal, tools, permissions, human approval points, success criteria and the chosen pattern: single agent, deterministic workflow or multi-agent.
Agent deployed on AgentCore
An agent built with Strands Agents, LangGraph or another framework, running on AgentCore Runtime with per-session isolation and managed memory.
Tools over MCP and APIs
APIs and Lambda functions exposed as tools through AgentCore Gateway and MCP servers, with clear schemas and least-privilege permissions.
Knowledge with Knowledge Bases
Amazon Bedrock knowledge bases with ingestion, chunking, metadata and access filters, so the agent answers with cited sources.
Identity, guardrails and audit
AgentCore Identity for delegated credentials, Bedrock Guardrails, action limits and a complete record of every decision.
Agent observability and evaluation
Traces for every step with AgentCore Observability and OpenTelemetry, per-task success metrics and evaluation sets in CI.
/How we work
Our process
Use case selection
We pick a narrow, frequent and measurable task, map the systems involved and define what the agent can do on its own and what needs approval.
Evaluated prototype
We build the agent with its tools and an evaluation set of real scenarios, and measure success rate, cost and latency.
Hardening for production
We add identity, guardrails, error handling, iteration limits, observability and deployment on AgentCore with Terraform.
Scaling and new agents
We monitor results, extend the toolset and reuse the platform for new agents or multi-agent collaboration.
What an AI agent is, and when it makes sense to use one
An AI agent is a system in which a language model decides which steps to take to reach a goal, choosing tools, looking up information and evaluating intermediate results. Unlike an assistant that only answers, an agent acts: it opens a ticket, checks an order, updates a record or prepares a draft for review.
Not every problem needs an agent. If the steps are known and stable, a deterministic workflow in Step Functions with targeted model calls is cheaper, faster and easier to test. Agents shine when the sequence depends on context, there are many possible tools and the task requires interpreting loosely structured information. That decision is the first thing we settle.
Amazon Bedrock Agents vs. AgentCore: which to use when
Amazon Bedrock Agents is the fully managed option for agents with declarative configuration: you define instructions, action groups and knowledge bases, and Bedrock orchestrates the reasoning and tool calls. It is a good fit for narrow use cases, teams that prefer less code and workflows where fine-grained control over agent logic is not a priority.
Amazon Bedrock AgentCore is a set of services for running and operating agents built with any framework and any model. It includes Runtime to run agents with per-session isolation, Memory for short- and long-term memory, Gateway to turn APIs and Lambdas into MCP-compatible tools, Identity for delegated credentials, Observability for traces, and built-in tools such as Code Interpreter and Browser.
In practice, we use AgentCore when we need fine control over the logic, frameworks like Strands Agents or LangGraph, complex integrations or models from different providers, and Bedrock Agents when simplicity matters more than flexibility. Either way, the agent is defined as code in your repository and deployed with Terraform, so it is reproducible across environments.
Tool use, MCP and Knowledge Bases
An agent is only as good as its model and its tools. We design tools with clear names and descriptions, strict input schemas, compact responses and informative errors, because the model decides based on that text. Each tool gets least-privilege permissions and, if it modifies data, a confirmation policy.
The Model Context Protocol standardizes how tools and data are exposed to agents. With AgentCore Gateway we turn existing APIs and Lambda functions into MCP tools without rewriting them, and reuse them across agents and teams. For knowledge, Amazon Bedrock Knowledge Bases handles ingestion, embeddings and retrieval with metadata filters, so the agent cites sources and respects access permissions.
Multi-agent orchestration without losing control
When a task spans different domains, such as reviewing a contract, checking billing and drafting a reply, it can pay to split it into specialized agents coordinated by a supervisor. Bedrock offers managed multi-agent collaboration, and frameworks like Strands Agents or LangGraph support supervisor, graph or swarm patterns.
Every extra agent adds latency, cost and failure points. So we start with a single, well-designed agent and move to multi-agent only when evaluation shows a clear benefit. We set iteration limits, token budgets per task and escape hatches to a human when the agent is not confident enough.
Observability and evaluation for agents in production
An agent without observability is a black box making decisions about your systems. We instrument every step with OpenTelemetry-compatible traces: the reasoning, the tool chosen, the parameters, the response, the tokens consumed and the latency. AgentCore Observability brings that data into CloudWatch, alongside the rest of your application.
On top of those traces we build business metrics: task completion rate, escalations to humans, tool errors and cost per task. Failed cases feed the evaluation set, which runs on every prompt, model or tool change to catch regressions before they reach users.
/FAQ
AI Agents with Bedrock: frequently asked questions
Another question? Write to hello@nubent.com and an engineer will answer.
What is Amazon Bedrock AgentCore?
It is a set of AWS services for deploying and operating AI agents securely and at scale, with any framework and any model. It includes Runtime, Memory, Gateway, Identity, Observability and built-in tools such as Code Interpreter and Browser. It covers the infrastructure that usually separates an agent prototype from a production system.
What is the difference between Bedrock Agents and AgentCore?
Bedrock Agents is a managed, declarative service: you configure instructions, actions and knowledge bases, and Bedrock orchestrates the agent. AgentCore gives you the infrastructure building blocks to run agents written in the framework of your choice, such as Strands Agents or LangGraph, with more control over the logic. The choice depends on how complex the use case is.
What is MCP and why does it matter for AI agents?
The Model Context Protocol is an open standard for connecting agents to tools and data sources in a uniform way. Instead of writing a separate integration for every agent, you expose a tool once as an MCP server and any compatible agent can use it. On AWS, AgentCore Gateway turns APIs and Lambda functions into MCP tools.
How do you stop an AI agent from doing something it should not?
With several layers: least-privilege permissions per tool, scoped delegated credentials, human confirmation for sensitive actions, Bedrock Guardrails on inputs and outputs, iteration and budget limits, and full traceability for every step. The evaluation set also includes adversarial scenarios, such as prompt injection attempts.
How much does it cost to run an AI agent on AWS?
Cost combines the tokens the model consumes at each step, AgentCore and tool usage, and storage for knowledge and memory. Because an agent can make several calls per task, we measure cost per completed task from the prototype stage and apply optimizations such as smaller models for simple steps and prompt caching.
Related services
AI-native on AWS
Products and platforms with generative AI at the core: Amazon Bedrock, agents, RAG, evaluation, guardrails, LLMOps and inference costs under control.
Learn moreGenerative AI on AWS
Generative AI on AWS with Amazon Bedrock: assistants, RAG over your documents and GenAI features in your product, with evaluations, guardrails and cost control.
Learn moreServerless on AWS
Lambda, API Gateway, Step Functions, EventBridge, DynamoDB and SQS: event-driven architectures that scale on their own, tolerate failures and bill only for real usage.
Learn moreObservability and SRE
CloudWatch, OpenTelemetry and Grafana, SLOs with error budgets, actionable alerts, incident management and postmortems to run AWS on data.
Learn moreData on AWS
A data platform on AWS: automated ingestion, an S3 data lake, Glue transformations, Athena and Redshift for queries, and Lake Formation for governance.
Learn moreNext step
Let's talk about your AI Agents with Bedrock project
30 minutes with an engineer. Concrete next steps, whether or not you work with us.