Neumann: Monte Carlo simulation in your AI chat

Neumann runs a Monte Carlo simulation over the uncertain inputs you describe and returns the resulting distribution, not a single guess. It's built for founders and operators stress-testing a plan — revenue, runway, delivery dates — right inside the AI chat assistant they already use.

Free anonymous tier: 3 runs per UTC day, up to 1,000 trials and 20 nodes per run — no sign-up needed.

Connects at https://neumann.kromatic.com/mcp. Questions? [email protected]. Privacy · Terms

  1. Pick your assistant below and open its MCP connector settings. No sign-up needed to start.
  2. Add the server URL: https://neumann.kromatic.com/mcp
  3. Ask your first question — try the prompt below.
  1. Open Claude.ai and go to Customize → Connectors, then choose "+ Add" → "Add custom connector".
  2. Name it "Neumann" and paste this server URL: https://neumann.kromatic.com/mcp
  3. Click Add, then turn it on in any chat from "+" → Connectors. On Team or Enterprise, an Owner adds it first under Organization settings → Connectors.
https://neumann.kromatic.com/mcp
Please add an MCP server named "neumann" at https://neumann.kromatic.com/mcp using the streamable HTTP transport, then confirm it's connected.
Simulate revenue = units × price where units ~ normal(mean 1000, sd 150) and price ~ triangular(18, 25, 40); run 1,000 trials and report p10/p50/p90 and the top sensitivity.
Neumann is newly launched, and it sleeps when idle. Production carries no application traffic yet, so its machines are allowed to stop when nothing is running and start again on the next request. Your first call may take noticeably longer than later ones while a machine boots — give the first request a generous client timeout and retry rather than treating a slow cold start as an outage. Once warm, calls are served immediately.
Related pages:
  • The Kromatic MCP estate — every public Kromatic MCP server
  • Fermi — the companion estimation server, good for producing the input ranges you feed Neumann, with its own separate authentication

Neumann serves its own machine-readable discovery documents — server.json, /.well-known/mcp.json, llms.txt and agents.md — from https://neumann.kromatic.com, built for whichever host you fetch them from. They are the canonical source for machine clients; this page is the human-readable version.

What Neumann is for

Use Neumann when a plan depends on several uncertain quantities at once and you want to know the shape of the outcome rather than a single best guess: revenue under uncertain demand and price, runway under uncertain burn, delivery dates under uncertain task durations. You supply root nodes (each an input drawn from a distribution), calc nodes (formulas over the values flowing into them), and edges naming those flows; Neumann samples the roots thousands of times and reports percentiles and summary statistics for every node.

Fermi and Neumann compose: ask Fermi for a calibrated range for each uncertain input, then hand those ranges to Neumann as root nodes to see what they imply together.

MCP endpoint

MCP-native clients connect to the Streamable HTTP transport at:

https://neumann.kromatic.com/mcp

With Claude Code, that is a single command:

claude mcp add neumann --transport http https://neumann.kromatic.com/mcp

Every tool also has a plain HTTP twin for clients that do not speak MCP: GET https://neumann.kromatic.com/mcp/tools lists them and POST https://neumann.kromatic.com/mcp/tools/<name> calls one. Simulations can additionally be submitted to POST https://neumann.kromatic.com/api/v1/runs, which supports streaming progress for long runs.

Authentication — sign in, or send a Bearer token

