ZICQ
中 Log in / Sign up
Newsroom Agentic #Amazon Bedrock AgentCore #Model Context Protocol #Tenant Isolation #On-Demand Skill Loading #Financial Agents

Duco Cuts Financial-Agent Context by 90% with On-Demand MCP Skills

Avatar of Mr.Xu

By Mr.Xu Compiled & Reviewed by Editorial

Published:

中文阅读 (Chinese) English Version
Co-reading Select any sentence in the article to highlight, annotate, or copy a quote card. Join discussion ↓

Summary:Financial data-automation provider Duco has rebuilt its agent stack on Amazon Bedrock and Amazon Bedrock AgentCore, combining dedicated per-tenant runtimes and gateways with identity, network, and data isolation. Its most consequential engineering change is an MCP skills architecture that replaces hundreds of statically injected tool schemas with three meta-tools for on-demand discovery and invocation, reducing the main context from roughly 200,000 tokens to 20,000. Duco reports 10× faster reco


Core Architecture: From Model Calls to a Governed Agent Runtime

Duco did not train a new foundation model for financial operations. It uses Amazon Bedrock as a unified API for managed model access and Amazon Bedrock AgentCore for runtime infrastructure, inbound authorization, tool gateways, tracing, and evaluation. Most of its existing LangChain and LangGraph code remains usable. The substantive changes are how tools are exposed, how tenant boundaries are enforced, and how work is routed across models.

A typical request follows this path:

user request → tenant Cognito/JWT → tenant AgentCore Runtime → tenant AgentCore Gateway → containerized MCP server → internal banking systems

This design separates agent logic from identity, networking, audit, and runtime operations. High-risk actions remain behind human approval: models collect evidence, explain anomalies, and prepare recommendations, but do not receive final authority over financial decisions.

Tenant Isolation Across Data, Identity, and Runtime Layers

Duco does not rely on a tenant ID embedded in a prompt. Isolation is enforced throughout the stack:

  • Infrastructure: Each tenant receives an EKS namespace and network isolation. Aurora MySQL, S3, KMS keys, SQS, SES, ElastiCache, and a Cognito user pool are dedicated per tenant. Duco says no data infrastructure is shared across clients.
  • Identity: Requests carry JWTs issued by the tenant's Cognito pool and validated by the AgentCore Runtime inbound authorizer. The Gateway propagates user identity, and each containerized MCP server verifies both the user and the agent before acting.
  • Networking: Tenants share a VPC and EKS cluster but remain separated by namespaces, network policies, security groups, and private endpoints. AgentCore runtimes use VPC network mode with interfaces in private subnets.
  • Agents: Every tenant has a dedicated Runtime and Gateway. AgentCore session isolation prevents shared memory, context, or tooling, while each tenant maintains its own MCP server set.

The design gives up some economies of scale in exchange for cleaner authorization boundaries and fault isolation. In payments and reconciliation, a cross-tenant isolation failure can be more expensive than duplicated infrastructure.

Model Routing: Separating Reasoning, Latency, and Cost

Duco assigns different model families to different roles rather than using one model for every task:

| Model | Primary role | Typical workload | |---|---|---| | Anthropic Claude Opus | Planning agent | Complex reasoning and upfront decomposition | | Anthropic Claude Sonnet | Main reasoning and decisions | Exception investigation, reconciliation logic, rule interpretation | | Anthropic Claude Haiku | Lightweight routing | Fast classification, tool selection, first-pass triage | | Amazon Nova 2 Pro | Tool-output summarization | Condensing MCP responses and producing analyst-readable summaries |

The model can be changed through configuration, reducing the need to rewrite the application layer. Multi-model routing is not automatically superior, however. Models differ in tool-call formatting, instruction adherence, refusal behavior, and reasoning stability. Production deployments therefore need a common output contract and regression testing whenever a model is swapped.

On-Demand MCP Skills: Moving 200K Tokens Out of the Resident Context

Each Duco tenant exposes 300–400 tools through AgentCore Gateway, backed by different MCP servers. Before the redesign, roughly 200,000 tokens of tool descriptions entered the context before work began. As the tool count grew, the model spent more prefill compute and had to distinguish among many similar JSON Schemas, function descriptions, and business rules, increasing the risk of selecting the wrong tool or losing the original reasoning goal.

Duco reorganized this information into three MCP resource types:

  • skill:// for on-demand skill and tool descriptions;
  • system:// for system-prompt sections composed at runtime;
  • ui:// for UI resources isolated from operational tools.

The agent harness exposes only three meta-tools: load_skill to retrieve a skill description, find_tool to locate a relevant tool and its schema, and invoke_tool to execute the selected tool. At boot time, the harness builds a registry from the Gateway but exposes only tool names to the model. Detailed schemas are retrieved on demand.

Before the change, context cost can be approximated as:

C_before ≈ P + ΣS_i + O ≈ 200K tokens

where P is the base prompt, S_i represents all tool schemas, and O contains task state and conversation history. After the change:

C_after ≈ P + M + Σ(S_s, selected skills) + O ≈ 20K tokens

M contains the three meta-tool definitions, while only the required skill subset is loaded. Under a standard full-attention approximation, prefill compute grows roughly quadratically with sequence length and KV-cache use grows roughly linearly. Shortening the resident context therefore has real computational value. It does not, however, imply a 10× reduction in end-to-end latency: output generation, tool round trips, network delay, and skill loading remain in the critical path.

