AI hallucinates numbers. Forge doesn't.

YAML-based financial modeling with Excel formula evaluation. Git-native. Deterministic. Battle-tested against Gnumeric and R.

Excel burns tokens. YAML doesn't. AI is trained on millions of YAML files. Not spreadsheets.

The math: A 50KB Excel file can burn 100K+ tokens when parsed. The same model in YAML? Under 2K tokens.

Don't trust us. Trust Gnumeric and R.

Every Forge formula is validated against independent, battle-tested open-source tools:

┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│  Forge YAML     │ ──► │  Export XLSX    │ ──► │  Gnumeric       │
│  =NPV(0.1, cf)  │     │  with formulas  │     │  recalculates   │
└─────────────────┘     └─────────────────┘     └─────────────────┘
                                                        │
                                                        ▼
                                                ┌─────────────────┐
                                                │  Compare CSV    │
                                                │  Forge = Gnumeric│
                                                └─────────────────┘

If Gnumeric and R agree with Forge, the math is right. No "trust me" - just proof.

• No circular dependencies - Forge doesn't validate itself
• Peer-reviewed tools - Gnumeric and R are industry standards
• Regulatory-grade - R is used by FDA, EMA for drug approval calculations
• 2,957 statistical conditions - Not just "does it run" but "is the math correct"

Forge isn't Excel 2.0. It's a purpose-built FP&A engine with 7 analytical capabilities Excel cannot replicate:

Model uncertainty with probability distributions. Run 10,000+ iterations to get P10/P50/P90 outcomes.

assumptions:
  revenue_growth:
    formula: "=MC.Normal(0.15, 0.05)"  # Mean 15%, StdDev 5%

  project_cost:
    formula: "=MC.Triangular(80000, 100000, 150000)"  # Min/Mode/Max

6 distributions: Normal, Triangular, Uniform, PERT, Lognormal, Discrete

Generate confidence intervals from historical data without assuming a distribution.

bootstrap:
  iterations: 10000
  confidence_levels: [0.90, 0.95, 0.99]
  data: [0.05, -0.02, 0.08, 0.03, ...]  # Historical returns

R-validated against the boot package.

Model sequential decisions with backward induction. Forge finds the optimal path automatically.

decision_tree:
  root:
    type: decision
    name: "Invest in R&D?"
    branches:
      invest:
        cost: 2000000
        next: tech_outcome
      dont_invest:
        value: 0

Quantify the value of managerial flexibility using Black-Scholes and binomial methods.

QuantLib-validated pricing models.

One-at-a-time sensitivity analysis. Instantly see what drives variance.

NPV Sensitivity Analysis (Base: $1.2M)

Revenue Growth    |████████████████████| ± $450K
Discount Rate     |██████████████      | ± $320K
Operating Margin  |██████████          | ± $180K
Tax Rate          |████                | ± $75K

Probabilistic graphical models for causal reasoning. Model how risks cascade.

bayesian_network:
  nodes:
    economic_conditions:
      states: ["good", "neutral", "bad"]
      prior: [0.3, 0.5, 0.2]

    default_probability:
      parents: ["economic_conditions", "management_quality"]
      # Conditional probability tables...

pgmpy-validated inference algorithms.

Probability-weighted scenarios with expected value calculation.

scenarios:
  bull_case:
    probability: 0.30
    scalars:
      revenue_growth: 0.25

  bear_case:
    probability: 0.20
    scalars:
      revenue_growth: -0.10

Forge speaks Claude's language. 10 tools for AI agents via Model Context Protocol:

{
  "mcpServers": {
    "forge": {
      "command": "forge",
      "args": ["mcp"]
    }
  }
}

Roadmap Note: MCP currently exposes 10 of 17 CLI features. The 7 analytical engines (Monte Carlo, Bootstrap, Bayesian, Decision Trees, Real Options, Tornado, Scenarios) are CLI-only for now. API server has 5 endpoints. Full MCP/API parity + OpenAPI spec planned for v10.0.0-beta.1 after E2E validation against R and Gnumeric is complete.

50x token efficiency. Claude processes YAML at a fraction of Excel's token cost.

All Excel-compatible functions plus 6 FP&A-native functions Excel doesn't have.

Run forge functions for full syntax and examples.

Every analyst builds these manually. Forge has them built-in:

# VARIANCE - What Excel makes you do manually
variance_analysis:
  revenue_var: "=VARIANCE(actual.revenue, budget.revenue)"           # Returns: -5000
  revenue_pct: "=VARIANCE_PCT(actual.revenue, budget.revenue)"       # Returns: -5%
  revenue_status: "=VARIANCE_STATUS(actual.revenue, budget.revenue)" # Returns: MISS

