# Startup Valuation MCP Server (remote · startup-valuation.simonmak.com)

Startup valuation for AI agents: 14 tools, 80+ pre-revenue formulas.

- Trust score: 74/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-08

## Components

- remote · `startup-valuation.simonmak.com`: 74/100 (this document), [markdown](https://verifymcp.io/servers/simonmak-ascent-startup-valuation/api.md), [page](https://verifymcp.io/servers/simonmak-ascent-startup-valuation/api)
- pypi · `startup-valuation`: 40/100, [markdown](https://verifymcp.io/servers/simonmak-ascent-startup-valuation/startup-valuation.md), [page](https://verifymcp.io/servers/simonmak-ascent-startup-valuation/startup-valuation)

## Channel facts

- Endpoint: `https://startup-valuation.simonmak.com/api`
- Transports: `streamable-http`
- Auth: `none`
- Version: `2.1.2`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-10-08.

- **Endpoint Security**: 80/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - No authorisation is required to call this server. Every tool declares its destructiveHint and none is destructive, so open access doesn't expose one.
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 71/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 9296 tokens (~320/item across 29 items; 14 tools + 15 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 17/100
  - Stability observed for 5 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 14 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 16 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 60/100
  - Spec-recency check failed: implements MCP spec 2025-06-18; the latest is 2026-07-28.

## Install

### How do I install the Startup Valuation MCP Server server?

Startup Valuation MCP Server is a hosted endpoint at https://startup-valuation.simonmak.com/api, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http simonmak-ascent-startup-valuation 'https://startup-valuation.simonmak.com/api'
```

### Cursor

```json
{
  "mcpServers": {
    "simonmak-ascent-startup-valuation": {
      "url": "https://startup-valuation.simonmak.com/api"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "simonmak-ascent-startup-valuation": {
      "type": "http",
      "url": "https://startup-valuation.simonmak.com/api"
    }
  }
}
```

### Codex

```toml
[mcp_servers.simonmak-ascent-startup-valuation]
url = "https://startup-valuation.simonmak.com/api"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "simonmak-ascent-startup-valuation": {
      "type": "remote",
      "url": "https://startup-valuation.simonmak.com/api",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add simonmak-ascent-startup-valuation --url 'https://startup-valuation.simonmak.com/api' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  simonmak-ascent-startup-valuation:
    url: "https://startup-valuation.simonmak.com/api"
```

### Netclaw

```json
{
  "McpServers": {
    "simonmak-ascent-startup-valuation": {
      "Transport": "http",
      "Url": "https://startup-valuation.simonmak.com/api"
    }
  }
}
```

### Vellum

```bash
assistant mcp add simonmak-ascent-startup-valuation -t streamable-http -u 'https://startup-valuation.simonmak.com/api'
```

### Other

```json
{
  "mcpServers": {
    "simonmak-ascent-startup-valuation": {
      "type": "http",
      "url": "https://startup-valuation.simonmak.com/api"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-10-08 (score 74, +2)

No change was recorded against any check on this day. Stability & Change Management went from 3 to 17. That category is still filling its 30-day observation window: 1 days of observed history at the previous scan, 5 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-04 (score 72, +1)

- [functional improvement] Stability: unverified → 0.03
- [functional] Server version: 2.1.0 → 2.1.2

### 2026-10-03 (score 71)

First indexed and scored.

## MCP tools (14)

### `valuation_probability` (~670 tokens)

Probability & Expected Value

Compute expected value and probability-weighted outcomes for startup scenarios: discrete E[X], joint probability of sequential events, probability-weighted value, VC portfolio expected return, Poisson event probability, and continuous E[X] over a range. Method selects the formula. Use for probability-weighted central estimates; for named bull/base/bear tables or option pricing use valuation_advanced, and to discount cash flows use valuation_time_value. Parameters apply per method: expected_value_discrete and probability_weighted need outcomes + probabilities; portfolio_return needs weights + returns; poisson needs mean_events + k; expected_value_continuous needs lower + upper. outcomes and probabilities must be equal length, and the probabilities should sum to 1. Routing: use valuation_advanced method 'scenario_analysis' for named bull/base/bear scenario tables, and its black_scholes/binomial methods for option pricing; use this tool for arbitrary outcome lists and probability-weighted central estimates. Only method is required; all other parameters are method-dependent, so supply those the selected method names and omit the rest (defaults apply where defined). Rate and decimal inputs are fractions (0.10 = 10%); probability and weight lists are in [0,1] and sum to 1. Returns value, method, inputs, assumptions, chapter, formula_number and calculation steps; pure arithmetic — no I/O and no external calls — rounded to 2 decimals, with no auth or rate limits. An unknown method, or a missing method-required parameter, returns an error instead of a value.

Input parameters:

- `k` (integer): Number of events k for the Poisson probability P(X=k); integer ≥ 0.
- `lower` (number): Lower integration bound (standard-normal domain, e.g. -1.0).
- `mean_events` (number): Poisson mean λ = expected number of events in the interval.
- `method` (string, required): Formula to apply. Options: expected_value_discrete = E[X] = Σ xᵢ·P(X=xᵢ) over a discrete outcome list.; joint_probability = P(total) = Π pᵢ for independent sequential events.; probability_weighted =…
- `outcomes` (array): Possible outcome values x_i, in any currency unit (must match probabilities in length/order).
- `probabilities` (array): Probability of each outcome or stage, each in [0,1]; the list must sum to 1 where it is exhaustive.
- `returns` (array): Return of each asset or scenario as a decimal (0.20 = 20%), aligned with weights.
- `upper` (number): Upper integration bound (standard-normal domain, e.g. 1.0).
- `weights` (array): Portfolio or factor weights, each in [0,1] and summing to 1 (same order as the paired value list).

Output parameters:

- `assumptions` (array): Modelling assumptions applied.
- `chapter` (string): Source textbook chapter.
- `defaults_applied` (array): Optional parameters that were not supplied, so their documented defaults were used.
- `error` (string): Error message when the call fails.
- `formula_number` (string): Source textbook formula number (e.g. '3.1').
- `inputs` (object): Echo of the normalised inputs used.
- `method` (string): Formula / method name that produced the result.
- `steps` (array): Intermediate steps for traceability.
- `value` (number): Computed valuation or metric.

### `valuation_time_value` (~701 tokens)

Time Value of Money

Discount, compound, and forecast value over time: single future value PV, net present value of a cash-flow stream, annuity present value, discounted cash flow with a Gordon terminal value, constant-rate compound growth of revenue or cash flow, and the implied compound annual growth rate (CAGR). Method selects the formula. Use to convert future cash to today's value, to value a full forecast with a terminal value (dcf), to project a revenue or cash-flow series forward, or to derive the growth rate implied by two values; get the discount rate from valuation_capm or valuation_international. Parameters apply per method: present_value needs future_value + rate + periods; npv needs cash_flows + rate; annuity needs payment + rate + periods; dcf needs cash_flows + rate (optional: terminal_growth); compound_growth needs starting_value + growth_rate + periods; cagr needs starting_value + ending_value + periods. growth_rate must be greater than -1, cagr requires starting_value > 0 and periods > 0, and dcf requires rate greater than terminal_growth. Not for option values (use valuation_advanced) or for expected values over outcomes (use valuation_probability). Only method is required; all other parameters are method-dependent, so supply those the selected method names and omit the rest (defaults apply where defined). Rate and decimal inputs are fractions (0.10 = 10%); probability and weight lists are in [0,1] and sum to 1. Returns value, method, inputs, assumptions, chapter, formula_number and calculation steps; pure arithmetic — no I/O and no external calls — rounded to 2 decimals, with no auth or rate limits. An unknown method, or a missing method-required parameter, returns an error instead of a value.

Input parameters:

- `cash_flows` (array): Cash flows by period, first element at t=1; negatives allowed for outflows.
- `ending_value` (number): Value at t=n to compare against the starting value, in currency units.
- `future_value` (number): Future cash amount to discount, in currency units.
- `growth_rate` (number): Revenue growth rate as a decimal (0.40 = 40%).
- `method` (string, required): Formula to apply. Options: present_value = PV = C / (1+r)^t.; npv = NPV = Σ Cₜ / (1+r)^t.; annuity = PV = P·[1-(1+r)^-n]/r.; compound_growth = V_n = V_0 (1+g)^n.; cagr = CAGR = (V_n / V_0)^(1/n) - 1.…
- `payment` (number): Recurring payment per period, in currency units.
- `periods` (number): Number of compounding periods, must be ≥ 1 (may be fractional).
- `rate` (number): Per-period discount rate as a decimal (0.10 = 10%).
- `starting_value` (number): Value at t=0 (revenue or cash flow) to grow forward, in currency units.
- `terminal_growth` (number): Perpetual growth rate g applied after the forecast window, as a decimal.

Output parameters:

- `assumptions` (array): Modelling assumptions applied.
- `chapter` (string): Source textbook chapter.
- `defaults_applied` (array): Optional parameters that were not supplied, so their documented defaults were used.
- `error` (string): Error message when the call fails.
- `formula_number` (string): Source textbook formula number (e.g. '3.1').
- `inputs` (object): Echo of the normalised inputs used.
- `method` (string): Formula / method name that produced the result.
- `steps` (array): Intermediate steps for traceability.
- `value` (number): Computed valuation or metric.

### `valuation_capm` (~647 tokens)

CAPM & Cost of Equity

Estimate the cost of capital: standard CAPM, startup-adjusted CAPM with size and illiquidity premiums, portfolio beta from weighted asset betas, and WACC blending after-tax cost of equity and debt. Method selects the formula. Use to derive the discount rate that feeds valuation_time_value and DCF models; for cross-border rates add valuation_international. Parameters apply per method: capm needs risk_free_rate + beta + market_return; startup_capm adds size_premium and liquidity_premium; portfolio_beta needs weights + betas, which must be equal length; wacc needs equity_value + debt_value + cost_of_equity + cost_of_debt + tax_rate. Only method is required; all other parameters are method-dependent, so supply those the selected method names and omit the rest (defaults apply where defined). Rate and decimal inputs are fractions (0.10 = 10%); probability and weight lists are in [0,1] and sum to 1. Returns value, method, inputs, assumptions, chapter, formula_number and calculation steps; pure arithmetic — no I/O and no external calls — rounded to 2 decimals, with no auth or rate limits. An unknown method, or a missing method-required parameter, returns an error instead of a value.

Input parameters:

- `beta` (number): Systematic risk beta (market = 1.0).
- `betas` (array): Asset betas aligned with weights; typically 0.5–3.0 (market = 1.0).
- `cost_of_debt` (number): Pre-tax cost of debt Rd as a decimal.
- `cost_of_equity` (number): After-tax cost of equity Re as a decimal.
- `debt_value` (number): Market value of debt, in currency units.
- `equity_value` (number): Value of equity offered, currency units.
- `liquidity_premium` (number): Illiquidity premium as a decimal.
- `market_return` (number): Expected market return as a decimal (e.g. 0.10 for 10%).
- `market_risk_premium` (number): Market risk premium as a decimal (e.g. 0.06).
- `method` (string, required): Formula to apply. Options: capm = E(R) = Rf + β·(E(Rm) - Rf).; startup_capm = r = Rf + β·MRP + size premium + illiquidity premium.; portfolio_beta = βp = Σ wᵢ·βᵢ.; wacc = WACC = (E/V)·Re + (D/V)·Rd·(…
- `risk_free_rate` (number): Risk-free rate as a decimal (e.g. 0.04 for 4%).
- `size_premium` (number): Small-cap / size premium as a decimal.
- `tax_rate` (number): Effective tax rate as a decimal in [0,1].
- `weights` (array): Portfolio or factor weights, each in [0,1] and summing to 1 (same order as the paired value list).

Output parameters:

- `assumptions` (array): Modelling assumptions applied.
- `chapter` (string): Source textbook chapter.
- `defaults_applied` (array): Optional parameters that were not supplied, so their documented defaults were used.
- `error` (string): Error message when the call fails.
- `formula_number` (string): Source textbook formula number (e.g. '3.1').
- `inputs` (object): Echo of the normalised inputs used.
- `method` (string): Formula / method name that produced the result.
- `steps` (array): Intermediate steps for traceability.
- `value` (number): Computed valuation or metric.

### `valuation_core` (~775 tokens)

Pre-Revenue Core Methods

The textbook's pre-revenue methods: Scorecard, Berkus, Risk-Factor Summation, VC Method (post- and pre-money), and exit terminal value. Use these first for early-stage startups. Method selects the formula, and each method names its own parameters: scorecard needs average_valuation + weights + scores; berkus takes five factor awards; risk_factor needs base_valuation + risk_ratings; vc_post_money needs terminal_value + target_return; vc_pre_money needs post_money + investment; terminal_value needs projected_revenue + multiple; triangulated needs the scorecard inputs plus terminal_value/target_return/investment. Routing: for SAFEs, tokens, ESG, network effects, or data-moat methods use valuation_emerging; for options or bull/base/bear scenario tables use valuation_advanced; for public-comparable multiples use valuation_comparables. Only method is required; all other parameters are method-dependent, so supply those the selected method names and omit the rest (defaults apply where defined). Rate and decimal inputs are fractions (0.10 = 10%); probability and weight lists are in [0,1] and sum to 1. Returns value, method, inputs, assumptions, chapter, formula_number and calculation steps; pure arithmetic — no I/O and no external calls — rounded to 2 decimals, with no auth or rate limits. An unknown method, or a missing method-required parameter, returns an error instead of a value.

Input parameters:

- `average_valuation` (number): Average pre-revenue valuation for the sector, currency units.
- `base_valuation` (number): Pre-adjustment baseline valuation, currency units.
- `investment` (number): Amount invested, currency units.
- `method` (string, required): Formula to apply. Options: scorecard = V = V_avg · Σ(wᵢ·sᵢ) across 7 factors.; berkus = V = Σ factor awards, each capped at $500K.; risk_factor = V = V_base + Σ(rᵢ·$250K) over 12 risks.; vc_post_mone…
- `multiple` (number): Exit or market multiple applied to the metric.
- `post_money` (number): Post-money valuation, currency units.
- `product_rollout` (number): Berkus award for product rollout / sales, 0 to 500,000.
- `projected_revenue` (number): Projected revenue at exit, currency units.
- `prototype` (number): Berkus award for prototype / technology, 0 to 500,000.
- `quality_team` (number): Berkus award for management team, 0 to 500,000.
- `risk_ratings` (array): 12 risk factor ratings in [-2,2] (very low to very high); each unit shifts value ±250,000.
- `scores` (array): Factor multipliers aligned with weights (1.0 = average, >1 above average).
- `sound_idea` (number): Berkus award for soundness of the idea, 0 to 500,000 (USD).
- `strategic_relationships` (number): Berkus award for strategic relationships, 0 to 500,000.
- `target_return` (number): VC target return multiple (e.g. 10 for a 10x target).
- `terminal_value` (number): Expected exit / terminal value, currency units.
- `weights` (array): Portfolio or factor weights, each in [0,1] and summing to 1 (same order as the paired value list).

Output parameters:

- `assumptions` (array): Modelling assumptions applied.
- `chapter` (string): Source textbook chapter.
- `defaults_applied` (array): Optional parameters that were not supplied, so their documented defaults were used.
- `error` (string): Error message when the call fails.
- `formula_number` (string): Source textbook formula number (e.g. '3.1').
- `inputs` (object): Echo of the normalised inputs used.
- `method` (string): Formula / method name that produced the result.
- `steps` (array): Intermediate steps for traceability.
- `value` (number): Computed valuation or metric.

### `valuation_advanced` (~468 tokens)

Options & Scenario Analysis

Advanced techniques: Black-Scholes call value, binomial-tree option value, and scenario analysis. Method selects the technique. For a quick expected value over arbitrary outcome lists, prefer valuation_probability with method 'probability_weighted'; scenario_analysis here is for explicit named bull/base/bear scenario tables. Parameters apply per method: black_scholes and binomial need underlying + strike + risk_free_rate + volatility + time_to_maturity (binomial adds steps); scenario_analysis needs scenarios. Not for plain discounted cash flow — for that use valuation_time_value. Only method is required; all other parameters are method-dependent, so supply those the selected method names and omit the rest (defaults apply where defined). Rate and decimal inputs are fractions (0.10 = 10%); probability and weight lists are in [0,1] and sum to 1. Returns value, method, inputs, assumptions, chapter, formula_number and calculation steps; pure arithmetic — no I/O and no external calls — rounded to 2 decimals, with no auth or rate limits. An unknown method, or a missing method-required parameter, returns an error instead of a value.

Input parameters:

- `method` (string, required): Formula to apply. Options: black_scholes = C = N(d₁)S - N(d₂)Ke^(-rT).; binomial = Cox-Ross-Rubinstein binomial option value.; scenario_analysis = E[V] = Σ pᵢ·Vᵢ over named scenarios.
- `risk_free_rate` (number): Risk-free rate as a decimal (e.g. 0.04 for 4%).
- `scenarios` (array): Scenario objects: {name: str, probability: 0-1, value: currency}; probabilities should sum to 1.
- `steps` (integer): Binomial tree time steps (integer ≥ 1; higher = more accurate).
- `strike` (number): Strike / exercise price K, currency units.
- `time_to_maturity` (number): Time to expiry in years T, must be ≥ 0.
- `underlying` (number): Underlying asset value S, currency units.
- `volatility` (number): Annualised volatility σ as a decimal (0.80 = 80%).

Output parameters:

- `assumptions` (array): Modelling assumptions applied.
- `chapter` (string): Source textbook chapter.
- `defaults_applied` (array): Optional parameters that were not supplied, so their documented defaults were used.
- `error` (string): Error message when the call fails.
- `formula_number` (string): Source textbook formula number (e.g. '3.1').
- `inputs` (object): Echo of the normalised inputs used.
- `method` (string): Formula / method name that produced the result.
- `steps` (array): Intermediate steps for traceability.
- `value` (number): Computed valuation or metric.

### `valuation_comparables` (~543 tokens)

Comparable Multiples

Market multiples from comparables: P/E, P/S, EV/EBITDA, EV/Revenue, and a regression-adjusted multiple. Method selects the ratio. Use when public comparables exist; for pre-revenue or private startups use valuation_core. Parameters apply per method: pe_ratio needs market_cap + net_income; ps_ratio needs market_cap + revenue; ev_ebitda needs enterprise_value + ebitda; ev_revenue needs enterprise_value + revenue; regression_multiple needs intercept + growth_rate + growth_coefficient (plus optional maturity/stage/geography terms). Only method is required; all other parameters are method-dependent, so supply those the selected method names and omit the rest (defaults apply where defined). Rate and decimal inputs are fractions (0.10 = 10%); probability and weight lists are in [0,1] and sum to 1. Returns value, method, inputs, assumptions, chapter, formula_number and calculation steps; pure arithmetic — no I/O and no external calls — rounded to 2 decimals, with no auth or rate limits. An unknown method, or a missing method-required parameter, returns an error instead of a value.

Input parameters:

- `ebitda` (number): EBITDA, currency units.
- `enterprise_value` (number): Enterprise value (market cap + net debt), currency units.
- `geography` (number): Geography indicator.
- `geography_coefficient` (number): Regression slope on geography.
- `growth_coefficient` (number): Regression slope on growth (multiple points per unit growth).
- `growth_rate` (number): Revenue growth rate as a decimal (0.40 = 40%).
- `intercept` (number): Regression intercept β0 (base multiple).
- `market_cap` (number): Market capitalisation, currency units.
- `market_maturity` (number): Market maturity indicator.
- `maturity_coefficient` (number): Regression slope on market maturity.
- `method` (string, required): Formula to apply. Options: pe_ratio = P/E = market cap / net income.; ps_ratio = P/S = market cap / revenue.; ev_ebitda = EV/EBITDA = enterprise value / EBITDA.; ev_revenue = EV/Revenue = enterprise…
- `net_income` (number): Net income (earnings), currency units.
- `revenue` (number): Revenue for the period, currency units.
- `stage` (number): Company stage indicator.
- `stage_coefficient` (number): Regression slope on stage.

Output parameters:

- `assumptions` (array): Modelling assumptions applied.
- `chapter` (string): Source textbook chapter.
- `defaults_applied` (array): Optional parameters that were not supplied, so their documented defaults were used.
- `error` (string): Error message when the call fails.
- `formula_number` (string): Source textbook formula number (e.g. '3.1').
- `inputs` (object): Echo of the normalised inputs used.
- `method` (string): Formula / method name that produced the result.
- `steps` (array): Intermediate steps for traceability.
- `value` (number): Computed valuation or metric.

### `valuation_saas` (~741 tokens)

SaaS Metrics & Valuation

SaaS unit economics and valuation: LTV, CAC, MRR, ARR, net revenue retention, magic number, Rule of 40, CAC payback, and ARR revenue-multiple valuation. Method selects the metric. Use for subscription software; for marketplace GMV metrics use valuation_marketplace and for payments/lending use valuation_fintech. Parameters apply per method: ltv needs arpu + gross_margin + churn_rate; cac needs sales_marketing_expense + new_customers; arr needs subscription_values; nrr needs starting_revenue + ending_revenue; revenue_multiple needs arr + revenue_multiple. Not for company-level pre-revenue value — for that use valuation_core. Only method is required; all other parameters are method-dependent, so supply those the selected method names and omit the rest (defaults apply where defined). Rate and decimal inputs are fractions (0.10 = 10%); probability and weight lists are in [0,1] and sum to 1. Returns value, method, inputs, assumptions, chapter, formula_number and calculation steps; pure arithmetic — no I/O and no external calls — rounded to 2 decimals, with no auth or rate limits. An unknown method, or a missing method-required parameter, returns an error instead of a value.

Input parameters:

- `arpu` (number): Average revenue per user per month, currency units.
- `arr` (number): Annual recurring revenue, currency units.
- `arr_value` (number): Annual recurring revenue, currency units.
- `cac` (number): Customer acquisition cost per customer, currency units.
- `churn_rate` (number): Periodic churn rate as a decimal (0.02 = 2% per month).
- `ending_revenue` (number): Revenue from the same cohort at period end, currency units.
- `expansion_revenue` (number): Expansion revenue from the cohort in the period.
- `gross_margin` (number): Gross margin as a decimal (0.80 = 80%).
- `growth_rate` (number): Revenue growth rate as a decimal (0.40 = 40%).
- `method` (string, required): Formula to apply. Options: ltv = LTV = ARPU × gross margin / churn.; cac = CAC = S&M expense / new customers.; mrr = MRR = ARR / 12 (reverse of ARR).; arr = ARR = Σ monthly subscriptions × 12.; nrr =…
- `mrr_per_customer` (number): Monthly recurring revenue per customer, currency units.
- `net_new_arr` (number): Net new ARR added in the period, currency units.
- `new_customers` (integer): Number of customers acquired in the period.
- `profit_margin` (number): Profit margin as a decimal (0.15 = 15%).
- `revenue_multiple` (number): SaaS revenue multiple (e.g. 8 for 8x ARR).
- `sales_marketing_expense` (number): Sales & marketing spend for the period, currency units.
- `sm_expense_prior` (number): Sales & marketing expense in the prior period, currency units.
- `starting_revenue` (number): Revenue from the cohort at period start, currency units.
- `subscription_values` (array): Monthly subscription revenue per customer (summed x12 for ARR).

Output parameters:

- `assumptions` (array): Modelling assumptions applied.
- `chapter` (string): Source textbook chapter.
- `defaults_applied` (array): Optional parameters that were not supplied, so their documented defaults were used.
- `error` (string): Error message when the call fails.
- `formula_number` (string): Source textbook formula number (e.g. '3.1').
- `inputs` (object): Echo of the normalised inputs used.
- `method` (string): Formula / method name that produced the result.
- `steps` (array): Intermediate steps for traceability.
- `value` (number): Computed valuation or metric.

### `valuation_marketplace` (~411 tokens)

Marketplace Metrics

Marketplace health and valuation: take rate, GMV revenue-multiple valuation, buyer retention, and network density. Method selects the metric. Use for two-sided transaction marketplaces; for subscription software use valuation_saas. Parameters apply per method: take_rate needs revenue + gmv; gmv_multiple needs gmv + multiple; buyer_retention needs buyers_period_1 + buyers_repeat; network_density needs active_buyers + active_sellers + total_users. Only method is required; all other parameters are method-dependent, so supply those the selected method names and omit the rest (defaults apply where defined). Rate and decimal inputs are fractions (0.10 = 10%); probability and weight lists are in [0,1] and sum to 1. Returns value, method, inputs, assumptions, chapter, formula_number and calculation steps; pure arithmetic — no I/O and no external calls — rounded to 2 decimals, with no auth or rate limits. An unknown method, or a missing method-required parameter, returns an error instead of a value.

Input parameters:

- `active_buyers` (integer): Active buyers in the period.
- `active_sellers` (integer): Active sellers in the period.
- `buyers_period_1` (integer): Distinct buyers in the base period.
- `buyers_repeat` (integer): Distinct buyers from the base period who purchased again.
- `gmv` (number): Gross merchandise value (total transaction volume), currency units.
- `method` (string, required): Formula to apply. Options: take_rate = Take rate = revenue / GMV.; gmv_multiple = Valuation = GMV × multiple.; buyer_retention = Retention = repeat buyers / base-period buyers.; network_density = Den…
- `multiple` (number): Exit or market multiple applied to the metric.
- `revenue` (number): Revenue for the period, currency units.
- `total_users` (integer): Total users (buyers + sellers) in the period.

Output parameters:

- `assumptions` (array): Modelling assumptions applied.
- `chapter` (string): Source textbook chapter.
- `defaults_applied` (array): Optional parameters that were not supplied, so their documented defaults were used.
- `error` (string): Error message when the call fails.
- `formula_number` (string): Source textbook formula number (e.g. '3.1').
- `inputs` (object): Echo of the normalised inputs used.
- `method` (string): Formula / method name that produced the result.
- `steps` (array): Intermediate steps for traceability.
- `value` (number): Computed valuation or metric.

### `valuation_fintech` (~562 tokens)

Fintech Valuation

Value and size fintech business models: payment revenue, lending valuation, payment-processor DCF, and neobank customer-based valuation. Method selects the model. Use for payments, lending, and neobanks; for SaaS-style unit economics use valuation_saas. Parameters apply per method: payment_revenue needs transaction_volume + take_rate; lending needs loan_book + roe + pe_multiple; payment_processor adds growth_rate + discount_rate + terminal_multiple; neobank needs customers + arpu + gross_margin + churn_rate + pe_multiple. Only method is required; all other parameters are method-dependent, so supply those the selected method names and omit the rest (defaults apply where defined). Rate and decimal inputs are fractions (0.10 = 10%); probability and weight lists are in [0,1] and sum to 1. Returns value, method, inputs, assumptions, chapter, formula_number and calculation steps; pure arithmetic — no I/O and no external calls — rounded to 2 decimals, with no auth or rate limits. An unknown method, or a missing method-required parameter, returns an error instead of a value.

Input parameters:

- `arpu` (number): Average revenue per user per month, currency units.
- `churn_rate` (number): Periodic churn rate as a decimal (0.02 = 2% per month).
- `customers` (integer): Number of customers.
- `discount_rate` (number): Discount rate as a decimal (0.12 = 12%).
- `gross_margin` (number): Gross margin as a decimal (0.80 = 80%).
- `growth_rate` (number): Revenue growth rate as a decimal (0.40 = 40%).
- `loan_book` (number): Outstanding loan book / principal, currency units.
- `method` (string, required): Formula to apply. Options: payment_revenue = Revenue = volume × take rate.; lending = V = loan book × ROE × P/E - NPL reserves.; payment_processor = DCF of payment revenue with a terminal multiple.;…
- `npl_reserves` (number): Non-performing loan reserves deducted, currency units.
- `pe_multiple` (number): Price/earnings multiple applied to earnings.
- `roe` (number): Return on equity as a decimal (0.20 = 20%).
- `take_rate` (number): Take rate as a decimal (0.15 = 15% of GMV).
- `terminal_multiple` (number): Terminal value multiple applied at the horizon.
- `transaction_volume` (number): Total payment transaction volume, currency units.
- `years` (integer): Forecast horizon in years; integer ≥ 1.

Output parameters:

- `assumptions` (array): Modelling assumptions applied.
- `chapter` (string): Source textbook chapter.
- `defaults_applied` (array): Optional parameters that were not supplied, so their documented defaults were used.
- `error` (string): Error message when the call fails.
- `formula_number` (string): Source textbook formula number (e.g. '3.1').
- `inputs` (object): Echo of the normalised inputs used.
- `method` (string): Formula / method name that produced the result.
- `steps` (array): Intermediate steps for traceability.
- `value` (number): Computed valuation or metric.

### `valuation_biotech` (~437 tokens)

Biotech Pipeline Valuation

Risk-adjusted biotech valuation: peak sales, decision-tree expected value, and full pipeline rNPV across drugs. Method selects the model. Use for pharma/drug pipelines; for hardware or deep tech use valuation_hardware. Parameters apply per method: peak_sales needs patient_population + penetration + price; decision_tree needs probabilities + terminal_value; pipeline needs drugs + discount_rate. Not for hardware or deep tech — for that use valuation_hardware. Only method is required; all other parameters are method-dependent, so supply those the selected method names and omit the rest (defaults apply where defined). Rate and decimal inputs are fractions (0.10 = 10%); probability and weight lists are in [0,1] and sum to 1. Returns value, method, inputs, assumptions, chapter, formula_number and calculation steps; pure arithmetic — no I/O and no external calls — rounded to 2 decimals, with no auth or rate limits. An unknown method, or a missing method-required parameter, returns an error instead of a value.

Input parameters:

- `compliance` (number): Compliance / adherence rate as a decimal.
- `discount_rate` (number): Discount rate as a decimal (0.12 = 12%).
- `drugs` (array): Pipeline drugs: {name, peak_sales, probability, years_to_market, multiple(optional)}.
- `method` (string, required): Formula to apply. Options: peak_sales = Peak = population × penetration × price × compliance.; decision_tree = EV = Π pᵢ × terminal value.; pipeline = V = Σ(peak sales × multiple × P_success) / (1+r)…
- `patient_population` (number): Target patient population treated per year.
- `penetration` (number): Market penetration as a decimal (0.10 = 10%).
- `price` (number): Price per unit / treatment, currency units.
- `probabilities` (array): Probability of each outcome or stage, each in [0,1]; the list must sum to 1 where it is exhaustive.
- `terminal_value` (number): Expected exit / terminal value, currency units.

Output parameters:

- `assumptions` (array): Modelling assumptions applied.
- `chapter` (string): Source textbook chapter.
- `defaults_applied` (array): Optional parameters that were not supplied, so their documented defaults were used.
- `error` (string): Error message when the call fails.
- `formula_number` (string): Source textbook formula number (e.g. '3.1').
- `inputs` (object): Echo of the normalised inputs used.
- `method` (string): Formula / method name that produced the result.
- `steps` (array): Intermediate steps for traceability.
- `value` (number): Computed valuation or metric.

### `valuation_hardware` (~428 tokens)

Hardware & Unit Economics

Hardware and deep-tech valuation: TRL-risk-adjusted valuation, gross margin, and break-even volume. Method selects the metric. Use for hardware and deep tech with technology-readiness risk; for drug pipelines use valuation_biotech. Parameters apply per method: trl needs market_size + market_share + margin + multiple + trl_discount; gross_margin needs asp + variable_cost; break_even_volume needs fixed_costs + asp + variable_cost. Not for drug pipelines — for those use valuation_biotech. Only method is required; all other parameters are method-dependent, so supply those the selected method names and omit the rest (defaults apply where defined). Rate and decimal inputs are fractions (0.10 = 10%); probability and weight lists are in [0,1] and sum to 1. Returns value, method, inputs, assumptions, chapter, formula_number and calculation steps; pure arithmetic — no I/O and no external calls — rounded to 2 decimals, with no auth or rate limits. An unknown method, or a missing method-required parameter, returns an error instead of a value.

Input parameters:

- `asp` (number): Average selling price per unit, currency units.
- `fixed_costs` (number): Fixed costs for the period, currency units.
- `margin` (number): Profit margin as a decimal.
- `market_share` (number): Target market share as a decimal in [0,1].
- `market_size` (number): Total addressable market, currency units.
- `method` (string, required): Formula to apply. Options: trl = V = market × share × margin × multiple × (1 - TRL discount).; gross_margin = GM = (ASP - COGS) / ASP.; break_even_volume = Units = fixed costs / (ASP - variable cost).
- `multiple` (number): Exit or market multiple applied to the metric.
- `trl_discount` (number): TRL risk discount as a decimal (applied as 1 - discount).
- `variable_cost` (number): Variable cost per unit, currency units.

Output parameters:

- `assumptions` (array): Modelling assumptions applied.
- `chapter` (string): Source textbook chapter.
- `defaults_applied` (array): Optional parameters that were not supplied, so their documented defaults were used.
- `error` (string): Error message when the call fails.
- `formula_number` (string): Source textbook formula number (e.g. '3.1').
- `inputs` (object): Echo of the normalised inputs used.
- `method` (string): Formula / method name that produced the result.
- `steps` (array): Intermediate steps for traceability.
- `value` (number): Computed valuation or metric.

### `valuation_international` (~473 tokens)

International Valuation

Cross-border adjustments: purchasing-power parity, country risk premium, and international CAPM. Method selects the adjustment. Use for cross-border cash flows and country risk; pair with valuation_capm and valuation_time_value. Parameters apply per method: ppp needs spot_rate + inflation_foreign + inflation_domestic; country_risk_premium needs sovereign_yield + us_treasury_yield; intl_capm needs risk_free_rate + beta + mrp + crp. Not for the domestic cost of equity — for that use valuation_capm. Only method is required; all other parameters are method-dependent, so supply those the selected method names and omit the rest (defaults apply where defined). Rate and decimal inputs are fractions (0.10 = 10%); probability and weight lists are in [0,1] and sum to 1. Returns value, method, inputs, assumptions, chapter, formula_number and calculation steps; pure arithmetic — no I/O and no external calls — rounded to 2 decimals, with no auth or rate limits. An unknown method, or a missing method-required parameter, returns an error instead of a value.

Input parameters:

- `beta` (number): Systematic risk beta (market = 1.0).
- `crp` (number): Country risk premium as a decimal.
- `inflation_domestic` (number): Domestic inflation rate as a decimal.
- `inflation_foreign` (number): Foreign inflation rate as a decimal.
- `method` (string, required): Formula to apply. Options: ppp = Eₜ = E₀·(1+π_foreign)/(1+π_domestic).; country_risk_premium = CRP = sovereign yield - US Treasury yield.; intl_capm = r = Rf + β·MRP + CRP.
- `mrp` (number): Market risk premium as a decimal.
- `risk_free_rate` (number): Risk-free rate as a decimal (e.g. 0.04 for 4%).
- `sovereign_yield` (number): Foreign sovereign bond yield as a decimal.
- `spot_rate` (number): Spot FX rate (domestic per foreign), e.g. 7.2 CNY/USD.
- `us_treasury_yield` (number): US Treasury yield as a decimal.

Output parameters:

- `assumptions` (array): Modelling assumptions applied.
- `chapter` (string): Source textbook chapter.
- `defaults_applied` (array): Optional parameters that were not supplied, so their documented defaults were used.
- `error` (string): Error message when the call fails.
- `formula_number` (string): Source textbook formula number (e.g. '3.1').
- `inputs` (object): Echo of the normalised inputs used.
- `method` (string): Formula / method name that produced the result.
- `steps` (array): Intermediate steps for traceability.
- `value` (number): Computed valuation or metric.

### `valuation_stakeholder` (~1013 tokens)

Stakeholder & Equity Allocation

Allocate value across stakeholders and equity classes: single-round dilution, OPM common stock, PWERM, liquidation value, M&A synergy, employee-option values, vesting adjustment, cash-vs-equity break-even, and asset-based loan capacity. Method selects the model. Use only after the company-level value is known (from valuation_core, valuation_saas, or valuation_comparables) to split that value across the cap table; for the company value itself do not use this tool. Parameters apply per method: dilution needs ownership_before + investment + post_money; opm needs enterprise_value + liquidation_pref + time_to_exit + volatility; pwerm and employee_option need scenarios; liquidation needs assets + recovery_rates; risk_adjusted_synergy needs revenue_synergies + cost_synergies; vesting_adjusted needs total_value + vested_fraction; max_asset_loan takes collateral values. Only method is required; all other parameters are method-dependent, so supply those the selected method names and omit the rest (defaults apply where defined). Rate and decimal inputs are fractions (0.10 = 10%); probability and weight lists are in [0,1] and sum to 1. Returns value, method, inputs, assumptions, chapter, formula_number and calculation steps; pure arithmetic — no I/O and no external calls — rounded to 2 decimals, with no auth or rate limits. An unknown method, or a missing method-required parameter, returns an error instead of a value.

Input parameters:

- `accounts_receivable` (number): Accounts receivable, currency units.
- `annual_vest_rate` (number): Annual vesting rate as a decimal.
- `assets` (object): Map of asset name to book value, e.g. {"cash": 500000}.
- `cash` (number): Cash and equivalents, currency units.
- `cost_synergies` (number): Cost synergy value, currency units.
- `discount_rate` (number): Discount rate as a decimal (0.12 = 12%).
- `enterprise_value` (number): Enterprise value (market cap + net debt), currency units.
- `equipment` (number): Equipment, currency units.
- `equity_value` (number): Value of equity offered, currency units.
- `fair_market_value` (number): Current fair market value per share, currency units.
- `inventory` (number): Inventory, currency units.
- `investment` (number): Amount invested, currency units.
- `liquidation_pref` (number): Liquidation preference amount, currency units.
- `method` (string, required): Formula to apply. Options: dilution = Ownership = before × (1 - investment / post-money).; opm = Option-pricing allocation of equity value to common shares.; pwerm = Probability-weighted expected ret…
- `ownership_before` (number): Founder ownership before the round as a decimal (0.60 = 60%).
- `post_money` (number): Post-money valuation, currency units.
- `prob_cost` (number): Probability of realising cost synergies, 0-1.
- `prob_revenue` (number): Probability of realising revenue synergies, 0-1.
- `real_estate` (number): Real estate, currency units.
- `recovery_rates` (object): Map of asset name to recovery rate in [0,1], matching assets.
- `retention_prob` (number): Probability the holder stays, 0-1.
- `revenue_synergies` (number): Revenue synergy value, currency units.
- `salary_reduction` (number): Annual salary foregone for equity, currency units.
- `scenarios` (array): Scenario objects: {name: str, probability: 0-1, value: currency}; probabilities should sum to 1.
- `shares` (integer): Number of option shares.
- `strike_price` (number): Option strike price, currency units.
- `tax_rate` (number): Effective tax rate as a decimal in [0,1].
- `time_to_exit` (number): Expected time to exit / liquidity in years.
- `total_value` (number): Total grant value, currency units.
- `vested_fraction` (number): Fraction vested in [0,1].
- `volatility` (number): Annualised volatility σ as a decimal (0.80 = 80%).
- `years` (integer): Forecast horizon in years; integer ≥ 1.
- `years_remaining` (integer): Years of vesting remaining.

Output parameters:

- `assumptions` (array): Modelling assumptions applied.
- `chapter` (string): Source textbook chapter.
- `defaults_applied` (array): Optional parameters that were not supplied, so their documented defaults were used.
- `error` (string): Error message when the call fails.
- `formula_number` (string): Source textbook formula number (e.g. '3.1').
- `inputs` (object): Echo of the normalised inputs used.
- `method` (string): Formula / method name that produced the result.
- `steps` (array): Intermediate steps for traceability.
- `value` (number): Computed valuation or metric.

### `valuation_emerging` (~1077 tokens)

Emerging & Alternative Methods

Modern and alternative valuation: SAFE conversion (discount, cap, expected value), token valuation (equation of exchange, NVT), ESG adjustments (rate, premium, discount), Metcalfe network value, data-moat value, and remote-first premium/NPV. Method selects the model. Use for SAFEs, tokens, ESG, network effects, data moats, and remote-first adjustments; for classic pre-revenue methods use valuation_core. Parameters apply per method: safe_discount needs series_a_price + discount; safe_cap needs cap + series_a_price; safe_expected needs investment + cap + discount + series_a_valuation + series_a_price; token_value needs transaction_volume + price_per_tx + velocity + supply; metcalfe needs n; esg_* need base_valuation + a score; data_moat needs data_volume + data_uniqueness + monetization_rate + competitive_advantage_years. Routing: for classic pre-revenue methods (Scorecard, Berkus, Risk-Factor Summation, VC Method) use valuation_core; for options or scenario tables use valuation_advanced; for public-comparable multiples use valuation_comparables. Only method is required; all other parameters are method-dependent, so supply those the selected method names and omit the rest (defaults apply where defined). Rate and decimal inputs are fractions (0.10 = 10%); probability and weight lists are in [0,1] and sum to 1. Returns value, method, inputs, assumptions, chapter, formula_number and calculation steps; pure arithmetic — no I/O and no external calls — rounded to 2 decimals, with no auth or rate limits. An unknown method, or a missing method-required parameter, returns an error instead of a value.

Input parameters:

- `annual_savings` (number): Annual cost savings, currency units.
- `base_valuation` (number): Pre-adjustment baseline valuation, currency units.
- `cap` (number): SAFE valuation cap, currency units.
- `competitive_advantage_years` (number): Years the data moat is expected to last.
- `cost_savings_pct` (number): Cost savings as a fraction of baseline.
- `data_uniqueness` (number): Uniqueness / scarcity of the data in [0,1].
- `data_volume` (number): Volume of proprietary data held.
- `discount` (number): Conversion discount as a decimal (0.20 = 20% discount).
- `discount_per_point` (number): Valuation discount per ESG risk point as a decimal.
- `discount_rate` (number): Discount rate as a decimal (0.12 = 12%).
- `esg_opportunity_discount` (number): ESG opportunity discount subtracted from the rate.
- `esg_risk_premium` (number): ESG risk premium added to the rate, as a decimal.
- `esg_risk_score` (number): ESG risk score in points (higher = riskier).
- `esg_score` (number): ESG score in points (e.g. 0-100).
- `investment` (number): Amount invested, currency units.
- `k` (integer): Number of events k for the Poisson probability P(X=k); integer ≥ 0.
- `market_cap` (number): Market capitalisation, currency units.
- `method` (string, required): Formula to apply. Options: safe_discount = Price = Series A price × (1 - discount).; safe_cap = Price = cap / pre-money shares (cap-based).; safe_expected = Expected SAFE value across cap and discoun…
- `monetization_rate` (number): Fraction of data value monetisable as a decimal.
- `n` (number): Number of users or nodes in the network.
- `premium_per_point` (number): Valuation premium per ESG point as a decimal.
- `price_per_tx` (number): Protocol revenue per transaction, currency units.
- `productivity_gain` (number): Productivity gain as a decimal.
- `rate` (number): Per-period discount rate as a decimal (0.10 = 10%).
- `series_a_price` (number): Price per share in the next priced (Series A) round.
- `series_a_valuation` (number): Series A post-money valuation, currency units.
- `supply` (number): Circulating token supply.
- `talent_access_premium` (number): Talent-access premium as a decimal.
- `transaction_volume` (number): Total payment transaction volume, currency units.
- `velocity` (number): Token velocity (turnover of supply per period).

Output parameters:

- `assumptions` (array): Modelling assumptions applied.
- `chapter` (string): Source textbook chapter.
- `defaults_applied` (array): Optional parameters that were not supplied, so their documented defaults were used.
- `error` (string): Error message when the call fails.
- `formula_number` (string): Source textbook formula number (e.g. '3.1').
- `inputs` (object): Echo of the normalised inputs used.
- `method` (string): Formula / method name that produced the result.
- `steps` (array): Intermediate steps for traceability.
- `value` (number): Computed valuation or metric.

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/simonmak-ascent-startup-valuation/api#diagnostics

## Score history

- 2026-10-08: 74
- 2026-10-04: 72
- 2026-10-03: 71

## Common questions

### What is the Startup Valuation MCP Server server?

Startup Valuation MCP Server is listed in the public MCP registry as io.github.simonmak-ascent/startup-valuation. Startup valuation for AI agents: 14 tools, 80+ pre-revenue formulas. This page covers its hosted endpoint (https://startup-valuation.simonmak.com/api).

### Is the Startup Valuation MCP Server server safe to use?

Startup Valuation MCP Server scores 74 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Startup Valuation MCP Server server expose?

Startup Valuation MCP Server exposes 14 tools: valuation_probability, valuation_time_value, valuation_capm, valuation_core, valuation_advanced, and 9 more. Their descriptions and schemas cost roughly 8,946 tokens of context every time the server is loaded.

### Does the Startup Valuation MCP Server server require authentication?

No. We connected to Startup Valuation MCP Server without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the Startup Valuation MCP Server server still maintained?

Startup Valuation MCP Server is still listed as active in the MCP registry. We last reached this channel on 8 October 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Remote endpoint: https://startup-valuation.simonmak.com/api
- Repository: https://github.com/simonmak-ascent/startup-valuation
- Website: https://startup-valuation.simonmak.com/
- Changelog RSS feed: https://verifymcp.io/servers/simonmak-ascent-startup-valuation/api.xml
- Changelog JSON feed: https://verifymcp.io/servers/simonmak-ascent-startup-valuation/api.json
- HTML version of this page: https://verifymcp.io/servers/simonmak-ascent-startup-valuation/api