Performance Metrics logo

Performance Metrics

Community
JoelLewis
performance-metrics

Evaluate investment performance on a risk-adjusted basis using industry-standard ratios and capture analysis. Use when the user asks about Sharpe ratio, Sortino ratio, Information Ratio, Treynor ratio, Calmar ratio, Omega ratio, or upside/downside capture. Also trigger when users mention 'risk-adjusted returns', 'return per unit of risk', 'M-squared', 'is this fund worth the volatility', 'how to compare two managers', 'capture ratio', or ask which investment performed better after accounting for risk.

Overview

PublisherJoelLewis
Repositoryfinance_skills
Skill nameperformance-metrics
Stars
217
Forks
37
Bundled files
1
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 1 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by JoelLewis on GitHub. Read the source before you install it.

Installation

Install the Performance Metrics AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/JoelLewis/finance_skills/tree/main/plugins/wealth-management/skills/performance-metrics
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/JoelLewis/finance_skills.git /tmp/finance_skills
mkdir -p .claude/skills
cp -r /tmp/finance_skills/plugins/wealth-management/skills/performance-metrics .claude/skills/performance-metrics
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Performance Metrics in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Performance Metrics on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Performance Metrics is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Performance Metrics

Core Concepts

Sharpe Ratio

The most widely used risk-adjusted performance measure. It divides excess return (over the risk-free rate) by total volatility.

SR = (R_p - R_f) / sigma_p
  • R_p: annualized portfolio return
  • R_f: annualized risk-free rate
  • sigma_p: annualized portfolio volatility (standard deviation of returns)

A higher Sharpe ratio indicates more return per unit of total risk. Typical benchmarks: SR < 0.5 is poor, 0.5-1.0 is acceptable, > 1.0 is strong, > 2.0 is exceptional.

Annualization: If computed from monthly data, SR_annual = SR_monthly * sqrt(12).

Sortino Ratio

Replaces total volatility with downside deviation, penalizing only harmful volatility (returns below a Minimum Acceptable Return).

Sortino = (R_p - R_f) / sigma_downside

where sigma_downside = sqrt((1/n) * sum(min(R_i - MAR, 0)^2)).

Common MAR choices: 0%, risk-free rate, or a target return. Always state which MAR is used, and use the same reference point in the numerator as in the downside deviation: if the MAR is not the risk-free rate, the numerator should be (R_p - MAR), not (R_p - R_f). Mixing reference points makes the ratio internally inconsistent.

Information Ratio

Measures active return (alpha) per unit of active risk (tracking error) relative to a benchmark.

IR = (R_p - R_b) / TE

where TE = std(R_p - R_b) * sqrt(N).

An IR above 0.5 is generally considered good; above 1.0 is exceptional and difficult to sustain.

Treynor Ratio

Measures excess return per unit of systematic risk (beta) rather than total risk.

Treynor = (R_p - R_f) / beta_p

Useful for evaluating diversified portfolios where idiosyncratic risk has been diversified away. For undiversified holdings, the Sharpe ratio is more appropriate.

Calmar Ratio

Relates annualized return to the worst peak-to-trough drawdown.

Calmar = CAGR / |MaxDrawdown|

A Calmar ratio above 1.0 means the annualized return exceeds the maximum drawdown. This ratio is popular among CTAs and hedge fund investors. Typically computed over a 3-year window.

Omega Ratio

A gain-loss ratio that considers the entire return distribution above and below a threshold tau.

Omega(tau) = integral from tau to +inf of [1 - F(r)] dr
             / integral from -inf to tau of F(r) dr

where F(r) is the cumulative distribution function of returns.

In practice, this is computed as:

Omega(tau) = sum(max(R_i - tau, 0)) / sum(max(tau - R_i, 0))

Omega > 1 means expected gains above tau exceed expected losses below tau. Unlike Sharpe, Omega captures the full shape of the distribution (skewness, kurtosis).

Upside and Downside Capture Ratios

Measure how the portfolio participates in benchmark up and down markets.

Up Capture   = R_p(in up months) / R_b(in up months) * 100
Down Capture = R_p(in down months) / R_b(in down months) * 100
Capture Ratio = Up Capture / Down Capture

Ideal profile: Up Capture > 100% and Down Capture < 100%, yielding a Capture Ratio > 1. "Up months" and "down months" are defined by the benchmark return being positive or negative, respectively.

M-Squared (Modigliani-Modigliani)

Expresses risk-adjusted return in the same units as return, by leveraging or deleveraging the portfolio to match benchmark volatility.

M^2 = R_f + SR_p * sigma_b
    = R_f + ((R_p - R_f) / sigma_p) * sigma_b

Interpretation: "If this portfolio were scaled to have the same volatility as the benchmark, it would have returned M-squared." This makes it directly comparable to benchmark returns.

Key Formulas

FormulaExpressionUse Case
Sharpe Ratio(R_p - R_f) / sigma_pReturn per unit of total risk
Sortino Ratio(R_p - R_f) / sigma_downsideReturn per unit of downside risk
Information Ratio(R_p - R_b) / TEActive return per unit of active risk
Treynor Ratio(R_p - R_f) / beta_pReturn per unit of systematic risk
Calmar RatioCAGR /MaxDD
Omega Ratiosum(max(R_i - tau, 0)) / sum(max(tau - R_i, 0))Full-distribution gain-loss ratio
Up CaptureR_p(up) / R_b(up) * 100Participation in rising markets
Down CaptureR_p(down) / R_b(down) * 100Participation in falling markets
M-SquaredR_f + SR_p * sigma_bRisk-adjusted return in return units