What a run costs depends on how you connect. There are three ways, and only the second has free runs of your own. None of them takes a credential as a tool argument: credentials travel only in the Authorization header of the request.

  • No account (anonymous) — send nothing. 3 free runs per UTC day, each model up to 1,000 trials and 20 nodes. A caller without an account is recognised by network address and client, so on a hosted platform such as Claude.ai or ChatGPT many callers share one identity: today’s free runs may already be spent by someone else.
  • Signed in with a free Kromatic account — when your client asks, sign in with your free Kromatic account (OAuth, issued by https://api.kromatic.com). That gives you 10 free runs per UTC day of your own. A free run must be a small model (trials × nodes × periods at most 100,000) and also stay within 10,000 trials and 50 nodes; free runs are spent before any credits. Claude, for example, offers the sign-in when the server asks for it.
  • An API-key account — created with the POST https://neumann.kromatic.com/api/v1/accounts described below. It authenticates you and starts with a grant of free credits, but it has no free daily runs at all: every run is paid in credits. Only signing in with a Kromatic account gives free daily runs.

Bearer token for headless clients and scripts

Create an account with a single unauthenticated POST — no body, no browser, no human approval:

curl -X POST https://neumann.kromatic.com/api/v1/accounts

The 201 response carries account_id, api_key, credit_balance and created_at. Keep the api_key secret.

Which credential goes where, in one line: on the MCP endpoint https://neumann.kromatic.com/mcp send Authorization: Bearer <key or nmn_pat_ token> — the account api_key or an opaque nmn_oat_ / nmn_pat_ token both work there. The plain HTTP twin accepts either X-API-Key: <api_key> or the same Bearer header. No Neumann tool takes an api_key argument.

Opaque nmn_pat_ tokens are minted by POST https://neumann.kromatic.com/api/v1/tokens and shown in plaintext exactly once; Neumann stores only a hash. Prefer one for long-lived integrations so the raw account key stays out of client configuration. With Claude Code:

claude mcp add neumann --transport http https://neumann.kromatic.com/mcp \
  --header "Authorization: Bearer <your nmn_pat_ token>"

Available tools

ToolDescription
run_monte_carlo_simulationRun a Monte Carlo simulation on a supplied graph. The full result comes back in the same call, so there is nothing to poll.
check_simulation_modelCheck a graph for structural and simulation-readiness problems before spending anything. Free.
estimate_simulation_size_and_costPre-flight a graph: its complexity, peak memory, run tier and credit cost, without running it. Free.
convert_range_to_distributionTurn a human estimate — “between X and Y, N% confident” — into engine-ready distribution_params.
convert_distribution_to_rangeTurn distribution parameters back into a plain min–max range. Free.
rank_inputs_by_impactOne-at-a-time sensitivity analysis: sweep each root over quantiles, measure how a target node responds, and return the drivers ranked as a tornado.
summarize_outcome_scenariosBest, median and worst scenario summaries for a target node.
get_simulation_resultsFetch an earlier run_monte_carlo_simulation result again by its run_id.
check_account_and_creditsCheck your account, credits and how many free runs are left today.
buy_creditsBuy more credits for your account: charges the card saved on the account, or returns a checkout link to save one. Needs an account; see Credits and access.
send_feedbackSend feedback, a feature request or a bug report to the Neumann team.

check_simulation_model and estimate_simulation_size_and_cost are free, so the cheap way to work is to check the model, estimate the cost, and only then run.

The live tool descriptors, including the full argument schemas, are served by Neumann itself at https://neumann.kromatic.com/mcp/tools. Treat that endpoint as authoritative if it ever disagrees with this table.

Worked example

Monthly revenue from an uncertain number of units sold at an uncertain price, over 1,000 trials. This uses the plain HTTP twin of run_monte_carlo_simulation, which is the easiest way to see the request and response shape:

curl -X POST https://neumann.kromatic.com/mcp/tools/run_monte_carlo_simulation \
  -H "Content-Type: application/json" \
  -d '{
  "graph": {
    "contract_version": "1.0",
    "root_nodes": [
      {
        "id": "units_sold",
        "name": "Units sold per month",
        "distribution_type": "normal",
        "distribution_params": {
          "mean": 1000,
          "std": 150
        }
      },
      {
        "id": "price_per_unit",
        "name": "Price per unit (USD)",
        "distribution_type": "triangle",
        "distribution_params": {
          "min_val": 18,
          "mode_val": 25,
          "max_val": 40
        }
      }
    ],
    "calc_nodes": [
      {
        "id": "revenue",
        "name": "Monthly revenue (USD)",
        "formula": "{e_units} * {e_price}"
      }
    ],
    "edges": [
      {
        "id": "e_units",
        "source": "units_sold",
        "target": "revenue"
      },
      {
        "id": "e_price",
        "source": "price_per_unit",
        "target": "revenue"
      }
    ],
    "run_params": {
      "trials": 1000,
      "time_periods": 1
    }
  },
  "seed": 42
}'

This call carries no credentials, so it uses the free anonymous tier (up to 1,000 trials per run). With an account, add -H "Authorization: Bearer <your key or token>" and raise trials beyond the free limits. The run comes back in the same call, with a run_id, a completed status, the run tier and the credits debited, plus per-node results: percentiles (p10, p50, p90) and basic_stats (mean, std, min, max) for each node and time period. Passing a seed makes the run reproducible.

The one gotcha worth knowing: {time_period} is 1-based inside formulas — the first period is 1 — while post-simulation aggregations such as npv, irr and payback index periods from 0. A mask written {time_period} == 0 inside a formula silently never fires.

Credits and access

Credits pay for what the free runs do not cover: once the day’s free runs are gone, or for a model too large to run free, a run is billed per-credit according to its tier — a large run costs more than a small one, and estimate_simulation_size_and_cost will tell you which tier a graph falls into before you run it. An API-key account starts with a grant of free credits so you can try it immediately, but it has no free daily runs; only signing in with a Kromatic account gives those. A Kromatic membership does not include Neumann access or a discount; the two are priced separately.

Buying more credits needs an account. Connect with your account’s Bearer credential, then call the buy_credits tool: it charges the card saved on your account, or, if none is saved yet, returns a Stripe checkout link to open in your browser and save one. Every other tool works without an account, and signing in with Kromatic needs no card. For anything else about billing, reach us through the contact form.

The price per credit is published by the service itself at https://neumann.kromatic.com/billing/pricing, so it is always the live number rather than a figure copied onto this page.

Powered bylogo
Copyright © 2026 Kromatic