The architecture also preserves prompt caching. The base system prompt and three meta-tools form a stable prefix, while skills are added to the conversation on demand rather than continuously rewriting the static tool list. Loaded skills still remain in long-running conversations, so summarization, trimming, or session segmentation is still necessary.

Dynamic Tool Discovery and Production Workflows

MCP servers are registered as Gateway targets during deployment. At boot, the agent receives a registry containing tool names; after a new service is deployed, it can locate and invoke it without redeploying or reconfiguring the agent. Tool expansion becomes a versioned service-registration process rather than a prompt-engineering exercise.

Duco applies the architecture to two principal workflows:

  1. Intelligent onboarding: The agent recognizes legacy file formats, translates old configurations into structured reconciliation processes, and parses historical spreadsheet macros. Duco reports 10× faster deployment of new reconciliation workflows.
  2. Exception investigation: The agent triages breaks, groups likely root causes, checks existing cases and timing windows, retrieves source-system evidence, distinguishes data-quality issues from true mismatches, and proposes adjustments, rule changes, or escalation. The result is routed to an analyst for final review.

The model handles the first mile of investigation, while people retain final authority. Decisions, supporting evidence, and approvals can be written to an audit trail, matching the human-in-the-loop constraints of regulated financial operations.

Engineering Trade-offs

| Benefit | New risk | Recommended control | |---|---|---| | 90% reduction in resident context | Skill discovery and invocation add model turns | Cache the catalog, retrieve schemas in parallel, and measure stage latency | | Capabilities can be added dynamically | The registry may become stale or contain ambiguous names | Use stable namespaces, versions, checksums, and boot-time synchronization | | Tool responses become more compact | Truncation may remove critical fields | Use structured summaries, evidence references, pagination, and raw-record lookup | | Dedicated tenant runtime and data layer | Higher resource cost and operational complexity | Scale resources by tenant load without weakening logical isolation | | Role-based model routing | Inconsistent behavior and a wider regression surface | Enforce output contracts and run the same task suite before upgrades | | Managed AgentCore infrastructure | Cloud control-plane dependency | Keep tool protocols and business rules portable; verify regional and compliance availability |

Reported Results and Evaluation Boundaries

Duco says its platform processes 20 billion transactions per month for more than 200 clients. It reports that the skills architecture reduced the main context from about 200,000 tokens to about 20,000 while using the same models, tools, and tasks, preserving prompt caching and improving response quality. The company also reports 10× faster reconciliation deployment, 70% lower onboarding costs for one global bank, more than a 20% increase in straight-through processing, and thousands of hours saved in manual investigation.

These figures do not yet constitute a complete independent benchmark. Scale indicates operational capacity, not agent accuracy, while the cost and processing figures come primarily from one customer deployment. The article does not disclose:

  • The fixed task set, sample size, model versions, or prompt configuration used before and after the change;
  • Tool-selection accuracy, task success, evidence-grounding accuracy, or human rework rates;
  • Time to first token, end-to-end p95/p99 latency, tool-call counts, or recovery time;
  • Total tokens after skill loading, cache-hit rate, inference spend per task, and infrastructure cost;
  • Negative cross-tenant authorization tests, audit completeness, or result consistency against legacy systems.

A stronger evaluation would use an A/B design with fixed models and tasks, measure total request context rather than only the resident prefix, and report business outcomes, cost, and tail latency separately. Isolation should also be verified through negative tests covering identity, Gateway routing, resource access, and network egress.

Deployment Guidance for Developers

  1. Group tools by business capability: Do not expose every API method as an independent tool. Define stable skill boundaries around reconciliation, investigation, and rule-management workflows.
  2. Separate static and dynamic context: Keep system prompts, base rules, and meta-tools in a stable prefix; load skill descriptions, tool schemas, and detailed records on demand.
  3. Preserve a strong identity chain: Validate JWTs at the Runtime ingress, propagate user identity through the Gateway, and require MCP servers and downstream services to authorize independently.
  4. Version the tool registry: Synchronize the Gateway and agent registry during deployment, handling schema changes, tool retirement, name conflicts, and rollback.
  5. Use tiered model routing: Let lower-cost models classify and route, use the main reasoning model for exceptions, reserve expensive models for complex planning, and compress tool output with a summarization model.
  6. Make evaluation a release gate: Track tool-selection accuracy, end-to-end success, total tokens, p95 latency, human-escalation rate, and cost per task together.
  7. Retain human decision gates: Fund movements, rule publication, and customer reporting should require explicit authorization, audit records, and rollback paths.
  8. Migrate incrementally: Begin with replayable workflows that have diverse formats but stable rules, establish a baseline, and then expand toward higher-risk operations.

Source: AWS Machine Learning Blog (2026-11-16)

— END —

Tags: #Amazon Bedrock AgentCore #Model Context Protocol #Tenant Isolation #On-Demand Skill Loading #Financial Agents

Editorial & Fact-Checking Note: This article is compiled from primary research, official release documentation, and source papers by the ZICQ Newsroom pipeline with automated entity verification and human editorial review. If you notice any technical inaccuracy, please submit a correction via our corrections policy or email our editorial desk directly.

What's your take on this story?
🚀 Explore & Submit Works

Community Comments

Loading live comments and annotations…