openvaluation

What it does

A Python library implementing eight startup valuation methods, with every result carrying its derivation.

Developers, accelerators, investors and teachers who need reusable, auditable early-stage valuation calculations. The methods themselves live in textbooks, angel-group worksheets and spreadsheets; there was no maintained open-source implementation.

Method constants

Implemented from their published descriptions, cited in the documentation, and exposed as constructor arguments rather than buried literals.

• Scorecard weights: 30% team, 25% opportunity, 15% product, 10% competition, 10% sales, 5% need for further investment, 5% other (Bill Payne).
• Berkus Method: five elements, up to $500,000 each, capping pre-money value at $2,500,000.
• Risk Factor Summation: twelve risk factors, $250,000 per rating step, adjusting a comparable average by at most ±$6,000,000.
• VC Method baseline discount rates: 60% at seed, 50% at Series A, 40% at Series B.

Why it exists

The pre-revenue methods angel groups actually use live in textbooks, worksheets and spreadsheets, but not in maintained software; commercial tools that implement them keep the arithmetic closed. And language models, asked constantly what a startup is worth, are good at reading a pitch deck and bad at the arithmetic. openvaluation draws the line between those two jobs: the model extracts structured facts, the engine computes — deterministically, with the full derivation attached. Same input, same output, every time.

Pitch deck in, defensible valuation range out — deterministically, from any AI agent.

Maturity and status

• Maturity: Deployed — first released on PyPI and GitHub on 22 August 2026; current release v0.1.1, 24 August 2026. No independent third-party reproduction or adoption is claimed.
• Role: Sole author and maintainer — Ruiqi Tan.
• Licence: MIT. Language: Python, Python 3.9–3.13. Runtime dependencies: none; the MCP server is an optional extra.
• Tests: 311 tests, run in CI across Python 3.9–3.13.
• Last updated: 24 August 2026 (v0.1.1 — documentation and metadata only; no calculation changed).

Extracted from the valuation engine I built for Wakeworth, a production valuation product — rewritten against the methods' published sources for standalone release.

How it works

Input is a plain nested dictionary of company facts — whatever an extraction step produced. A readiness layer reports which methods the available data supports, and which single missing field would unlock the most. Every method that runs returns its result with the arithmetic steps, the assumptions, the limitations and citations for the method and any market data used. Market benchmarks are injected through a BenchmarkProvider: the shipped defaults are labelled illustrative placeholders, and any result that touches them carries that caveat in its own limitations.

berkus: 1,900,000 USD (range 1,400,000–2,400,000)

Steps
  1. Sound idea — basic value, product risk: 500,000  — rating 1.00
  2. Prototype — technology risk: 500,000  — rating 1.00
  3. Quality management team — execution risk: 400,000  — rating 0.80
  4. Strategic relationships — market risk: 200,000  — rating 0.40
  5. Product rollout or sales — production risk: 300,000  — rating 0.60
  6. Pre-money valuation: 1,900,000  — sum of five elements

Assumptions
  cap_per_element: 500000.0

Limitations
  - Berkus caps pre-revenue value and ignores market size, growth and financials.
  - Ratings are judgements, not measurements; this run capped at 2,500,000.

Sources
  - Dave Berkus, 'The Berkus Method: Valuing an Early Stage Investment'

Actual output of result.explain() for one method; this example, like every example in the package documentation, is executed by the test suite.

For AI agents

An MCP server (pip install "openvaluation[mcp]", run as openvaluation-mcp) exposes four tools, so any MCP-capable model can value a company without doing arithmetic itself:

The server's instructions tell the model what it would otherwise get wrong: that ratings are judgements needing evidence, that shipped benchmark figures are placeholders whose caveat must travel with the number, and that a median alone is not the answer. The same four functions are importable without MCP, for an HTTP handler or a notebook.

Evidence

Every claim above links to the released state it describes (tag v0.1.1), not to a moving branch:

• Release v0.1.1 on GitHub · openvaluation 0.1.1 on PyPI · Changelog
• Documentation index — one page per method — and the FAQ
• tests/test_docs.py — executes every documented example · tests/test_methods.py — the method arithmetic
• src/openvaluation/mcp_server.py — the MCP server behind the agent tools
• CITATION.cff — machine-readable citation metadata

Where it sits in the larger system

openvaluation is the calculation layer of a product I built alone — extracted, rewritten from published sources, and released so the arithmetic can be checked by anyone. It is what the "governed AI systems" claim looks like in practice: the probabilistic part (reading documents) stays with the model, the part that must be reproducible (the arithmetic) is deterministic code with its derivation attached.

Related

• Wakeworth — the production valuation product these methods were extracted from; also available as the public application.
• Ruiqi Tan — author and maintainer.