# BREAKEVEN - Instant unit economics
breakeven:
  units_required: "=BREAKEVEN_UNITS(500000, 150, 60)"     # Returns: 5,556 units
  revenue_required: "=BREAKEVEN_REVENUE(500000, 0.60)"    # Returns: $833,333

Type-aware variance: Costs use inverted logic (under budget = BEAT).

# Install from source
cargo install --path .

# Or use the Makefile
make install-forge

# Validate a model
forge validate model.yaml

# Calculate with scenario
forge calculate model.yaml --scenario optimistic

# Export to Excel (formulas intact)
forge export model.yaml output.xlsx

_forge_version: "5.0.0"

assumptions:
  revenue_y1: 1000000
  growth_rate: 0.15
  gross_margin: 0.65
  opex_pct: 0.30
  tax_rate: 0.25
  discount_rate: 0.10

projections:
  year: [1, 2, 3, 4, 5]
  revenue: "=assumptions.revenue_y1 * (1 + assumptions.growth_rate) ^ (year - 1)"
  gross_profit: "=revenue * assumptions.gross_margin"
  opex: "=revenue * assumptions.opex_pct"
  ebit: "=gross_profit - opex"
  tax: "=MAX(0, ebit * assumptions.tax_rate)"
  net_income: "=ebit - tax"

valuation:
  total_revenue: "=SUM(projections.revenue)"
  avg_margin: "=AVERAGE(projections.gross_profit / projections.revenue)"
  npv_cash_flows: "=NPV(assumptions.discount_rate, projections.net_income)"
  irr: "=IRR(projections.net_income)"

scenarios:
  base:
    growth_rate: 0.15
  bull:
    growth_rate: 0.25
    gross_margin: 0.70
  bear:
    growth_rate: 0.05
    gross_margin: 0.55

forge calculate model.yaml --scenario bull
forge sensitivity model.yaml -v growth_rate -r 0.05,0.30,0.05 -o npv_cash_flows
forge export model.yaml valuation.xlsx

# Core Operations
forge validate <files...>           # Validate YAML model(s)
forge calculate <file>              # Execute all formulas
forge audit <file> <variable>       # Trace formula dependencies

# Analysis
forge sensitivity <file> -v VAR -r RANGE -o OUTPUT
forge goal-seek <file> --target VAR --value N --vary INPUT
forge break-even <file> -o OUTPUT -v INPUT
forge variance <budget> <actual> --threshold PCT

# Prediction & Simulation
forge simulate <file> --iterations N    # Monte Carlo
forge scenarios <file>                  # Scenario analysis
forge decision-tree <file>              # Decision trees
forge real-options <file>               # Real options
forge tornado <file>                    # Tornado diagrams
forge bootstrap <file>                  # Bootstrap resampling

# Excel Bridge
forge export <yaml> <xlsx>          # YAML → Excel with formulas
forge import <xlsx> <yaml>          # Excel → YAML

# AI Integration
forge mcp                           # Start MCP server
forge serve --port 8080             # Start REST API

# Reference
forge functions                     # List all 173 functions

forge (inline unit tests)     forge-e2e (integration/E2E)
├── 1,297 unit tests          ├── 836 E2E tests
├── #[cfg(test)] modules      ├── Gnumeric validation
└── Per-function coverage     └── R statistical validation

cargo test                              # Run all tests
cargo clippy -- -D warnings             # Zero warnings policy
make check                              # Full CI check

Elastic License 2.0 - See LICENSE

Forge is Source Available - the code is open for inspection, but commercial production use requires a license.

┌─────────────────────────────────────────────────────────────┐
│  Source Available ≠ Open Source                            │
│                                                             │
│  • Code is OPEN (you can read it, audit it, learn from it) │
│  • Use is FREE for evaluation and non-production           │
│  • Production use in commercial settings requires license  │
│  • You cannot offer Forge as a hosted service              │
│                                                             │
│  Used by: Elasticsearch, Kibana (Elastic NV)               │
└─────────────────────────────────────────────────────────────┘

Finance needs auditable code. You can verify every calculation. No black boxes.

But building enterprise software requires sustainable revenue. Elastic-2.0 balances transparency with commercial viability - without ever converting to open source.

For production deployment or enterprise support:

Open a GitHub Issue: github.com/royalbit/forge/issues (use licensing label)

See COMMERCIAL_LICENSE.md for details.

Built with RoyalBit Asimov - The AI autonomy framework.