Newshot

How Duco transforms financial data automation with Amazon Bedrock AgentCore

Summary

Financial institutions face a critical challenge: processing massive volumes of data with speed, accuracy, and compliance while operating under some of the world’s strictest regulatory frameworks. Duco is the agentic Operations platform for financial services, serving tier-one banks and other financial institutions. It processes 20 billion transactions monthly for 200+ clients, including 7 of the top 20 banks and 10 of the top 20 asset managers. To keep pace as data processing demands grew, Duco evolved from traditional machine learning models to the agentic AI capabilities of Amazon Bedrock and Amazon Bedrock AgentCore. In this post, we share how Duco rebuilt its agentic AI stack on these services, cutting deployment time and onboarding costs while keeping each bank’s data isolated. The challenge: Scaling intelligence in a regulated environment Duco’s platform empowers teams to automate mission-critical data processes using AI and no-code models, handling everything from data extracti…

Original text(via AWS Machine Learning)

How Duco transforms financial data automation with Amazon Bedrock AgentCore

Financial institutions face a critical challenge: processing massive volumes of data with speed, accuracy, and compliance while operating under some of the world’s strictest regulatory frameworks. Duco is the agentic Operations platform for financial services, serving tier-one banks and other financial institutions. It processes 20 billion transactions monthly for 200+ clients, including 7 of the top 20 banks and 10 of the top 20 asset managers. To keep pace as data processing demands grew, Duco evolved from traditional machine learning models to the agentic AI capabilities of Amazon Bedrock and Amazon Bedrock AgentCore. In this post, we share how Duco rebuilt its agentic AI stack on these services, cutting deployment time and onboarding costs while keeping each bank’s data isolated.

The challenge: Scaling intelligence in a regulated environment

Duco’s platform empowers teams to automate mission-critical data processes using AI and no-code models, handling everything from data extraction to downstream publication. It already used traditional machine learning models for predictive labeling and pattern recognition, helping banks consolidate and automate over 20,000 processes.

However, these classical machine learning approaches had inherent limitations. They required extensive historical data for training, struggled with novel scenarios, and demanded significant customization for each new use case. Most critically, they couldn’t adapt quickly to the diverse, constantly evolving data formats and business rules that characterize modern financial operations.

“The classical prediction models worked to an extent, but they weren’t agile or flexible enough. Traditional machine learning models can only amplify what they’ve already learned — they can’t help with the next step or find new problems.”

— Rob Gates, Chief Architect and Innovation Officer, Duco

The solution: Amazon Bedrock and Bedrock AgentCore

Duco made a strategic decision to adopt Amazon Bedrock for managed access to foundation models, and Amazon Bedrock AgentCore to run agents at scale. This was more than a technology upgrade. It was a fundamental shift in how its system could understand, reason about, and act on financial data.

About Amazon Bedrock and Bedrock AgentCore

Amazon Bedrock is a fully managed service that offers a choice of high-performing foundation models from leading AI companies through a single API, along with a broad set of capabilities to build generative AI applications with security, privacy, and responsible AI. Learn more about Amazon Bedrock.

Amazon Bedrock AgentCore is the platform to build, connect, and optimize AI agents at scale. Build with any open source framework and any model. Connect agents to your tools and data with authentication and access controls built in. Monitor and improve agents in production with tracing and evaluation. AgentCore handles the infrastructure so you focus on agent logic, not backend plumbing, and you get enterprise security and reliability without giving up open source flexibility.

Learn more on the Amazon Bedrock AgentCore product page.

Why Amazon Bedrock?

Several factors made Amazon Bedrock the ideal choice for Duco’s regulated financial services industry (FSI) environment:

  • Security and compliance first: With Amazon Bedrock, customer data stays within the AWS environment, and it is not used to train models. With private endpoints in its virtual private cloud (VPC), Duco can connect to internal systems while keeping them completely isolated, which matters for sensitive financial data processing.
  • Model flexibility: Access to leading foundation models from the Amazon Nova 2 family, Anthropic, OpenAI, Cohere, Meta, and Mistral AI through a single API means Duco can choose the right model for each task. Duco can switch between models by changing a configuration parameter.
  • Built for financial services: Amazon Bedrock provides the robust governance controls and compliance frameworks that financial services require, avoiding infrastructure complexity while maintaining the security standards tier-one banks demand.

