# Neumann (remote · neumann.kromatic.com)

Monte Carlo ranges for uncertain plans: project cost, budget, timeline, capacity, NPV/IRR/payback.

- Trust score: 64/100 (medium)
- Change this week: +2
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- remote · `neumann.kromatic.com`: 64/100 (this document), [markdown](https://verifymcp.io/servers/kromatic-innovation-neumann/neumann.md), [page](https://verifymcp.io/servers/kromatic-innovation-neumann/neumann)

## Channel facts

- Endpoint: `https://neumann.kromatic.com/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `0.2.34`

## 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-11-05.

- **Endpoint Security**: 57/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation check failed: no authorisation is required to call this server, and it exposes a tool marked destructive (buy_credits).
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - 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**: 74/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 6898 tokens (~530/item across 13 items; 11 tools + 2 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability check failed: schema churn in the 8 days we've observed: 9 tool removals, 0 breaking changes, 0 auth/transport breaks, 10 additions.
- **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.
  - All 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 13 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the Neumann MCP server?

Neumann is a hosted endpoint at https://neumann.kromatic.com/mcp, 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 kromatic-innovation-neumann 'https://neumann.kromatic.com/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "kromatic-innovation-neumann": {
      "url": "https://neumann.kromatic.com/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "kromatic-innovation-neumann": {
      "type": "http",
      "url": "https://neumann.kromatic.com/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.kromatic-innovation-neumann]
url = "https://neumann.kromatic.com/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "kromatic-innovation-neumann": {
      "type": "remote",
      "url": "https://neumann.kromatic.com/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add kromatic-innovation-neumann --url 'https://neumann.kromatic.com/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  kromatic-innovation-neumann:
    url: "https://neumann.kromatic.com/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "kromatic-innovation-neumann": {
      "Transport": "http",
      "Url": "https://neumann.kromatic.com/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add kromatic-innovation-neumann -t streamable-http -u 'https://neumann.kromatic.com/mcp'
```

### Other

```json
{
  "mcpServers": {
    "kromatic-innovation-neumann": {
      "type": "http",
      "url": "https://neumann.kromatic.com/mcp"
    }
  }
}
```

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-31 (score 64, 0)

- [security] Tool “send_feedback” rewrote its description, which is the text the model reads
- [functional] Server version: 0.2.32 → 0.2.34

### 2026-10-30 (score 64, +2)

- [security] The server rewrote its instructions, which are the text every model session reads
- [security] Tool “estimate_simulation_size_and_cost” rewrote its description, which is the text the model reads
- [security] Tool “get_simulation_results” rewrote its description, which is the text the model reads
- [security] Tool “rank_inputs_by_impact” rewrote its description, which is the text the model reads
- [security] Tool “summarize_outcome_scenarios” rewrote its description, which is the text the model reads
- [security] Tool “buy_credits” rewrote its description, which is the text the model reads
- [security] Tool “check_account_and_credits” rewrote its description, which is the text the model reads
- [security] Tool “send_feedback” rewrote its description, which is the text the model reads
- [security] Tool “run_monte_carlo_simulation” rewrote its description, which is the text the model reads
- [functional regression] Schema quality: 5830 → 6880
- [functional improvement] Schema quality: 530 → 476
- [functional] The server now declares the “prompts” capability
- [functional] The server now declares the “resources” capability
- [functional] First check of Schema quality: 100
- [functional] New prompt “model_business_idea”
- [functional] New resource “catalog”
- [functional] New resource “example-graph”
- [functional] Server version: 0.2.31 → 0.2.32
- [functional] Server version: 0.2.28 → 0.2.31
- [functional] Server version: 0.2.25 → 0.2.28
- [functional] Server version: 0.2.16 → 0.2.25
- [functional] Server version: 0.2.10 → 0.2.16
- [cosmetic] “get_simulation_results” added an optional parameter “histogram”
- [cosmetic] “get_simulation_results” added an optional parameter “nodes”
- [cosmetic] “get_simulation_results” added an optional parameter “percentiles”
- [cosmetic] “get_simulation_results” added an optional parameter “period_from”
- [cosmetic] “get_simulation_results” added an optional parameter “period_to”
- [cosmetic] “get_simulation_results” added an optional parameter “periods”
- [cosmetic] “get_simulation_results” added an optional parameter “threshold”
- [cosmetic] “get_simulation_results” added an optional parameter “threshold_direction”
- [cosmetic] “get_simulation_results” added an optional parameter “wait_seconds”
- [cosmetic] “rank_inputs_by_impact” added an optional parameter “detail”
- [cosmetic] “send_feedback” added an optional parameter “error_text”
- [cosmetic] “send_feedback” added an optional parameter “expected”
- [cosmetic] “send_feedback” added an optional parameter “impact”
- [cosmetic] “send_feedback” added an optional parameter “run_id”
- [cosmetic] “send_feedback” added an optional parameter “suggestion”
- [cosmetic] “send_feedback” added an optional parameter “tool_name”
- [cosmetic] “send_feedback” added an optional parameter “user_goal”
- [cosmetic] “send_feedback” added an optional parameter “what_happened”
- [cosmetic] “run_monte_carlo_simulation” added an optional parameter “detail”
- [cosmetic] “get_simulation_results” reworded the description of “run_id”
- [cosmetic] “run_monte_carlo_simulation” reworded the description of “detail”
- [cosmetic] “send_feedback” reworded the description of “feedback_type”
- [cosmetic] “send_feedback” reworded the description of “message”
- [cosmetic] “send_feedback” reworded the description of “sender_email”
- [cosmetic] “summarize_outcome_scenarios” reworded the description of “percentiles”
- [cosmetic] “buy_credits” dropped the optional parameter “api_key”
- [cosmetic] “check_account_and_credits” dropped the optional parameter “api_key”
- [cosmetic] “check_simulation_model” dropped the optional parameter “api_key”
- [cosmetic] “convert_distribution_to_range” dropped the optional parameter “api_key”
- [cosmetic] “convert_range_to_distribution” dropped the optional parameter “api_key”
- [cosmetic] “estimate_simulation_size_and_cost” dropped the optional parameter “api_key”
- [cosmetic] “get_simulation_results” dropped the optional parameter “api_key”
- [cosmetic] “rank_inputs_by_impact” dropped the optional parameter “api_key”
- [cosmetic] “run_monte_carlo_simulation” dropped the optional parameter “api_key”
- [cosmetic] “send_feedback” dropped the optional parameter “api_key”
- [cosmetic] “summarize_outcome_scenarios” dropped the optional parameter “api_key”
- [cosmetic] “send_feedback” made “feedback_type” optional
- [cosmetic] “send_feedback” made “sender_email” optional

### 2026-10-29 (score 62, 0)

- [security regression] Stability: unverified → fail
- [security regression] Tool “estimate” was removed
- [security regression] Tool “feedback” was removed
- [security regression] Tool “get_results” was removed
- [security regression] Tool “oat_sensitivity” was removed
- [security regression] Tool “run_simulation” was removed
- [security regression] Tool “scenario_analysis” was removed
- [security regression] Tool “share_result” was removed
- [security regression] Tool “solve_distribution_parameters” was removed
- [security regression] Tool “validate_graph” was removed
- [security] The server rewrote its instructions, which are the text every model session reads
- [security] Tool “buy_credits” rewrote its description, which is the text the model reads
- [functional regression] Schema quality: 230 → 530
- [functional improvement] Stability: unverified → 0.03
- [functional] Server version: 0.1.5 → 0.2.10
- [functional] New tool “check_account_and_credits”
- [functional] New tool “check_simulation_model”
- [functional] New tool “convert_distribution_to_range”
- [functional] New tool “convert_range_to_distribution”
- [functional] New tool “estimate_simulation_size_and_cost”
- [functional] New tool “get_simulation_results”
- [functional] New tool “rank_inputs_by_impact”
- [functional] New tool “run_monte_carlo_simulation”
- [functional] New tool “send_feedback”
- [functional] New tool “summarize_outcome_scenarios”
- [cosmetic] “buy_credits” reworded the description of “api_key”
- [cosmetic] “buy_credits” reworded the description of “credits”
- [cosmetic] Tool “buy_credits” changed its title: Buy credits → Buy Neumann credits with your saved card

### 2026-10-28 (score 62)

First indexed and scored.

## MCP tools (11)

### `run_monte_carlo_simulation` (~754 tokens)

Run a Monte Carlo simulation of a model

Runs a Monte Carlo simulation of a model and returns the full range of possible outcomes, not one guessed number. A model is a set of uncertain inputs, the formulas that combine them, and the links between them. The simulation draws random values for every input many times; each draw is a trial, and one call is one run. Use this when you need to know how likely different outcomes are for a plan built on uncertain inputs: a project's total cost or budget (for example from low / most likely / high estimates per line item), a schedule or delivery date, capacity, revenue, or an investment's NPV, IRR or payback. It returns a summary: for each output node (the nodes nothing else depends on, or the ones you list in run_params.output_request.nodes) the mean, the 10th, 50th and 90th percentiles (the value that share of trials fall below), the minimum and maximum in the last time period, and the same per period; plus any metrics you asked for, such as NPV, IRR, payback or the chance of beating a target or budget; and a run_id. Pass that run_id to get_simulation_results for other nodes, periods or percentiles. A run that takes longer than about 40 seconds keeps running in the background: you get status running and a run_id, and get_simulation_results gives you progress and then the result. Cost: without an account, 1 of your 3 free runs per UTC day (models up to 1,000 trials and 20 nodes); with an account, 1 credit for a small run or 5 for a large one, currently $0.50 per credit. A model that is invalid or over the no-account limits is rejected before running and costs nothing. If it fails mid-run: anonymous, the free run is used; account, not charged.

Input parameters:

- `detail` (string): How much to return. summary (the default): the output nodes' mean, 10th/50th/90th percentiles, minimum and maximum, a compact per-period series, and your metrics. full: every node and edge in every p…
- `graph` (object, required): The model. A model has four parts. root_nodes are the uncertain inputs; each one draws a value from a probability distribution in every trial. calc_nodes are formulas that combine values. edges are l…
- `seed`: Optional whole number that fixes the random draws, so repeating the call gives the same result. Exact repeats are guaranteed only for small runs, where trials × nodes × time periods is at most 100,00…

Output parameters:

- `billing`: Who you are and what this call cost.
- `credits_debited` (integer): Credits charged (0 without an account).
- `estimated_seconds`: Rough total run time, in seconds.
- `next_step`: What to do while the run is still going.
- `progress`: Percent done while the run is running or queued.
- `result`: Every node and edge per period (only with detail full).
- `run_id` (string): Id of this run. Pass it to get_simulation_results for progress, the result, or specific numbers.
- `status` (string): completed, or running / queued: the run continues in the background, so call get_simulation_results with run_id. A run that fails within this call returns an error instead.
- `summary`: The headline numbers (the default).
- `tier` (string): small or large; sets the credit price for an account.
- `total_trials` (integer): Number of trials run.
- `truncation`: Present only when the summary left data out to stay small: what was left out and how to get it.

### `rank_inputs_by_impact` (~934 tokens)

Rank which inputs drive an outcome most (one-at-a-time sensitivity)

Ranks a model's uncertain inputs by how much each one moves a chosen outcome, and returns the data for a tornado chart. A tornado chart is a bar chart with one horizontal bar per input, sorted with the biggest swing at the top. This is a one-at-a-time (OAT) sensitivity analysis. Every input is held at its median while one input at a time is set to low, middle and high values from its own distribution (by default its 5th, 50th and 95th percentiles). The tool records how the outcome's average changes. Use this when you need to know which assumption matters most, so you know what to research or de-risk first. It returns one entry per input, ranked so rank 1 has the biggest impact. Each entry lists the input values tried, the outcome at each, and an elasticity score. Elasticity means how strongly the outcome reacts: roughly, how many percent the outcome moves when the input moves 1 percent. It returns numbers, not an image. Inputs whose distribution produces a list of values are skipped. It always returns a run_id. It runs the model once per input per value tried, so on a big model it can take minutes: if it is not done in about 40 seconds you get status running, and get_simulation_results gives you progress and then the ranking. Cost: without an account, 1 of your 3 free runs per UTC day for each call, even though the analysis runs the model many times (models up to 1,000 trials and 20 nodes); with an account, 1 credit for a small model or 5 for a large one, currently $0.50 per credit. A model that is invalid or over the no-account limits is rejected before running and costs nothing. If it fails mid-run: anonymous, the free run is used; account, already charged, because this tool charges when the analysis starts.

Input parameters:

- `detail` (string): How much to return. summary (the default): one row per input with its rank, its low and high values, the outcome at each, the swing between them and its elasticity. full: also each input's whole resp…
- `graph` (object, required): The model: root_nodes (uncertain inputs), calc_nodes (formulas), edges (links; formulas refer to them like {e1}) and run_params (trials and time periods). Same format as run_monte_carlo_simulation's…
- `num_quantiles`: Instead of quantiles: how many points to try, an even whole number from 2 to 10. That many percentiles are spread evenly between the 5th and 95th, and the median (0.5) is added. 2 gives [0.05, 0.5, 0…
- `quantiles`: A list of points in each input's own distribution to try. Each point is a fraction from 0 to 1 naming a percentile: 0.05 is the 5th percentile, the value 5% of outcomes fall below. Default [0.05, 0.5…
- `seed`: Optional whole number that fixes the random draws, so repeating the call gives the same result. Exact repeats are guaranteed only for small runs, where trials × nodes × time periods is at most 100,00…
- `target_node_id`: The id of the outcome node to measure. Defaults to the last calc node in the model, which is usually the final outcome.
- `time_period`: Index of the time period to measure, counting from 0: with 12 monthly periods, 11 is month 12. Defaults to the last period. This measures the node's value in that one period, not a total. For a cumul…

Output parameters:

- `baseline_outcome`: The outcome's mean with every input at its median.
- `billing`: Who you are and what this call cost: principal, auth source, credits debited and balance, or the anonymous allowance left today.
- `credits_debited` (integer): Credits charged (0 without an account).
- `estimated_seconds`: Rough total run time, in seconds.
- `inputs_not_shown` (integer)
- `next_step`: What to do next while the run is still going.
- `progress`: Present while the run is queued or running.
- `quantiles` (array): The percentiles of each input that were tried, as fractions.
- `results` (array): One entry per input, in rank order (rank 1 = biggest impact).
- `run_id`
- `runs_executed` (integer): Internal simulation runs used: 1 baseline plus inputs × quantiles. You are billed once.
- `status` (string)
- `target_node_id` (string): The outcome node measured.
- `time_period` (integer): The period measured (index counted from 0).
- `tornado` (array)

### `summarize_outcome_scenarios` (~758 tokens)

Summarize worst, median and best outcomes

Runs a model once and reports one outcome's worst, median and best values. By default, worst is the lowest value in any trial, median is the middle value, and best is the highest value. Worst always means lowest, so for a cost the worst case is the cheapest one. You can ask for other percentiles instead, such as the 10th and 90th. Use this when you want a short worst, typical and best case story rather than the full distribution. For the full distribution, use run_monte_carlo_simulation. To find which input matters most, use rank_inputs_by_impact. It returns each scenario's outcome value and every input's own value at the same percentile. Those input values are an estimate, not the exact inputs of that trial. It also returns a run_id; a long run comes back as status running, and get_simulation_results gives you progress and then the result. Cost: without an account, 1 of your 3 free runs per UTC day (models up to 1,000 trials and 20 nodes); with an account, 1 credit for a small run or 5 for a large one, currently $0.50 per credit. A model that is invalid or over the no-account limits is rejected before running and costs nothing. If it fails mid-run: anonymous, the free run is used; account, not charged.

Input parameters:

- `graph` (object, required): The model: root_nodes (uncertain inputs), calc_nodes (formulas), edges (links; formulas refer to them like {e1}) and run_params (trials and time periods). Same format as run_monte_carlo_simulation's…
- `percentiles`: A list of percentiles of the outcome to report. Each is a fraction from 0 to 1: 0.1 is the 10th percentile, the value 10% of trials fall below. Default [0, 0.5, 1]: 0 is the lowest trial (labelled wo…
- `seed`: Optional whole number that fixes the random draws, so repeating the call gives the same result. Exact repeats are guaranteed only for small runs, where trials × nodes × time periods is at most 100,00…
- `target_node_id`: The id of the outcome node to measure. Defaults to the last calc node in the model, which is usually the final outcome.
- `time_period`: Index of the time period to measure, counting from 0: with 12 monthly periods, 11 is month 12. Defaults to the last period. This measures the node's value in that one period, not a total. For a cumul…

Output parameters:

- `billing`: Who you are and what this call cost: principal, auth source, credits debited and balance, or the anonymous allowance left today.
- `credits_debited` (integer): Credits charged (0 without an account).
- `estimated_seconds`: Rough total run time, in seconds.
- `next_step`: What to do next while the run is still going.
- `progress`: Present while the run is queued or running.
- `run_id`
- `runs_executed` (integer): Always 1; one run is reused for every scenario.
- `scenarios` (array): One entry per percentile, lowest first.
- `status` (string)
- `target_node_id` (string): The outcome node measured.
- `time_period` (integer): The period measured (index counted from 0).
- `trials` (integer): Number of trials in the run.

### `check_simulation_model` (~296 tokens)

Check a simulation model for errors before running it

Checks a model for mistakes before you run it and lists every problem it finds. It looks for loops with no delay, nodes that are not connected, unknown distributions, missing or invalid distribution parameters, and broken formulas. A loop, including an edge from a node to itself, is allowed and is not an error when at least one edge in it has delay 1 or more. Use this when you have built or edited a model and want to fix it without spending a run. To see what a run will cost, use estimate_simulation_size_and_cost instead. It returns is_valid and a list of issues. Each issue gives the rule broken, a severity (error, warning or info, where info is only a note), a message, and the node and edge ids involved. If an edge points at a node that does not exist, you get an error message instead of the list. Cost: free; uses no credits and no free runs. Without an account, a model over 1,000 trials or 20 nodes is rejected, also at no cost.

Input parameters:

- `graph` (object, required): The model: root_nodes (uncertain inputs), calc_nodes (formulas), edges (links; formulas refer to them like {e1}) and run_params (trials and time periods). Same format as run_monte_carlo_simulation's…

Output parameters:

- `billing`: Who you are and what this call cost: principal, auth source, credits debited and balance, or the anonymous allowance left today.
- `is_valid` (boolean): true when there are no errors. Warnings and info notes do not make it false.
- `issues` (array)

### `estimate_simulation_size_and_cost` (~340 tokens)

Estimate a simulation's cost and size before running it

Predicts how large a run of a model will be and how many credits it will cost, without running it. Use this before running a large or unfamiliar model, or to check that an account can afford it. It does not look for mistakes; use check_simulation_model for that. It returns the number of trials, time periods, nodes and edges, the estimated peak memory in MB, a complexity score, the size tier (small or large), the credit cost for an account, and a rough run time in seconds for run_monte_carlo_simulation and for rank_inputs_by_impact (which runs the model many times). Runs over about 40 seconds continue in the background and are collected with get_simulation_results. A run is small when trials × nodes × time periods is at most 100,000, and large otherwise. Accounts have no fixed trial or node limit. That cost is what run_monte_carlo_simulation, summarize_outcome_scenarios and rank_inputs_by_impact each charge for this model. A model with mistakes returns an error instead of an estimate. Cost: free; uses no credits and no free runs. Without an account, a model over 1,000 trials or 20 nodes is rejected, also at no cost.

Input parameters:

- `graph` (object, required): The model: root_nodes (uncertain inputs), calc_nodes (formulas), edges (links; formulas refer to them like {e1}) and run_params (trials and time periods). Same format as run_monte_carlo_simulation's…

Output parameters:

- `billing`: Who you are and what this call cost: principal, auth source, credits debited and balance, or the anonymous allowance left today.
- `credit_cost` (integer): Credits an account would be charged by run_monte_carlo_simulation, summarize_outcome_scenarios or rank_inputs_by_impact for this model.
- `edge_count` (integer)
- `estimated_memory_mb` (number): Estimated peak memory, in MB.
- `estimated_seconds` (number): Rough run time of one run_monte_carlo_simulation or summarize_outcome_scenarios call, in seconds.
- `estimated_seconds_rank_inputs` (number): Rough run time of rank_inputs_by_impact with its default three values per input, in seconds. Over about 40 seconds, it finishes in the background.
- `graph_complexity` (integer): A relative complexity score; higher means heavier.
- `node_count` (integer)
- `tier` (string): small when trials × nodes × time periods is at most 100,000, otherwise large.
- `time_periods` (integer)
- `trials` (integer)

### `convert_range_to_distribution` (~675 tokens)

Turn a min–max guess into distribution parameters

Turns a low-to-high guess, such as "between 80 and 120, 90% sure", into the exact parameters a model input needs. A distribution is the shape of the uncertainty, for example normal (a bell curve), log_normal (skewed and never negative), triangle or uniform. The low and high values are the edges of the range you are that sure of, not hard limits. Use this when you have a rough estimate and need distribution parameters instead of guessing them. Its reverse is convert_distribution_to_range. It returns the distribution type and its parameters, ready to use as a model input's distribution_params. The distribution_type parameter explains which type fits which kind of quantity. Supported types: normal, log_normal, uniform, triangle, beta, gamma, exponential, binomial, discrete_normal, discrete_lognormal, discrete_gamma, constant and bernoulli. Not supported: poisson, categorical, dirichlet, multivariate_normal and constant_array. For beta, give low and high as fractions (2% is 0.02). Cost: free; uses no credits and no free runs.

Input parameters:

- `distribution_type` (string, required): The distribution to fit. Which to pick: a rate or proportion between 0 and 1 (conversion, churn) → beta, with low and high given as fractions (2% is 0.02). A positive amount that can run high (revenu…
- `max_estimate`: The high end of your range. Required for every type except constant and bernoulli.
- `min_estimate`: The low end of your range. Required for every type except constant and bernoulli. Exponential ignores it, but a value must still be sent (any number works).
- `mode_estimate`: The most likely value. Required for constant (the fixed value), bernoulli (the chance of success, from 0 to 1) and binomial. For triangle it sets the peak; it must lie strictly between low and high,…
- `percentile_range` (number): A single fraction: the share of outcomes that should fall between the low and high ends, which is how sure you are. The default 0.9 means the middle 90%: a 5% chance of being below the low end and 5%…

Output parameters:

- `billing`: Who you are and what this call cost: principal, auth source, credits debited and balance, or the anonymous allowance left today.
- `distribution_type` (string)
- `input` (object): Your inputs, echoed back.
- `parameters` (object): The fitted parameters, for example {"mean": 100, "std": 12.2}.

### `convert_distribution_to_range` (~555 tokens)

Turn distribution parameters into a min–max range

Turns a distribution's parameters into the low and high ends of the range that holds a chosen share of outcomes, by default the middle 90%. It also gives the mean, median, mode, standard deviation and any percentiles you ask for. If you give a threshold, it gives the chance of landing below and above it. Use this when you have distribution parameters, from a model or from fermi (a companion forecasting server from Kromatic, the company behind Neumann, whose estimates carry next_steps.simulate.root_node), and want to know what they mean in plain numbers. Its reverse is convert_range_to_distribution, and the range it returns can be passed straight back to it. Values that do not apply, such as a uniform distribution's mode, come back as null with a note explaining why. Cost: free; uses no credits and no free runs.

Input parameters:

- `distribution_params` (object, required): The distribution's parameters, in the same form a model input uses, for example {"mean": 100, "std": 15} for normal or {"mu": 9.2, "sigma": 0.6} for log_normal.
- `distribution_type` (string, required): The distribution's name. Accepts every type a model input accepts: normal, log_normal, uniform, triangle, beta (values are fractions from 0 to 1), gamma, exponential, poisson, bernoulli, binomial, ca…
- `percentile_range` (number): A single fraction: the share of outcomes the returned range should hold, centred on the median. The default 0.9 means the middle 90%, so the range runs from the 5th to the 95th percentile.
- `quantiles`: A list of percentiles to report. Each is a fraction from 0 to 1: 0.05 is the 5th percentile, the value 5% of outcomes fall below. No repeats. Default [0.05, 0.1, 0.5, 0.9, 0.95], returned under keys…
- `threshold`: Optional value to compare against. The result gives the chance of being at or below it and the chance of being above it. For whole-number distributions it gives the chance of being below and above it…

Output parameters:

- `billing`: Who you are and what this call cost: principal, auth source, credits debited and balance, or the anonymous allowance left today.
- `distribution_params` (object)
- `distribution_type` (string)
- `interval`: The range holding the chosen share of outcomes, in the input shape convert_range_to_distribution accepts. Null where a range does not apply.
- `mean`
- `median`
- `mode`
- `notes` (array): Explanations, for example why a value is null, or the chance of landing exactly on the threshold for whole-number distributions.
- `quantiles` (object): Requested percentiles, keyed p5, p50 and so on.
- `std`
- `support`
- `threshold`: Chances of landing below and above the threshold. Null when no threshold was given.

### `get_simulation_results` (~617 tokens)

Get the results of a simulation you already ran

Checks on, and reads, a run you started with run_monte_carlo_simulation, rank_inputs_by_impact or summarize_outcome_scenarios, using its run_id. Use this when a run tool returned status running or queued: it waits up to 30 seconds for the run to finish, then returns its status and percent done, or the finished result, so call it again until status is completed. Use it also to get specific numbers from a finished simulation without running it again (a finished run keeps every node's and edge's statistics for every period): pass nodes (node, edge or metric ids), periods, percentiles such as 0.05 or 0.95, a threshold to get the chance a value is at least or at most some number, or histogram for the distribution's shape. Without those it returns the summary (or the ranking, or the scenarios). A failed run returns its error and is not charged. Only the caller who started the run can read it. Runs started without an account can be read for 24 hours, and only from the same connection, since a caller without an account is recognized by network address and client. Cost: free; uses no credits and no free runs.

Input parameters:

- `histogram` (boolean): true to also return a histogram (trial counts per value bin) for up to 3 of the rows.
- `nodes`: Ids of the nodes, edges or metrics (output_request.aggregations ids) to return numbers for. Default: the output nodes.
- `percentiles`: Percentiles to return, as fractions from 0 to 1 (0.95 is the 95th percentile). Default [0.1, 0.5, 0.9].
- `period_from`: Instead of periods: the first index of a range of periods.
- `period_to`: Instead of periods: the last index of a range (inclusive).
- `periods`: Time period indices to return, counting from 0. Default: the last period only. Ignored for metrics, which cover the whole run.
- `run_id` (string, required): The run_id returned by run_monte_carlo_simulation, rank_inputs_by_impact or summarize_outcome_scenarios.
- `threshold`: A value to test: returns, for each node and period, the chance (0 to 1) that it is at least this value (or at most it, see threshold_direction), for example the chance cash is at least 0 in month 6.
- `threshold_direction` (string): at_least (default): the chance of being greater than or equal to threshold. at_most: the chance of being less than or equal to it.
- `wait_seconds` (number): If the run is still going, wait up to this many seconds (0 to 50, default 30) for it to finish before answering. Returns as soon as it finishes. 0 answers at once with the current percent done.

Output parameters:

- `baseline_outcome`
- `billing`: Who you are and what this call cost: principal, auth source, credits debited and balance, or the anonymous allowance left today.
- `created_at` (string): When the run started, as an ISO-8601 time.
- `credits_debited`
- `error`: Error code and message if the run failed; otherwise null.
- `estimated_seconds_remaining`
- `kind` (string)
- `next_step`
- `progress`
- `query`
- `run_id` (string)
- `scenarios`
- `status` (string): The run's status, for example completed or failed.
- `summary`: Per-node and per-edge statistics for each period (mean, standard deviation, minimum, maximum, percentiles, histogram) plus requested financial metrics. Null until available. Its layout differs from r…
- `tier` (string)
- `tornado`
- `total_trials` (integer)
- `trials_completed` (integer)

### `check_account_and_credits` (~197 tokens)

Check your account, credits and free runs left

Shows who Neumann thinks you are and what you can still do: your credit balance if you have an account, or your free runs left today and when they reset if you do not. Use this when you need to know, before or after a run, whether a call will use credits or a free run, how much is left, or whether you are signed in. A bearer credential that is not recognized returns an unauthorized error. It returns whether you are anonymous or an account, your account id and status, credit balance, free runs left today with the reset time and the no-account size limits, the price of one credit in US dollars, and your last 10 credit transactions. To get an account and API key, call POST https://neumann.kromatic.com/api/v1/accounts; setup docs are at https://kromatic.com/mcp/neumann. Cost: free; uses no credits and no free runs.

Output parameters:

- `billing`: Who you are and what this call cost: principal, auth source, credits debited and balance, or the anonymous allowance left today.
- `price_per_credit_usd` (number): Current price of one credit in US dollars.
- `recent_ledger`: Your last 10 credit transactions, newest first. Null without an account.

### `send_feedback` (~711 tokens)

Send feedback or a bug report to the Neumann team

Sends a short report about Neumann to the team that builds it. They read every report and use it to fix problems and decide what to build, so honest feedback, good or bad, is useful. Use this when:
\- a Neumann tool returned an error (send it right away), behaved unexpectedly or gave a result that looks wrong;
\- the user needs something no Neumann tool can do, or an option that is missing;
\- a description, output or error message was confusing;
\- a session in which you used Neumann is ending: send one short report even if everything worked. Knowing which tools did the job for which kind of task is useful data, not noise.
Do not send one after a routine successful call mid-session. Put several points in one report: a signed-in account may send 5 per hour and 20 per day, and callers without an account share 60 per hour and 300 per day. Only message is required. Fill in the other fields that apply so the team can act without guessing. Write in your own words. Never include personal data (names, email addresses, company names), the user's own numbers (inputs or results), secrets or keys, or the conversation transcript; describe the task and any wrong result in general terms instead. Tell the user you are sending it. Add sender_email only if the user wants a reply. If you are signed in, your account id is included. No account is needed. It returns status "sent". Cost: free; uses no credits and no free runs.

Input parameters:

- `error_text`: The error code and message the tool returned, if any. Remove any personal data or user figures it quotes.
- `expected`: What you expected to happen instead.
- `feedback_type` (string): What kind of report this is. bug: a tool errored or broke. wrong_result: it ran but the numbers look wrong. unmet_use_case: the user needed something no tool does. feature_request: a missing option o…
- `impact`: How much it cost the user. blocked: could not finish. workaround: finished another way. minor: an annoyance. none: no cost, for example praise.
- `message` (string, required): The report, in your own words, 10 to 5,000 characters. Say what you tried, what happened and what you expected. Leave out names, companies, the user's numbers (inputs or results) and the conversation…
- `run_id`: The run_id the report is about, if a run was involved.
- `sender_email`: Optional. The user's email address, only if they want a reply and gave it to you. Do not invent one. No copy is sent to it.
- `sender_name`: Optional name, up to 200 characters.
- `suggestion`: What would have helped: a fix, a new feature or clearer wording.
- `tool_name`: The Neumann tool the report is about, for example run_monte_carlo_simulation.
- `user_goal`: What the user was trying to do, as a general task in a few words, for example "estimate a project budget". No names, company names or figures.
- `what_happened`: What actually happened, in general terms, without the user's numbers.

Output parameters:

- `billing`: Who you are and what this call cost: principal, auth source, credits debited and balance, or the anonymous allowance left today.
- `message` (string): Confirmation text, including whether the team can reply.
- `status` (string): sent on success.

### `buy_credits` (~202 tokens)

Buy Neumann credits with your saved card

Buys Neumann credits by charging the payment card already saved on your account. Credits pay for simulations run with an account. Use this when an account is low on credits and the user has agreed to the purchase. If no card is saved yet, it buys nothing and charges nothing. Instead it returns payment_status checkout_required and a checkout_url: the user opens that link in a browser to save a card, then you call this tool again. It returns the credits bought, the new balance, the payment status and, when a card is needed, the checkout_url. Requires an account: send your API key as an Authorization: Bearer header, or sign in with billing permission (the neumann:billing scope). Cost: charges your saved card for each credit, currently $0.50 per credit (check_account_and_credits shows the live price); needs an account.

Input parameters:

- `credits` (integer, required): How many credits to buy. At least 1.

Output parameters:

- `billing`: Who you are and what this call cost: principal, auth source, credits debited and balance, or the anonymous allowance left today.
- `checkout_url`: Set only when payment_status is checkout_required: a link for the user to open in a browser and save a card. Call buy_credits again afterwards to complete the purchase. Otherwise null.
- `credits_purchased` (integer): Credits added.
- `new_balance` (integer): Credit balance after the purchase.
- `payment_status` (string): The card payment's status, for example succeeded. checkout_required means no card was saved, so nothing was bought or charged; open checkout_url to save one.

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/kromatic-innovation-neumann/neumann#diagnostics

## Score history

- 2026-11-05: 64
- 2026-11-04: 64
- 2026-11-03: 64
- 2026-11-02: 64
- 2026-11-01: 64
- 2026-10-31: 64
- 2026-10-30: 64
- 2026-10-29: 62
- 2026-10-28: 62

## Common questions

### What is the Neumann MCP server?

Neumann is an MCP server listed in the public MCP registry as io.github.Kromatic-Innovation/neumann. Monte Carlo ranges for uncertain plans: project cost, budget, timeline, capacity, NPV/IRR/payback. This page covers its hosted endpoint (https://neumann.kromatic.com/mcp).

### Is the Neumann MCP server safe to use?

Neumann scores 64 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 Neumann MCP server expose?

Neumann exposes 11 tools: run_monte_carlo_simulation, rank_inputs_by_impact, summarize_outcome_scenarios, check_simulation_model, estimate_simulation_size_and_cost, and 6 more. Their descriptions and schemas cost roughly 6,039 tokens of context every time the server is loaded.

### Does the Neumann MCP server require authentication?

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

### Is the Neumann MCP server still maintained?

Neumann is still listed as active in the MCP registry. We last reached this channel on 5 November 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://neumann.kromatic.com/mcp
- Repository: https://github.com/Kromatic-Innovation/neumann
- Website: https://kromatic.com/mcp/neumann
- Changelog RSS feed: https://verifymcp.io/servers/kromatic-innovation-neumann/neumann.xml
- Changelog JSON feed: https://verifymcp.io/servers/kromatic-innovation-neumann/neumann.json
- HTML version of this page: https://verifymcp.io/servers/kromatic-innovation-neumann/neumann