Building Financial AI Agents with Claude: Anthropic's Dual-Deployment Architecture

Hook

Most AI agent frameworks force you to choose between interactive chat interfaces and headless API automation. Anthropic's financial-services repository proves you can have both from a single codebase—no build step required.

Context

Financial services firms face a peculiar AI deployment challenge. Investment bankers need interactive AI assistants in collaborative workspaces to draft pitch books and analyze deals. Meanwhile, back-office operations require headless agents running on schedules to reconcile general ledgers and review earnings reports. Traditionally, these use cases demanded separate codebases: one for chat-style interfaces, another for API-driven automation.

Anthropics/financial-services tackles this with a dual-deployment architecture where the same agent definitions work in both Claude Cowork (Anthropic's collaborative workspace) and the Claude Managed Agents API. Rather than providing another generic chatbot framework, it ships concrete agents for real financial workflows—pitch deck generation, GL reconciliation, earnings analysis—with domain expertise encoded as reusable "skills." The repository represents Anthropic's thesis that enterprise AI adoption requires workflow-specific agents, not general-purpose assistants, and that financial institutions won't tolerate maintaining parallel codebases for interactive versus automated deployments.

Technical Insight

The architecture rests on three layers: skills, agents, and connectivity. Skills are markdown files encoding domain expertise—how to analyze credit metrics, structure M&A pitches, or review financial statements. Agents are JSON manifests that bundle skills with instructions for specific workflows. The Model Context Protocol (MCP) provides standardized data connectivity to Bloomberg terminals, LSEG platforms, and document stores.

Here's what an agent manifest looks like:

{
  "name": "Pitch Agent",
  "description": "Investment banking pitch book assistant",
  "instructions": "You are an expert investment banker helping create pitch materials. Use comparable company analysis and precedent transactions to support recommendations.",
  "skills": [
    "vertical_plugins/investment_banking/comps_analysis",
    "vertical_plugins/investment_banking/precedent_transactions",
    "vertical_plugins/investment_banking/pitch_structure"
  ],
  "mcp_servers": ["bloomberg_terminal", "document_store"]
}

The brilliance is in the file-based approach. No compilation, no bundling—just markdown and JSON. Deploy to Cowork by uploading through the UI. Deploy as a headless agent by pointing the Managed Agents API at the same files. Change a skill once, and it propagates to every agent that references it.

Skills use a specific markdown structure with decision trees and examples:

# Comparable Company Analysis

## When to Use
- Valuing a private company for M&A
- Setting IPO price ranges
- Assessing acquisition premiums

## Methodology
1. Identify peer set (same industry, similar size, geography)
2. Calculate key multiples (EV/EBITDA, P/E, EV/Sales)
3. Apply median multiples to target's metrics
4. Triangulate with DCF and precedent transactions

## Common Pitfalls
- Including distressed companies in peer set
- Using stale financials (>90 days old)
- Ignoring growth rate differences

The MCP integration deserves attention. Rather than hardcoding API calls to Bloomberg or FactSet, agents reference MCP server names. The MCP server handles authentication, rate limiting, and response normalization:

# Example MCP server for Bloomberg Terminal
from mcp import Server, Tool

server = Server("bloomberg_terminal")

@server.tool()
async def get_company_fundamentals(ticker: str) -> dict:
    """Fetch financial metrics for a company"""
    # Bloomberg API integration
    response = await bloomberg_client.get_fundamentals(
        ticker=ticker,
        fields=["SALES", "EBITDA", "NET_INCOME", "TOTAL_DEBT"]
    )
    return normalize_response(response)

The research preview feature for subagent delegation enables multi-agent workflows. A parent agent can delegate tasks to specialist agents and aggregate results. The Pitch Agent might delegate competitive analysis to an Equity Research agent while simultaneously asking a Data Extraction agent to pull financials from PDFs. Handoff is explicit—the parent agent calls a delegation tool with the subagent name and task description.

What makes this architecture work is the constraint to financial services. Generic agent frameworks drown in abstraction trying to support every domain. By targeting investment banking, private equity, and wealth management specifically, the repository can ship opinionated skills and agents that actually solve real problems. The GL Reconciler agent knows accounting standards. The Earnings Reviewer understands GAAP vs. non-GAAP metrics. This specificity is what makes it useful out-of-the-box rather than another framework requiring months of customization.

Gotcha

The disclaimers in this repository are aggressive for a reason: financial AI is a regulatory minefield. The README explicitly states it provides no investment, legal, or tax advice. Agent outputs require human review by qualified professionals. If you're imagining autonomous agents executing trades or filing SEC documents, stop—that's not what this enables and likely violates regulations. The compliance burden falls entirely on you, and no amount of prompt engineering changes that.

Practical limitations are equally significant. You need Claude enterprise products (Cowork and Managed Agents API), which aren't available to individual developers or small firms. The MCP servers reference premium data terminals—Bloomberg costs $24,000+ per user annually, FactSet similarly expensive. You can't run the provided agents meaningfully without these data sources. The subagent delegation is marked as research preview, meaning the orchestration layer will change and potentially break your workflows. For production use, you're essentially beta testing Anthropic's multi-agent features while handling your own financial regulatory compliance. Finally, the repository covers investment banking, equity research, private equity, and wealth management—if your workflow is trading algorithms, risk management, or retail banking, the provided agents and skills don't apply.

Verdict

Use if: You're at a financial institution with existing Claude enterprise licensing, access to Bloomberg/FactSet/S&P Global terminals, and workflows matching the provided agents (pitch generation, GL reconciliation, earnings analysis, diligence reviews). The dual-deployment model eliminates maintaining separate codebases for interactive and automated use cases, and the skill reuse across agents is genuinely elegant. If you're building multiple financial AI workflows, the architectural patterns here—skills as markdown, MCP for data connectivity, file-based deployment—provide a solid foundation worth adopting. Skip if: You're an individual practitioner, lack enterprise Claude access, work in uncovered financial domains (trading, risk, retail banking), or need production-grade multi-agent orchestration today. Also skip if you expect plug-and-play functionality without data terminal subscriptions or human oversight. The regulatory compliance responsibility is yours alone, and the repository makes no attempt to abstract that away—appropriately, but it means you need legal and compliance teams involved before deploying anything.