On this tutorial, we construct a complicated workflow round Anthropic’s financial-services repository and reproduce its skill-driven structure in pure Python. We start by putting in the required libraries, cloning the repository, and programmatically mapping its brokers, vertical plugins, companion integrations, managed-agent cookbooks, and monetary evaluation expertise. We then parse the repository’s SKILL.md information right into a searchable registry and assemble a reusable SkillAgent that injects chosen monetary playbooks into the Anthropic Messages API whereas supporting an iterative tool-use loop for Python calculations and file era. Utilizing this structure, we execute an artificial discounted money circulate valuation, generate a WACC and terminal-growth sensitivity heatmap, carry out comparable-company evaluation with formatted Excel output, draft a private-equity funding committee memo, and examine a managed-agent deployment specification with out sending a reside deployment request.
import subprocess, sys, os, io, re, json, glob, textwrap, contextlib, pathlib
def sh(cmd):
print(f"$ {cmd}")
r = subprocess.run(cmd, shell=True, capture_output=True, textual content=True)
if r.returncode != 0:
print(r.stderr[-1500:])
return r
sh(f"{sys.executable} -m pip set up -q anthropic pandas openpyxl pyyaml matplotlib")
import pandas as pd
import yaml
import matplotlib.pyplot as plt
REPO_URL = "https://github.com/anthropics/financial-services.git"
REPO_DIR = "financial-services"
if not os.path.isdir(REPO_DIR):
sh(f"git clone --depth 1 {REPO_URL} {REPO_DIR}")
else:
print("Repo already cloned — skipping.")
def get_api_key():
attempt:
from google.colab import userdata
okay = userdata.get("ANTHROPIC_API_KEY")
if okay:
return okay
besides Exception:
move
if os.environ.get("ANTHROPIC_API_KEY"):
return os.environ["ANTHROPIC_API_KEY"]
from getpass import getpass
return getpass("Enter your Anthropic API key: ")
os.environ["ANTHROPIC_API_KEY"] = get_api_key()
import anthropic
shopper = anthropic.Anthropic()
MODEL = "claude-sonnet-4-6"
print("SDK prepared. Mannequin:", MODEL)
We set up the required Python libraries, clone Anthropic’s financial-services repository, and put together the Google Colab runtime for execution. We retrieve the Anthropic API key from Colab secrets and techniques, surroundings variables, or a safe interactive immediate. We then initialize the official Anthropic SDK and choose the Claude mannequin that powers the financial-analysis workflows.
def repo_map(root=REPO_DIR):
rows = []
for form, sample in [
("agent", f"{root}/plugins/agent-plugins/*"),
("vertical",f"{root}/plugins/vertical-plugins/*"),
("partner", f"{root}/plugins/partner-built/*"),
("cookbook",f"{root}/managed-agent-cookbooks/*"),
]:
for p in sorted(glob.glob(sample)):
if not os.path.isdir(p):
proceed
expertise = glob.glob(f"{p}/**/SKILL.md", recursive=True)
instructions = glob.glob(f"{p}/instructions/*.md")
rows.append({"kind": form, "title": os.path.basename(p),
"expertise": len(expertise), "instructions": len(instructions)})
return pd.DataFrame(rows)
print("n=== REPO MAP ===")
repo_df = repo_map()
print(repo_df.to_string(index=False))
mcp_files = glob.glob(f"{REPO_DIR}/plugins/**/.mcp.json", recursive=True)
for f in mcp_files[:1]:
print(f"n=== MCP CONNECTORS ({f}) ===")
attempt:
cfg = json.load(open(f))
for title, srv in cfg.get("mcpServers", cfg).gadgets():
print(f" {title:<14} -> {srv.get('url', srv)}")
besides Exception as e:
print(" (couldn't parse:", e, ")")
FRONTMATTER = re.compile(r"^---s*n(.*?)n---s*n", re.S)
class Ability:
def __init__(self, path):
self.path = path
uncooked = open(path, encoding="utf-8", errors="change").learn()
m = FRONTMATTER.match(uncooked)
meta = {}
if m:
attempt:
meta = yaml.safe_load(m.group(1)) or {}
besides Exception:
meta = {}
self.title = str(meta.get("title") or pathlib.Path(path).mother or father.title)
self.description = str(meta.get("description", ""))[:300]
self.physique = uncooked[m.end():] if m else uncooked
def __repr__(self):
return f""
class SkillRegistry:
def __init__(self, root=REPO_DIR):
paths = sorted(glob.glob(f"{root}/plugins/vertical-plugins/**/SKILL.md", recursive=True))
paths += sorted(glob.glob(f"{root}/plugins/**/SKILL.md", recursive=True))
self.expertise = {}
for p in paths:
s = Ability(p)
self.expertise.setdefault(s.title.decrease(), s)
def discover(self, question):
q = question.decrease()
hits = [s for k, s in self.skills.items() if q in k]
if not hits:
hits = [s for s in self.skills.values() if q in s.description.lower()]
return hits
def get(self, question):
hits = self.discover(question)
if not hits:
elevate KeyError(f"No ability matching '{question}'. "
f"Accessible: {sorted(self.expertise)[:40]}")
return hits[0]
registry = SkillRegistry()
print(f"nLoaded {len(registry.expertise)} distinctive expertise.")
print("Pattern:", sorted(registry.expertise)[:12], "...")
We examine the repository construction and determine its agent plugins, vertical plugins, companion integrations, managed-agent cookbooks, and accessible instructions. We find MCP configuration information and show the exterior monetary information connectors outlined within the repository. We then parse every SKILL.md file, extract its YAML metadata and methodology, and register each distinctive ability for searchable entry.
os.makedirs("outputs", exist_ok=True)
TOOLS = [
{
"name": "run_python",
"description": ("Execute Python code and return stdout. pandas as pd "
"and numpy as np are pre-imported. Use print() to "
"return results. State persists across calls."),
"input_schema": {
"type": "object",
"properties": {"code": {"type": "string"}},
"required": ["code"],
},
},
{
"title": "save_file",
"description": "Save textual content content material to outputs/.",
"input_schema": {
"kind": "object",
"properties": {"filename": {"kind": "string"},
"content material": {"kind": "string"}},
"required": ["filename", "content"],
},
},
]
_PY_NS = {}
def _tool_run_python(code):
import numpy as np
_PY_NS.setdefault("pd", pd); _PY_NS.setdefault("np", np)
buf = io.StringIO()
attempt:
with contextlib.redirect_stdout(buf):
exec(code, _PY_NS)
out = buf.getvalue()
return out[:6000] if out else "(no stdout — use print())"
besides Exception as e:
return f"ERROR: {kind(e).__name__}: {e}"
def _tool_save_file(filename, content material):
secure = os.path.basename(filename)
path = os.path.be a part of("outputs", secure)
open(path, "w", encoding="utf-8").write(content material)
return f"Saved {path} ({len(content material)} chars)"
DISPATCH = {"run_python": lambda i: _tool_run_python(i["code"]),
"save_file": lambda i: _tool_save_file(i["filename"], i["content"])}
BASE_SYSTEM = """You're a monetary analyst assistant working with the
ability playbooks supplied beneath (from Anthropic's financial-services repo).
Observe the ability's methodology, conventions, and output format carefully.
Use the run_python device for all numerical work — by no means do arithmetic in
your head. Use save_file for ultimate deliverables. All work is a DRAFT for
human assessment; don't current it as funding recommendation."""
class SkillAgent:
"""Minimal replica of Cowork's skill-firing: chosen expertise are
concatenated into the system immediate; the agent then runs an ordinary
tool-use loop in opposition to the Messages API till the mannequin stops."""
def __init__(self, skill_queries, max_skill_chars=12000, verbose=True):
self.expertise = [registry.get(q) for q in skill_queries]
blocks = []
for s in self.expertise:
blocks.append(f"nn===== SKILL: {s.title} =====n"
f"{s.description}n{s.physique[:max_skill_chars]}")
self.system = BASE_SYSTEM + "".be a part of(blocks)
self.verbose = verbose
def run(self, immediate, max_turns=12):
messages = [{"role": "user", "content": prompt}]
for flip in vary(max_turns):
resp = shopper.messages.create(
mannequin=MODEL, max_tokens=8000,
system=self.system, instruments=TOOLS, messages=messages)
messages.append({"position": "assistant", "content material": resp.content material})
if resp.stop_reason != "tool_use":
ultimate = "".be a part of(b.textual content for b in resp.content material
if b.kind == "textual content")
return ultimate, messages
outcomes = []
for block in resp.content material:
if block.kind == "tool_use":
if self.verbose:
print(f" [turn {turn}] device: {block.title}")
out = DISPATCH[block.name](block.enter)
outcomes.append({"kind": "tool_result",
"tool_use_id": block.id,
"content material": str(out)})
messages.append({"position": "person", "content material": outcomes})
return "(hit max_turns)", messages
We outline instruments that enable Claude to execute Python calculations and save generated deliverables contained in the Colab surroundings. We construct a persistent Python namespace so numerical fashions, tables, and intermediate variables stay accessible throughout a number of agent turns. We then create the SkillAgent class, inject chosen monetary playbooks into its system immediate, and handle the Anthropic Messages API tool-use loop.
SAMPLE_CO = """
Goal: 'Meridian Software program' (artificial). FY2025 actuals, $mm:
Income 850 (grew 18% y/y) | EBITDA margin 27% | D&A 4% of rev
CapEx 5% of rev | NWC change 1% of rev progress | Tax fee 24%
Internet debt 320 | Diluted shares 92mm
Assumptions: income progress fades 18% -> 6% linearly over 5 yrs,
EBITDA margin expands 100bps whole, WACC 9.5%, terminal progress 2.5%.
"""
print("n" + "="*76 + "nDEMO A — DCF (dcf-model ability)n" + "="*76)
attempt:
dcf_agent = SkillAgent(["dcf"])
dcf_answer, _ = dcf_agent.run(
"Run a 5-year unlevered DCF per the ability playbook on this firm:n"
+ SAMPLE_CO +
"nCompute enterprise worth, fairness worth, and implied share worth "
"with run_python. Then print a WACC (8.5%-10.5%, 50bp steps) x "
"terminal progress (1.5%-3.5%, 50bp steps) sensitivity grid of implied "
"share worth as a JSON object beneath the marker SENS_JSON:, and provides "
"a concise abstract.")
print("n--- DCF RESULT ---n", dcf_answer[:3000])
m = re.search(r"SENS_JSON:s*({.*})", dcf_answer, re.S)
if m:
grid = json.hundreds(m.group(1))
sens = pd.DataFrame(grid)
sens = sens.apply(pd.to_numeric, errors="coerce")
fig, ax = plt.subplots(figsize=(7, 4))
im = ax.imshow(sens.values, cmap="RdYlGn", facet="auto")
ax.set_xticks(vary(len(sens.columns)), sens.columns)
ax.set_yticks(vary(len(sens.index)), sens.index)
ax.set_xlabel("Terminal progress"); ax.set_ylabel("WACC")
ax.set_title("Implied share worth sensitivity ($)")
for i in vary(sens.form[0]):
for j in vary(sens.form[1]):
v = sens.values[i, j]
if pd.notna(v):
ax.textual content(j, i, f"{v:,.0f}", ha="heart", va="heart",
fontsize=8)
fig.colorbar(im); plt.tight_layout(); plt.present()
besides Exception as e:
print("Demo A skipped:", e)
We offer artificial working assumptions and instruct the DCF ability agent to assemble a five-year unlevered cash-flow valuation. We use the Python execution device to calculate enterprise worth, fairness worth, implied share worth, and a two-dimensional sensitivity matrix. We then extract the structured sensitivity outcomes and visualize the connection between WACC, terminal progress, and implied valuation by way of a heatmap.
PEERS = """
Artificial peer set ($mm besides per-share):
Ticker Value Shares NetDebt Rev_NTM EBITDA_NTM EPS_NTM
ALFA 64.2 210 450 2900 820 3.10
BRVO 28.7 540 -120 4100 980 1.45
CHRL 112.5 95 760 1850 610 5.60
DLTA 41.9 330 210 2600 700 2.05
"""
print("n" + "="*76 + "nDEMO B — COMPS (comps-analysis ability) -> Exceln" + "="*76)
attempt:
comps_agent = SkillAgent(["comps"])
comps_answer, _ = comps_agent.run(
"Per the comps ability, compute EV, EV/Income, EV/EBITDA and P/E "
"(all NTM) for these friends with run_python:n" + PEERS +
"nThen print the total comps desk plus min/twenty fifth/median/seventy fifth/max "
"abstract stats as JSON beneath the marker COMPS_JSON: with keys "
"'desk' (record of row dicts) and 'stats' (dict of dicts).")
print("n--- COMPS NARRATIVE ---n", comps_answer[:1500])
m = re.search(r"COMPS_JSON:s*({.*})", comps_answer, re.S)
if m:
payload = json.hundreds(m.group(1))
desk = pd.DataFrame(payload["table"])
stats = pd.DataFrame(payload["stats"])
xlsx = "outputs/comps_analysis.xlsx"
with pd.ExcelWriter(xlsx, engine="openpyxl") as xl:
desk.to_excel(xl, sheet_name="Comps", index=False)
stats.to_excel(xl, sheet_name="Abstract Stats")
from openpyxl import load_workbook
from openpyxl.types import Font, PatternFill
wb = load_workbook(xlsx)
for ws in wb.worksheets:
for cell in ws[1]:
cell.font = Font(daring=True, colour="FFFFFF")
cell.fill = PatternFill("strong", start_color="1F4E79")
for col in ws.columns:
w = max(len(str(c.worth)) for c in col if c.worth will not be None)
ws.column_dimensions[col[0].column_letter].width = w + 3
wb.save(xlsx)
print("Wrote", xlsx)
print(desk.to_string(index=False))
besides Exception as e:
print("Demo B skipped:", e)
We provide an artificial peer set and calculate enterprise worth, EV-to-revenue, EV-to-EBITDA, and price-to-earnings multiples. We convert the agent’s structured JSON response into detailed comparable-company and summary-statistics DataFrames. We then export the evaluation to a multi-sheet Excel workbook and apply skilled header formatting and computerized column sizing.
print("n" + "="*76 + "nDEMO C — IC MEMO (ic-memo ability)n" + "="*76)
attempt:
ic_agent = SkillAgent(["ic-memo"])
ic_answer, _ = ic_agent.run(
"Draft a first-round IC memo per the ability for a hypothetical "
"buyout of Meridian Software program (see information beneath). Base the valuation "
"framing on ~11x EV/EBITDA entry, 45% leverage, 5-yr maintain. Use "
"run_python for any fast math (e.g., tough MOIC/IRR math) and "
"save the memo with save_file as ic_memo_meridian.md.n" + SAMPLE_CO)
print("n--- IC MEMO (first 1500 chars of reply) ---n", ic_answer[:1500])
memo_path = "outputs/ic_memo_meridian.md"
if os.path.exists(memo_path):
print(f"nMemo saved -> {memo_path} "
f"({os.path.getsize(memo_path)} bytes)")
besides Exception as e:
print("Demo C skipped:", e)
print("n" + "="*76 + "nPART 7 — MANAGED AGENT COOKBOOK (dry run)n" + "="*76)
yamls = sorted(glob.glob(f"{REPO_DIR}/managed-agent-cookbooks/*/agent.yaml"))
+ sorted(glob.glob(f"{REPO_DIR}/managed-agent-cookbooks/*/*.yaml"))
if yamls:
path = yamls[0]
print("Inspecting:", path)
attempt:
spec = yaml.safe_load(open(path))
print(json.dumps(spec, indent=2, default=str)[:2500])
print("nDeploy circulate: resolve file refs -> add expertise -> create "
"leaf-worker subagents -> POST orchestrator to /v1/brokers "
"(see scripts/orchestrate.py for the handoff_request occasion loop).")
besides Exception as e:
print("Couldn't parse yaml:", e)
else:
print("No cookbook yaml discovered on this department — see "
"managed-agent-cookbooks/ READMEs on GitHub.")
print("n" + "="*76)
print("DONE. Artifacts in ./outputs/:", os.listdir("outputs"))
print("""
The place to go subsequent:
* Swap SAMPLE_CO / PEERS for actual information by way of the repo's MCP connectors
(Daloopa, FactSet, S&P, Morningstar, PitchBook...) — subscriptions apply.
* Load different expertise: SkillAgent(["lbo"]), ["merger"], ["earnings"],
["rebalance"], ["tlh"], ["kyc"] ... — see `sorted(registry.expertise)`.
* Stack expertise: SkillAgent(["comps", "dcf"]) for a football-field workflow.
* For manufacturing, set up as a Cowork plugin or deploy by way of Managed Brokers
as an alternative of this Colab loop — identical expertise, ruled runtime.
All outputs are drafts for certified human assessment — not funding recommendation.
""")
We apply the investment-committee memo ability to a hypothetical software program buyout and calculate supporting return metrics with Python. We save the ensuing memo as a Markdown deliverable and confirm that the generated file exists within the output listing. We then examine a managed-agent cookbook, show the deployment specification, and conclude by reviewing the generated artifacts and doable manufacturing extensions.
By finishing this tutorial, we implement a sensible Colab-based approximation of Anthropic’s financial-services ability and agent framework whereas preserving the repository’s methodology-driven method to monetary evaluation. We mix structured ability discovery, dynamic system-prompt building, persistent Python execution, API-based device orchestration, and automatic deliverable era in a single reusable workflow. We additionally display how the identical agent structure helps a number of finance use circumstances, together with DCF valuation, trading-comps evaluation, sensitivity testing, Excel reporting, and funding committee memo preparation. From right here, we lengthen the system by loading extra expertise, combining a number of valuation playbooks, connecting to licensed monetary information suppliers by way of MCP integrations, and changing the tutorial sandbox with a ruled manufacturing runtime in Claude Code, Cowork, or Managed Brokers.
Try the Full Code right here. Additionally, be happy to comply with us on Twitter and don’t neglect to hitch our 150k+ML SubReddit and Subscribe to our Publication. Wait! are you on telegram? now you possibly can be a part of us on telegram as effectively.
Have to companion with us for selling your GitHub Repo OR Hugging Face Web page OR Product Launch OR Webinar and many others.? Join with us
Sana Hassan, a consulting intern at Marktechpost and dual-degree pupil at IIT Madras, is keen about making use of expertise and AI to deal with real-world challenges. With a eager curiosity in fixing sensible issues, he brings a recent perspective to the intersection of AI and real-life options.