Choosing AgentCore as the runtime

Duco’s existing agent infrastructure was built on LangChain and LangGraph, both of which were already in production. When evaluating runtime options for its agentic workloads, AgentCore emerged as the clear choice for three key reasons:

  • Compatibility with existing primitives: AgentCore is fully compatible with Duco’s existing LangChain and LangGraph code, so most existing code continued to work without modification.
  • Managed runtime: Instead of Duco running its own agent infrastructure, AgentCore provides a fully managed runtime, reducing operational overhead for the engineering team.
  • Regulated environment suitability: AgentCore met the stringent requirements of deploying in regulated financial services environments, with built-in security and compliance controls.

Multi-tenant architecture: Isolation by design

Duco’s platform operates as a multi-tenant software as a service (SaaS) offering with strict tenant isolation (figure 1). This is a non-negotiable requirement for regulated institutions. The architecture reflects this at every layer, from the underlying cloud infrastructure right up to the AI agent runtime.

Duco multi-tenant architecture with per-tenant isolation across the infrastructure, security, and agent layers
Duco multi-tenant architecture with per-tenant isolation across the infrastructure, security, and agent layers

Figure 1: Multi-tenant architecture

Infrastructure layer

  • Amazon Elastic Kubernetes Service (Amazon EKS) clusters with namespace-per-tenant isolation and network segregation help maintain workload separation at the Kubernetes layer.
  • Per-tenant dedicated AWS services: every tenant receives a dedicated Amazon Aurora MySQL database, Amazon Simple Storage Service (Amazon S3) storage bucket, AWS Key Management Service (AWS KMS) encryption keys, Amazon Simple Email Service (Amazon SES) and Amazon Simple Queue Service (Amazon SQS) messaging stack, Amazon ElastiCache layer, and Amazon Cognito user pool. Zero shared data infrastructure across clients.
  • Per-tenant autoscaling helps minimize the impact of one client’s compute-intensive workload on another tenant’s performance.

Security and access control

Isolation is enforced through identity as well as infrastructure, with every hop between the user and their data authenticated (figure 2):

  • Tenant-scoped authentication: every request carries a JSON Web Token (JWT) issued by the tenant’s dedicated Cognito user pool, validated by the inbound authorizer of the AgentCore runtime, a capability of Amazon Bedrock AgentCore, before agent logic runs.
  • Gateway-mediated tool access: agents reach tools only through the tenant’s dedicated AgentCore Gateway, a capability of Amazon Bedrock AgentCore, which passes calls through to the tenant’s container-based Model Context Protocol (MCP) services running in Amazon EKS.
  • End-to-end user identity: the user’s identity is passed through to downstream services, and each MCP server validates both the agent’s and the user’s identity against the tenant’s Cognito user pool, so every tool call is authorized as the calling user, made by a trusted agent.
  • Private networking: tenants share a VPC and Amazon EKS cluster, segregated by namespace and network policy, with private endpoints keeping traffic to Amazon Bedrock and AgentCore on the AWS network. Each tenant’s AgentCore runtime runs in VPC network mode, with network interfaces in the private subnets, so its outbound traffic enters the VPC and is governed by security groups.

Agent layer

The isolation principle extends fully into the agent architecture:

  • One AgentCore runtime and Gateway per tenant: each tenant is served by a dedicated runtime and Gateway, configured against that tenant’s own Cognito user pool and Amazon EKS namespace. Combined with the built-in session isolation of AgentCore, this means there is no shared memory, context, or tooling between clients. Each bank’s unique schemas, naming conventions, and institutional knowledge remain completely isolated from other tenants.
  • Per-tenant MCP servers: each tenant has its own set of MCP servers providing service-specific capabilities, dynamically discovered at boot time.

The architecture helps maintain a model where each agent only has access to one bank’s data, context, and reasoning, facilitating real isolation of context across banks.

High-level architecture showing requests flowing through a per-tenant AgentCore runtime and Gateway to MCP services in Amazon EKS
High-level architecture showing requests flowing through a per-tenant AgentCore runtime and Gateway to MCP services in Amazon EKS

