Anthropic just open-sourced a collection of financial agents (28,540 stars, trending #14 in Python) that expose a fundamental architectural choice: the same agent definition runs in two deployment modes. You can install it as a Cowork plugin, where orchestration runs client-side in Claude’s UI, or deploy it as a Managed Agent API template, where orchestration runs server-side behind your own workflow engine. Same system prompt, same skills, different runtime boundaries.
This dual-deployment model matters because financial compliance demands audit trails, human sign-off, and non-repudiation. The choice between client-side and server-side orchestration changes who owns state, where errors surface, and how you version skills when regulators ask for a paper trail.
What Ships in the Repo
The repo includes named agents for investment banking, equity research, private equity, and wealth management:
- Pitch Agent: Comps, precedents, LBO models into a branded pitch deck
- Market Researcher: Sector or theme into industry overview, competitive landscape, peer comps
- Earnings Reviewer: Earnings call plus filings into model update and note draft
- GL Reconciler: General ledger reconciliation workflows
- Meeting Prep Agent: Briefing pack before client meetings
Each agent bundles skills (comps, DCF, earnings analysis) and data connectors. You can install the full agent or just the vertical plugins, which are the underlying skills, slash commands, and data connectors bundled by financial vertical. Install these standalone if you just want /comps, /dcf, /earnings and the connectors without a full agent.
The disclaimer is explicit: “Nothing in this repository constitutes investment, legal, tax, or accounting advice. These agents draft analyst work product for review by a qualified professional. They do not make investment recommendations, execute transactions, bind risk, post to a ledger, or approve onboarding; every output is staged for human sign-off.”
Dual-Deployment Architecture
The same agent definition runs in two contexts:
Cowork Plugin (Client-Side Orchestration)
- Orchestration runs inside Claude’s UI
- User sees the agent’s reasoning, tool calls, and intermediate outputs in real time
- Human sign-off happens in the UI before outputs leave the session
- Audit trail is the Cowork conversation history
Managed Agent API (Server-Side Orchestration)
- Orchestration runs behind your workflow engine via
/v1/agents - You call the API with a task, the agent executes, you get structured output
- State lives in your backend (database, queue, event log)
- Human sign-off is a callback, review queue, or compliance hook you implement
- Audit trail is your event log, not Claude’s session history
The system prompt and skills are identical. The deployment choice determines where orchestration runs and who owns the state.
What Changes When Orchestration Moves
| Concern | Cowork Plugin | Managed Agent API |
|---|---|---|
| Orchestration | Claude UI drives the loop | Your workflow engine drives the loop |
| State | Cowork session | Your database or queue |
| Error handling | User sees errors in chat, retries manually | Your code catches errors, retries programmatically |
| Human sign-off | UI button before output leaves session | Callback or queue you implement |
| Audit trail | Cowork conversation history | Your event log (Kafka, Postgres, S3) |
| Versioning | Plugin updates when you pull new version | You control when to pull new agent template |
| Compliance hooks | Limited to Cowork’s built-in controls | You add custom hooks (approval workflows, risk checks) |
The Cowork plugin is faster to deploy but gives you less control. The Managed Agent API requires more plumbing but lets you insert compliance hooks, custom error handling, and persistent state.
How Skills Are Shared
Skills are the underlying tools that agents call. The repo ships vertical plugins that bundle skills by financial vertical:
- Investment banking: comps, precedents, LBO
- Equity research: earnings analysis, model updates
- Private equity: deal sourcing, due diligence
- Wealth management: portfolio analysis, client briefings
When you install a Cowork plugin, it bundles the skills it needs. When you deploy a Managed Agent via API, you reference the same skill modules in your backend. The skill code is identical. The difference is whether Claude calls the skill directly (Cowork) or your workflow engine calls it on Claude’s behalf (Managed Agent API).
Staged for Human Sign-Off
The disclaimer says “every output is staged for human sign-off.” The repo does not specify the exact implementation of this staging mechanism in either deployment mode. The architectural implication is clear: outputs do not move downstream (to a client, to a ledger, to a trading system) without explicit human approval.
In a Cowork deployment, this likely means the user reviews output in the UI before exporting or sharing. In a Managed Agent API deployment, you implement the review queue and approval workflow in your own code. The compliance requirement is the same. The implementation is your responsibility.
Managed Agents API Integration
The repo includes Managed Agent cookbooks that show how to deploy agents via the /v1/agents endpoint. The actual API signature and parameters are documented in the Claude Managed Agents API documentation. The key architectural point: you call the API with a task, the agent executes server-side, and you receive structured output. Your workflow engine handles state persistence, error recovery, and human review loops.
The repo provides templates, not a turnkey service. You will need to add:
- Error handling and retry logic
- Review queue implementation
- Event logging for audit trails
- Approval workflow integration
- Rate limiting and monitoring
Versioning and Skill Updates
When Anthropic updates a skill (fixes a bug in the DCF model, adds a new data connector), you control when to pull the update. Both Cowork plugins and Managed Agent templates are versioned in the GitHub repo. You decide when to upgrade.
For Cowork plugins, you pull the new version and reinstall. For Managed Agent API deployments, you pull the new template and deploy it to your backend. You can test the new version in staging before production. You can pin to a specific version if compliance requires it.
The trade-off is velocity versus control. Cowork is faster to install. Managed Agent API gives you control over rollout timing and version pinning.
Compliance and Audit Trails
Financial regulators care about three things:
- Non-repudiation: Can you prove who approved what and when?
- Auditability: Can you reconstruct the agent’s reasoning six months later?
- Human oversight: Did a qualified professional review the output before it moved downstream?
Cowork Plugin: The audit trail is the Cowork conversation history. You can export it, but it’s not structured. Non-repudiation depends on Cowork’s session logging. Human oversight is the user’s decision to export.
Managed Agent API: The audit trail is your event log. You write structured events (agent started, tool called, output generated, human approved) to Postgres, Kafka, or S3. Non-repudiation is a database row with a timestamp and user ID. Human oversight is a state transition you enforce in code.
If your firm is subject to SEC, FINRA, or FCA rules, the Managed Agent API gives you the control you need to satisfy auditors.
When to Use Each Deployment Mode
| Use Cowork Plugin If | Use Managed Agent API If |
|---|---|
| You want fast iteration and don’t need custom compliance hooks | You need custom approval workflows, risk checks, or audit logging |
| Your firm allows analyst tools to run in third-party UIs | Your firm requires all orchestration to run behind your firewall |
| You can accept the versioning and update cadence of pulling from GitHub | You need to pin versions or control rollout timing |
| Your audit trail can be conversation history | Your audit trail must be structured events in your database |
| Human sign-off is a UI action | Human sign-off is a state transition in your workflow engine |
Technical Verdict
The dual-deployment model is a reference architecture, not a production service. It lets you start fast with Cowork and migrate to Managed Agent API when compliance demands it. The system prompt and skills are identical, so you’re not rewriting logic when you move orchestration server-side.
Use Cowork plugins if you’re an analyst or small team that wants to try agentic workflows without building infrastructure. The sign-off is manual, the audit trail is conversation history, and you control versioning by pulling updates from the repo.
Use Managed Agent API if you’re a regulated firm that needs custom compliance hooks, persistent state, and structured audit logs. You’ll write more plumbing (review queues, event logs, approval workflows), but you’ll own the runtime and satisfy auditors.
The repo provides templates and cookbooks. You’ll need to add error handling, retry logic, rate limiting, and monitoring. But the dual-deployment pattern is the right abstraction: same agent, two runtime boundaries, explicit trade-offs.