Claude in Financial Services: The Agent Architecture

Banks, insurers, and fintechs all reach the same wall when they try to ship a Claude-powered agent: a working demo is easy, but a system that survives an audit, a 2 a.m. incident, and a regulator's question is not. The gap is almost never the model. It is the architecture around the model — the boundaries, the data paths, the controls, and the way state moves through the system. This post walks the full anatomy of a production Claude agent for financial services, from the moment a request lands to the moment a decision is logged.

Throughout, I'll treat the model as one component among many. Opus 4.8 or Sonnet 4.6 is the reasoning core, but the parts that determine whether you pass a SOC 2 audit or a model-risk review live in the layers you build around it.

Why a financial-services agent needs more than a chat loop

A consumer chatbot can get away with a single request-response loop. A financial agent cannot, because every action it takes has a counterparty, a ledger entry, and a compliance obligation behind it. When a customer asks "move my emergency fund into the high-yield account," the agent is not generating text — it is potentially initiating a transfer, checking limits, screening for fraud, and creating an audit record. The architecture has to make each of those steps explicit, reversible where possible, and observable always.

The other pressure is data sensitivity. The agent will touch account numbers, balances, transaction history, and sometimes PII that falls under GLBA, PCI-DSS, or regional rules like GDPR. That means the architecture has to control exactly what data enters the model's context, where it is logged, and how long it lives. You cannot bolt this on later; it shapes how you design the tool layer and the context-assembly layer from day one.

The layered architecture, end to end

I think of a production Claude agent as five layers stacked between the user and your systems of record. The ingress layer authenticates the caller and resolves identity. The policy layer decides what this caller is allowed to do and which tools are even visible. The orchestration layer runs the Claude agent loop and decides when to call tools. The tool layer — implemented as MCP servers — exposes capabilities like "get balance" or "initiate transfer" with strict schemas. The systems-of-record layer is your core banking platform, card processor, or policy-admin system, which the tools wrap but never expose directly.

flowchart TD
  A["Customer request"] --> B["Ingress: authN & identity resolve"]
  B --> C{"Policy: allowed action?"}
  C -->|No| D["Refuse & log decline"]
  C -->|Yes| E["Orchestrator: Claude agent loop"]
  E --> F["MCP tool layer (scoped schemas)"]
  F --> G["Systems of record: core banking, ledger"]
  G --> H["Structured result back to Claude"]
  H --> I["Compose answer & write audit log"]

The arrows that matter most are the ones into and out of the policy layer. By making policy a hard gate before the orchestrator, you ensure the model can never reason its way into an action the caller is not entitled to take. The model never sees a transfer tool if the policy layer hasn't already authorized transfers for this session. This is the single most important architectural decision: capability is granted by code, not earned by clever prompting.

Context assembly: the most underrated component

Between the orchestrator and the model sits a context-assembly step that decides exactly what goes into Claude's window on each turn. For a financial agent this is where you enforce data minimization. Rather than dumping a full account record into context, the assembler pulls only the fields the current task needs — a masked account number, a balance band, a recent-transaction summary — and leaves raw PANs and full SSNs out entirely.

This layer also injects the durable instructions: the system prompt describing the agent's role, the regulatory guardrails it must respect, and the tool-use conventions. Because Claude Code and the Agent SDK support large context windows, the temptation is to stuff everything in. Resist it. A tighter context is cheaper, faster, and dramatically easier to reason about during an incident review, because you can point to exactly what the model saw when it made a decision.

Memory, state, and the audit trail

Financial agents need two kinds of memory, and conflating them is a common mistake. Working state is the within-session scratchpad — what the customer asked, which tools have run, what's still pending. Durable memory is the cross-session record — preferences, prior interactions, open cases. The architecture should keep working state in the orchestrator and durable memory in a governed store with its own retention and access controls, never silently accumulating sensitive data in a vector database nobody is auditing.

The audit trail is not optional and it is not the same as your application logs. For every consequential action, you want an immutable record that captures the caller identity, the policy decision, the exact tool call and its arguments, the system-of-record response, and the model's rendered explanation. When a regulator or a model-risk officer asks "why did the agent do this," you reconstruct the decision from this trail, not from a transcript that may have been truncated.

Where the controls live

Guardrails in a financial agent are layered, not singular. At the ingress, you authenticate. At the policy gate, you enforce entitlements and transaction limits. Inside the tool layer, each MCP tool validates its own inputs and enforces idempotency so a retried transfer doesn't double-execute. Around the model, you run content and prompt-injection screening on untrusted inputs like inbound emails or uploaded documents. And after the model, a verification step can require human approval for actions above a threshold — a classic human-in-the-loop checkpoint for high-dollar or high-risk operations.

The reason to spread controls across layers is defense in depth. If the model is jailbroken by a malicious document, the policy gate and the tool-layer validation still hold. If a tool has a bug, the limit checks at the policy layer catch the anomaly. No single layer is trusted to be perfect, which is exactly the posture financial regulators expect.

Model selection inside the architecture

One architecture can host different Claude models for different jobs. A common pattern routes high-stakes reasoning — a complex underwriting question, a dispute adjudication — to Opus 4.8, while high-volume, lower-complexity steps like classifying an inbound message or extracting fields from a statement go to Sonnet 4.6 or Haiku 4.5. The orchestration layer makes that routing decision based on the task, keeping latency and cost in check without compromising the hard cases. Crucially, the surrounding controls stay identical regardless of which model runs; the architecture, not the model, is the source of trust.

Frequently asked questions

What is an agent architecture in financial services?

An agent architecture in financial services is the layered system — ingress, policy, orchestration, tools, and systems of record — that lets an AI model like Claude take authenticated, authorized, and auditable actions on financial data and accounts. The model reasons; the architecture enforces who can do what, logs every decision, and keeps sensitive data out of places it shouldn't go.

Why not let the model call the core banking system directly?

Because direct access removes every control you need. By routing all capability through an MCP tool layer with strict schemas and idempotency, you constrain what's possible, validate inputs, and create a clean audit boundary. The model never holds raw credentials or unbounded access to a ledger.

How do you keep sensitive data out of the model's context?

A context-assembly layer selects only the minimal fields each task needs and masks identifiers like account and card numbers before they reach Claude. Raw PII stays in governed systems; the model sees summaries, bands, and masked tokens, which also reduces log exposure and audit scope.

Which Claude model should run the agent?

Route by task. Use Opus 4.8 for complex, high-stakes reasoning and Sonnet 4.6 or Haiku 4.5 for high-volume classification and extraction. The orchestration layer chooses per step, and the surrounding controls remain identical regardless of which model handles the turn.

Bringing these patterns to your phone lines

CallSphere takes the same layered, audited, tool-driven approach and applies it to voice and chat — agents that answer every call, pull live account context mid-conversation, and act safely on it around the clock. See how it works at callsphere.ai.

Source & attribution: This is an independent, original explainer inspired by Anthropic's coverage on the Claude blog. Claude, Claude Code, Claude Cowork, Claude Opus, and the Model Context Protocol are products and trademarks of Anthropic. CallSphere is not affiliated with or endorsed by Anthropic.