Figure 2: High-level architecture

Multi-model strategy

Rather than committing to a single foundation model, Duco uses the right model for each job, assigning each role in its agent design to the model best suited to it. This approach delivers both quality and cost efficiency by matching the right model capability to each specific workload:

ModelPrimary roleUse cases
Anthropic Claude OpusPlanning agentFor complex reasoning and understanding, formulating up front plans for other agents to execute on
Anthropic Claude SonnetMain reasoning & complex decision-makingException investigation, reconciliation logic, rule interpretation
Anthropic Claude HaikuLightweight tool routing decisionsFast routing choices, low-latency classification, cost-efficient first-pass triage
Amazon Nova 2 ProTool output summarizationCondensing MCP tool responses, generating readable summaries for analysts

Anthropic Claude Opus

This multi-model approach is architecturally designed to allow model swapping without disrupting the stack, which is critical in a landscape where model capabilities evolve rapidly.

Solving context bloat: The MCP skills architecture

One of Duco’s most significant technical innovations addresses a challenge familiar to anyone building production agent systems: context window management.

The problem

With 300–400 tools exposed per tenant through AgentCore Gateway (which fronts a separate MCP server for each underlying Duco service), approximately 200,000 tokens of tool descriptions were loaded into context before work began. This caused context overloading: response quality degraded as conversations lengthened, and the model lost the thread of earlier reasoning. The team emphasized that a feeling an agent is becoming less capable isn’t enough evidence on its own. Evaluations must be run before engineering decisions are made.

The solution: On-demand skills loading

Duco created a skills architecture using MCP resource types to move tool descriptions out of the static context and load them only when needed:

  • skill:// resources — on-demand tool descriptions loaded only when a skill is required.
  • system:// resources — dynamic system prompt sections composed at runtime, keeping the base system prompt lean.
  • ui:// resources — UI-specific resources, isolated from operational tooling.

Three new meta-tools, implemented in Duco’s agent harness, replaced the bloated tool description payload:

  • load_skill — fetches skill descriptions on demand, only when the agent determines a skill is needed.
  • find_tool — locates relevant tools without loading all schemas into context.
  • invoke_tool — executes the selected tool once identified.
On-demand MCP skills loading where meta-tools fetch skill and tool descriptions instead of preloading all tool schemas into context
On-demand MCP skills loading where meta-tools fetch skill and tool descriptions instead of preloading all tool schemas into context

Figure 3: Context loading and MCP connectivity

The results

  • 90% context reduction: Main context reduced from 200,000 tokens to approximately 20,000 tokens by moving tool descriptions out of static context and limiting the size of tool responses.
  • Prompt caching preserved: the static prompt prefix (system prompt plus the three meta-tools) stays small and stable, and skills load into the conversation rather than the tool list, so loading a skill does not invalidate the cache.
  • Measurably improved agent response quality: validated through a rigorous evaluation framework.
  • Zero infrastructure changes required: same underlying models, same tools, and same tasks, with measurably better outcomes.

MCP tool discovery: Deploy a service, gain a capability

A key architectural decision was implementing MCP tool discovery at boot time. When a new service is deployed, its MCP server is registered as a target on the tenant’s AgentCore Gateway as part of the deployment. When an agent boots, the harness builds a registry of every tool the Gateway exposes and shares just the tool names. The agent then uses find_tool and invoke_tool to discover the details and invoke tools on demand. As a result, the agent automatically gains that capability with no redeployment or agent reconfiguration required. Access control is enforced by the underlying services themselves: because the user’s identity is passed through the Gateway, each tool call succeeds only if that user is permitted to perform the action.

This provides operational agility: the platform team can ship new capabilities to agents by deploying a new microservice, without touching the agent configuration or requiring downtime. For a platform that serves 200+ clients with diverse and evolving operational needs, this dynamic capability model is a significant competitive advantage.

Deploying agents at scale

Duco implemented Amazon Bedrock and Bedrock AgentCore to power two critical workflows that previously required extensive manual effort:

1. Intelligent onboarding

Previously, onboarding new reconciliation processes was a manual, time-intensive exercise requiring significant professional services resources. Banks would take years to migrate thousands of processes, moving at a pace of roughly one per week.