Worked Examples

Example 1: Sharpe Ratio Calculation

Given: A fund returned 12% annualized, the risk-free rate is 4%, and the fund's annualized volatility is 15%.

Calculate: Sharpe Ratio.

Solution:

SR = (0.12 - 0.04) / 0.15
   = 0.08 / 0.15
   = 0.533

The fund earned 0.533 units of excess return per unit of risk. This is in the "acceptable" range but below 1.0.

Example 2: Comparing Funds with Sharpe and Sortino

Given:

  • Fund A: Sharpe = 0.8, Sortino = 1.2
  • Fund B: Sharpe = 0.7, Sortino = 1.5

Calculate: Which fund is better for a downside-averse investor?

Solution:

Fund A has a higher Sharpe ratio (0.8 vs 0.7), indicating better total-risk-adjusted performance. However, Fund B has a notably higher Sortino ratio (1.5 vs 1.2), meaning it delivers significantly more return per unit of downside risk.

The divergence implies Fund B's volatility is more skewed to the upside -- its total volatility includes more "good" volatility (gains), while its downside volatility is relatively contained.

For a downside-averse investor, Fund B is preferable because the Sortino ratio better captures the risk they care about (losses), and Fund B's superior Sortino indicates better downside risk management.

Example 3: Information Ratio

Given: A portfolio returned 10% annualized, its benchmark returned 8%, and the tracking error is 4%.

Calculate: Information Ratio.

Solution:

IR = (0.10 - 0.08) / 0.04
   = 0.02 / 0.04
   = 0.50

The manager generated 0.50 units of active return per unit of active risk. This is generally considered a good IR, suggesting consistent alpha generation relative to benchmark deviations.

Common Pitfalls

  • Annualizing Sharpe incorrectly: The Sharpe ratio scales by sqrt(N) where N is the number of periods per year. SR_annual = SR_monthly * sqrt(12), not * 12. The excess return and volatility must be in consistent units before dividing.
  • Using wrong risk-free rate frequency: If computing monthly Sharpe, use the monthly risk-free rate (annual rate / 12), not the annual rate directly.
  • Sortino MAR ambiguity: The Sortino ratio result changes significantly depending on whether MAR = 0, MAR = risk-free rate, or MAR = some target return. Always state the MAR assumption explicitly.
  • Small sample sizes making ratios unreliable: Ratios computed from fewer than 36 monthly observations are statistically unreliable. A Sharpe ratio from 12 months of data has a standard error of approximately sqrt((1 + SR^2/2) / 12), which is very wide.
  • Comparing Sharpe ratios across different time periods: A Sharpe of 1.0 in a low-vol environment is not the same as 1.0 in a high-vol environment. Performance ratios are period-specific and not directly comparable across different market regimes.

Cross-References

  • historical-risk (wealth-management plugin): Provides the risk measures (volatility, drawdown, downside deviation, tracking error) used as denominators in these performance ratios.
  • performance-reporting (wealth-management plugin) and return-calculations (core plugin): For TWR/MWR calculation methodology and reporting presentation, see performance-reporting and core/return-calculations.
  • forward-risk (wealth-management plugin): Forward-looking risk measures (VaR, CVaR) complement retrospective performance assessment by estimating future potential losses.
  • volatility-modeling (wealth-management plugin): Volatility forecasts from GARCH or EWMA can be used to compute forward-looking or conditional Sharpe ratios.
  • factor-investing (wealth-management plugin): Factor regressions decompose the alpha behind these ratios; the closet-index screen uses tracking error and a breakeven Information Ratio

Running the script

Run with uv run scripts/performance_metrics.py (the PEP 723 header resolves numpy automatically) or with python3 scripts/performance_metrics.py after pip install numpy scipy. A bare run prints a full scorecard (Sharpe, Sortino, Information Ratio, Calmar, Treynor, Omega, capture ratios, batting average, win/loss) on seeded synthetic portfolio and benchmark data. Use --verify to assert outputs match this skill's worked examples and the demo's expected values (exit code 0 on PASS) and --help for an overview of the class. The file is primarily meant to be imported as a module (e.g., from performance_metrics import PerformanceScorecard).

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Performance Metrics AI skill do?

Evaluate investment performance on a risk-adjusted basis using industry-standard ratios and capture analysis. Use when the user asks about Sharpe ratio, Sortino ratio, Information Ratio, Treynor ratio, Calmar ratio, Omega ratio, or upside/downside capture. Also trigger when users mention 'risk-adjusted returns', 'return per unit of risk', 'M-squared', 'is this fund worth the volatility', 'how to compare two managers', 'capture ratio', or ask which investment performed better after accounting for risk.

Why use Performance Metrics on TypingMind?

Because you install it once and use it with any model. Performance Metrics is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Performance Metrics in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/JoelLewis/finance_skills/tree/main/plugins/wealth-management/skills/performance-metrics. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Performance Metrics?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Performance Metrics?

As many as you like. As long as a model supports skills, you can use Performance Metrics with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Performance Metrics AI skill free?

Yes. It is published on GitHub by JoelLewis under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