Skip to content
Nubent

/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

  1. 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.

  2. Evaluated prototype

    We build the agent with its tools and an evaluation set of real scenarios, and measure success rate, cost and latency.

  3. Hardening for production

    We add identity, guardrails, error handling, iteration limits, observability and deployment on AgentCore with Terraform.

  4. 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.

Next 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.