With Amazon Bedrock and Bedrock AgentCore, Duco can now:

  • Automatically understand diverse file formats and data structures across legacy and modern systems.
  • Translate legacy configurations from existing systems into structured Duco processes.
  • Parse complex spreadsheet macros written decades ago that no one fully understands.
  • Deploy new reconciliations 10× faster than before.

One global bank experienced a 70% decrease in onboarding costs for new reconciliations and achieved an increase of over 20% in straight-through processing through better match rates and allocation rules.

2. AI-driven exception investigation

Financial institutions run thousands of quality gates between systems, generating countless exceptions daily. Traditionally, armies of analysts manually investigate each break to determine if it’s worth worrying about, already being investigated, or represents a new risk.

Duco’s agents now handle the “first mile” of investigation:

  • Triage new breaks as they arrive, grouping related exceptions that share a likely root cause.
  • Check context, such as whether a break is already known, already being worked, or a timing difference expected to clear.
  • Investigate by pulling evidence from source data and systems to trace the root cause of each inconsistency, whether a data quality issue, a missing or late record, a mapping or reference data problem, or a genuine mismatch, and explain why it happened.
  • Recommend a decision-ready case: the likely cause, a proposed resolution such as an adjustment, a rule change, or an escalation, the alternatives considered, and the supporting evidence.
  • Route each case to the right analyst, who reviews the evidence and makes the final call, with every decision recorded in the audit trail.

This agentic approach excels because financial workflows involve highly variable paths through information, exactly the kind of complex, context-heavy reasoning that foundation models handle well.

Operating in a regulated environment

Deploying AI agents in financial services requires more than technical capability. It demands rigorous compliance, auditability, and risk management. Duco’s implementation on Amazon Bedrock addresses these requirements through four core principles:

  • Comprehensive observability: Every agent decision is logged in a complete audit trail. Reviewers can trace each decision to check it against regulatory requirements.
  • Human-in-the-loop controls: High-risk actions require explicit authorization, with clear escalation pathways for complex scenarios that exceed agent confidence thresholds.
  • Fail-safe architecture: Systems default to client protection over operational efficiency, supporting safety even when agents encounter edge cases or unexpected data.
  • Regulatory alignment: The platform supports workloads subject to SOC 2 and DORA requirements, with data residency controls per institution.

Results that matter

Duco’s adoption of Amazon Bedrock has delivered measurable, auditable business impact across client deployments:

Faster reconciliation deployments

Reduction in onboarding costs

Increase in straight-through processing

Hours saved in manual investigation

Perhaps most importantly, Duco now has a foundation for rapid innovation. Building new agentic capabilities no longer requires extensive machine learning engineering, so the team can focus on solving business problems rather than managing infrastructure.

Roadmap: The future of human–agent collaboration

Duco’s architecture is designed not to replace workers, but to elevate them. The platform envisions a clear progression in human roles as agentic capabilities mature:

Task Worker → Investigator → Decision Maker

Rather than humans performing repetitive tasks, the future sees operations teams orchestrating multiple agents in parallel with humans making final approval decisions based on agent-prepared analysis. The architecture is designed to support agent-to-agent communication, including cross-firm scenarios where agents at different financial institutions could coordinate.

Conclusion

For regulated financial institutions, Duco’s architecture shows that agentic AI isn’t only viable. It’s already delivering at production scale. Duco rebuilt its agentic AI stack on Amazon Bedrock and Amazon Bedrock AgentCore, combining strict per-tenant isolation, the right model for each job, and an MCP skills architecture that cut context overhead by 90%. The results include reconciliation deployments 10× faster and, for one global bank, onboarding costs down 70% and straight-through processing up by over 20%. To build a similar multi-tenant setup, start with the Amazon Bedrock AgentCore Developer Guide, then read Building multi-tenant agents with Amazon Bedrock AgentCore on the AWS Machine Learning Blog. For the operating model behind this work, see Duco’s Agentic Operations: a new operating model for post-trade.

About the authors

The text above was extracted automatically from the source page and may miss images, tables or code blocks. The original is authoritative.

Published by AWS Machine Learning
This site only summarises and aggregates; copyright stays with the original author. Headlines and summaries follow the source — where they differ, the original wins.
Read the original ↗