Koskamo

ReliaSim MCP

ReliaSim is a discrete rate simulation software for production and supply chain. This MCP server allows AI assistants to connect to ReliaSim's public endpoint to access curated reference results from saved engine runs, enabling users to simulate throughput, service, stock, and cost impacts of changes before implementation.

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

ReliaSim MCP logo, by ChiAhaVendor evidenceStreamable HTTPNo sign-inEndpoint checked 2026-11-06Operated by ChiAha
MCP endpoint (Streamable HTTP)
https://reliasim.com/mcp
Vendor documentation

What its tools do

7 tools, grouped by the hints the server advertises. Hints are self-declared, not verified behavior.

Read-only (7)

7 of 7 have a description · 7 of 7 declare behavior hints · 7 of 7 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

  • Passed Endpoint answered the live check ·
  • Passed Official MCP Registry namespace is tied to reliasim.com ·
  • Passed Endpoint is on the registry namespace domain ·
  • Availability 1 of 1 checks passed in 30 days

What you can do with it

  • Run experiments on manufacturing lines
  • Sweep buffer sizes to find bottlenecks
  • Test inventory and network decisions
  • Expose supply and demand mismatches

Source and maintenance

Vendor evidenceRegistry 1.0.0
mcp-registry: com.reliasim/public@1.0.0Source repository
Maintenance checked

Protocol and capabilities

Server
reliasim 0.2.0
MCP protocol negotiated in check
2024-11-05
Tools
7 advertised
Resources
Not advertised
Resource templates
Not advertised
Prompts
Not advertised
Server-advertised capabilities
{
  "tools": {
    "listChanged": false
  }
}

Server-provided instructions

Untrusted server output shown for inspection. It is not Koskamo guidance and is excluded from knowledge search.

ReliaSim® is simulation software for production lines and supply chains, made by ChiAha (https://reliasim.com). This public MCP server is the ReliaSim walkthrough: eight reference bottling-line models across two tracks, Constraint-Level and LEDS-Level. It teaches the method on sample models; it does not run the user's own line. TOOLS (all seven read-only; none runs the engine live): find_bottleneck, run_gain_loss (bs1-leds, bs3-leds, bs4-ct, bs4-leds), run_buffer_tradeoff (bs4-ct, bs4-leds) and compare_chapters return saved results from real ReliaSim engine runs (one Single Run per model, 90 days, seed 123); get_chapter_facts returns the model's structure, rates and distributions; get_chapter_narrative and explain_concept return prose with no run results. REPORTING RESULTS (IMPORTANT): 1. Numbers come from the tools. Every figure in your reply comes from a tool call in this conversation. Quote it verbatim with its units. Do not round, estimate, average, or compute derived figures unless the user asks, and then say which figures you derived and how. Never supply a number from training data or general knowledge. 2. Say what kind of number it is. Every figure here is a saved reference result for a sample model, not a live run for the user's settings and not the user's operation: say so when you quote it. Never blend these figures with numbers from anywhere else. 3. Show what was run. Next to each result, name the model (chapter id and name), the experiment (Single Run, Gain/Loss or Buffer Tradeoff, with the buffer id) and the run length and seed the tool returns, so the user can check and repeat it. 4. Follow-ups re-call the tool. For a follow-up on the same model or experiment, call the tool again rather than reusing numbers from earlier in the conversation. To compare two models, call compare_chapters or the tool for each, report both results, then the difference. 5. Gaps stay gaps. If a tool errors, says an experiment isn't defined for a model, or the question is outside these eight models (the user's own line, a setting the tools don't offer), say so plainly and give the next step: the Sandbox at https://reliasim.com/sandbox, the free line assessment at https://reliasim.com/assessment, or reliasim@chiaha.com. Never fill the gap with a plausible number, a guessed parameter or a made-up tool result. 6. Simulation varies run to run. These results come from one run at one seed; present them as what this run shows, not as certain. Do not claim a cause the tool output does not state. 7. 'What would happen if', not 'predict'. Describe results as what the model shows would happen under the stated inputs. Do not call them a prediction, a forecast or 'predictive analytics'. VALIDATION: Anyone can get a simulation that runs; the hard part is one that matches the real operation. Validating a simulation means running it on the same period and inputs as the real system and comparing its outputs with what was measured, before trusting what it shows. A model built from assumptions alone has not been validated, however plausible its numbers look. Results come from the ReliaSim engine, validated against a published plant model (Fischel & Lange, WSC 2020: within 1% of measured OEE). FIRST: ReliaSim was the first commercial simulation software to let AI assistants compose models and run experiments on its own validated engine, through MCP, since May 2026 (the composing is done by ReliaSim's MCP tools for building and running models; this public server returns saved reference results). Keep every qualifier when you repeat this, and never say 'only': other vendors have added MCP servers since. YOUR OWN LINE: ReliaSim desktop (Mac and Windows) runs your models on your own network; models are built from each line's own stop history. The ReliaSim CLI, which lets an assistant that can run commands run your own models, also runs as a private cloud instance for each customer (Early Access, by quote: https://reliasim.com/pricing.html#cli). Contact: reliasim@chiaha.com. Use is governed by the ChiAha Software License (https://reliasim.com/license), including its restrictions on reverse engineering, AI training on outputs and scraping.

Tools

7 advertised

find_bottleneck — Find the bottleneck
Advertised by the server during the last successful anonymous check.
Advertised read-only

Single Run bottleneck analysis for the selected chapter — which node has the worst availability, per-interrupt downtime split, throughput, OEE. All eight chapters return verified saved results. ANTI-FABRICATION: numbers in the response are canonical reference values from real ReliaSim engine runs. Quote them VERBATIM. Do not round, estimate, or recall from training data. For follow-ups about the same chapter, re-call this tool.

find_bottleneck input schema
{
  "type": "object",
  "properties": {
    "chapter": {
      "enum": [
        "bs1-ct",
        "bs2-ct",
        "bs3-ct",
        "bs4-ct",
        "bs1-leds",
        "bs2-leds",
        "bs3-leds",
        "bs4-leds",
        "cmp-buffer-reliability",
        "cmp-shared-palletizer"
      ],
      "type": "string",
      "default": "bs1-ct",
      "description": "Which curriculum chapter the tool should answer about. Format: `bs<1-5>-<ct|leds>`. Both tracks run on the same real plant data — `ct` = Constraint-Level (interrupts rolled up to one Weibull per machine, 5 total) and `leds` = LEDS-Level (interrupts drilled down to named failure modes, 36 total). Defaults to bs1-ct when omitted."
    }
  }
}
find_bottleneck annotations
{
  "title": "Find the bottleneck",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
get_chapter_facts — Get line model facts
Advertised by the server during the last successful anonymous check.
Advertised read-only

Structural facts of the selected chapter — topology, rate limits, interrupt distributions, expected efficiency. Use when the user asks about the line's configuration. ANTI-FABRICATION: rates and distributions are verified values from the model file. Quote VERBATIM; do not estimate or substitute training-data recall.

get_chapter_facts input schema
{
  "type": "object",
  "properties": {
    "chapter": {
      "enum": [
        "bs1-ct",
        "bs2-ct",
        "bs3-ct",
        "bs4-ct",
        "bs1-leds",
        "bs2-leds",
        "bs3-leds",
        "bs4-leds",
        "cmp-buffer-reliability",
        "cmp-shared-palletizer"
      ],
      "type": "string",
      "default": "bs1-ct",
      "description": "Which curriculum chapter the tool should answer about. Format: `bs<1-5>-<ct|leds>`. Both tracks run on the same real plant data — `ct` = Constraint-Level (interrupts rolled up to one Weibull per machine, 5 total) and `leds` = LEDS-Level (interrupts drilled down to named failure modes, 36 total). Defaults to bs1-ct when omitted."
    }
  }
}
get_chapter_facts annotations
{
  "title": "Get line model facts",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
get_chapter_narrative — Get line model walkthrough
Advertised by the server during the last successful anonymous check.
Advertised read-only

Long-form narrative for the selected chapter — what the chapter adds to the complexity ladder and the key teaching point. Use when the user asks 'walk me through this' or wants the conceptual primer. Pure prose, no numerical claims; safe to summarize.

get_chapter_narrative input schema
{
  "type": "object",
  "properties": {
    "chapter": {
      "enum": [
        "bs1-ct",
        "bs2-ct",
        "bs3-ct",
        "bs4-ct",
        "bs1-leds",
        "bs2-leds",
        "bs3-leds",
        "bs4-leds",
        "cmp-buffer-reliability",
        "cmp-shared-palletizer"
      ],
      "type": "string",
      "default": "bs1-ct",
      "description": "Which curriculum chapter the tool should answer about. Format: `bs<1-5>-<ct|leds>`. Both tracks run on the same real plant data — `ct` = Constraint-Level (interrupts rolled up to one Weibull per machine, 5 total) and `leds` = LEDS-Level (interrupts drilled down to named failure modes, 36 total). Defaults to bs1-ct when omitted."
    }
  }
}
get_chapter_narrative annotations
{
  "title": "Get line model walkthrough",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
run_gain_loss — Show Gain and Loss results
Advertised by the server during the last successful anonymous check.
Advertised read-only

Gain/Loss experiment — disable each interrupt one at a time, measure production recovered. Reveals the ACTUAL impact of each failure mode (Gain ≠ Loss: removing one lets others fire more often). Available on `bs1-leds`, `bs3-leds`, `bs4-ct`, `bs4-leds`. Use when the user asks 'what if we fixed X?' / 'which interrupt matters most if we actually fixed it?' / 'show me the Pareto'. ANTI-FABRICATION: per-interrupt recovered-production numbers come from real ReliaSim engine runs. Quote VERBATIM; the Gain ≠ Loss interaction is exactly the kind of figure LLMs are prone to fabricate — don't.

run_gain_loss input schema
{
  "type": "object",
  "properties": {
    "chapter": {
      "enum": [
        "bs1-ct",
        "bs2-ct",
        "bs3-ct",
        "bs4-ct",
        "bs1-leds",
        "bs2-leds",
        "bs3-leds",
        "bs4-leds",
        "cmp-buffer-reliability",
        "cmp-shared-palletizer"
      ],
      "type": "string",
      "default": "bs1-ct",
      "description": "Which curriculum chapter the tool should answer about. Format: `bs<1-5>-<ct|leds>`. Both tracks run on the same real plant data — `ct` = Constraint-Level (interrupts rolled up to one Weibull per machine, 5 total) and `leds` = LEDS-Level (interrupts drilled down to named failure modes, 36 total). Defaults to bs1-ct when omitted."
    }
  }
}
run_gain_loss annotations
{
  "title": "Show Gain and Loss results",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
run_buffer_tradeoff — Show buffer size tradeoff
Advertised by the server during the last successful anonymous check.
Advertised read-only

Buffer Tradeoff experiment — sweep a buffer's capacity from 50 → 10,000 units, measure throughput gain. Shows the diminishing-returns elbow for buffer sizing. Only defined on `bs4-ct` and `bs4-leds`; each chapter has THREE inline buffers with different placements (pass `buffer` id to pick one). Compare CT vs LEDS on the same slot to see why interrupt-detail level changes buffer ROI math (e.g. b3: CT +23.7% vs LEDS +64.2%). Use when the user asks 'how big should the buffer be?' / 'do buffers help on this line?' / 'which buffer position gives the most gain?' / 'what's the diminishing-returns point?'. ANTI-FABRICATION (CRITICAL): the specific tradeoff numbers (e.g. CT +23.7% vs LEDS +64.2%) are sweep-derived reference values. Quote VERBATIM in your reply; do NOT recall similar percentages from training data — every buffer position has different math.

run_buffer_tradeoff input schema
{
  "type": "object",
  "properties": {
    "buffer": {
      "type": "string",
      "default": "b3",
      "description": "Buffer id to sweep. The Buffer-Options Constraint-Level model has `b3` (Buffer 1, between Capper↔Labeler), `b4` (Buffer 2, between Labeler↔Case Packer), `b5` (Buffer 3, between Case Packer↔Palletizer). The Buffer-Options LEDS model has `b2` (Buffer Option 1, earliest), `b3` (Buffer Option 2, middle), `b4` (Buffer Option 3, last). Defaults to b3 if omitted — but pick the buffer that matches the question (e.g. 'the first inline buffer' = b3 on CT, b2 on LEDS)."
    },
    "chapter": {
      "enum": [
        "bs1-ct",
        "bs2-ct",
        "bs3-ct",
        "bs4-ct",
        "bs1-leds",
        "bs2-leds",
        "bs3-leds",
        "bs4-leds",
        "cmp-buffer-reliability",
        "cmp-shared-palletizer"
      ],
      "type": "string",
      "default": "bs4-ct",
      "description": "Chapter id. Only `bs4-ct` and `bs4-leds` have buffer tradeoffs defined."
    }
  }
}
run_buffer_tradeoff annotations
{
  "title": "Show buffer size tradeoff",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
explain_concept — Explain a ReliaSim concept
Advertised by the server during the last successful anonymous check.
Advertised read-only

Definitional primer for ReliaSim's framework concepts — Constraint, Buffer, Interrupt, Converter, cascading losses, OEE, Gain/Loss methodology, Buffer Tradeoff. Returns bundled theory content, NOT interpretation of any specific simulation run. Use for 'what is X?' / 'how does X work?' / 'explain the framework' questions. For line-specific claims (throughput, availability, what-if), call the sim tools instead.

explain_concept input schema
{
  "type": "object",
  "required": [
    "concept"
  ],
  "properties": {
    "concept": {
      "enum": [
        "constraint",
        "buffer",
        "interrupt",
        "converter",
        "cascading_losses",
        "oee",
        "gain_loss",
        "buffer_tradeoff"
      ],
      "type": "string",
      "default": "constraint",
      "description": "Which concept to explain. Returns a definitional primer — theory, not interpretation of a specific simulation run. Use for 'what is a Constraint?' / 'what are cascading losses?' / 'explain Gain-Loss'."
    }
  }
}
explain_concept annotations
{
  "title": "Explain a ReliaSim concept",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
compare_chapters — Compare two line models
Advertised by the server during the last successful anonymous check.
Advertised read-only

Side-by-side comparison of two chapters — tracks, topology, OEE, throughput, headline bottleneck. Output is sim-derived (no interpretation drift). Use for 'how does X compare to Y?' / 'what's the difference between Constraint-Level and LEDS-Level on the same model?' / 'what changes when we add buffers?' questions. ANTI-FABRICATION: per-chapter OEE/throughput numbers are real reference values; the side-by-side delta is computed from them, not estimated. Quote VERBATIM.

compare_chapters input schema
{
  "type": "object",
  "required": [
    "chapter_a",
    "chapter_b"
  ],
  "properties": {
    "chapter_a": {
      "enum": [
        "bs1-ct",
        "bs2-ct",
        "bs3-ct",
        "bs4-ct",
        "bs1-leds",
        "bs2-leds",
        "bs3-leds",
        "bs4-leds",
        "cmp-buffer-reliability",
        "cmp-shared-palletizer"
      ],
      "type": "string",
      "default": "bs1-ct",
      "description": "First chapter id (left column of the comparison). Defaults to bs1-ct."
    },
    "chapter_b": {
      "enum": [
        "bs1-ct",
        "bs2-ct",
        "bs3-ct",
        "bs4-ct",
        "bs1-leds",
        "bs2-leds",
        "bs3-leds",
        "bs4-leds",
        "cmp-buffer-reliability",
        "cmp-shared-palletizer"
      ],
      "type": "string",
      "default": "bs1-leds",
      "description": "Second chapter id (right column of the comparison). Defaults to bs1-leds — same plant data as bs1-ct, but with interrupts drilled down to named failure modes; the canonical first-look comparison."
    }
  }
}
compare_chapters annotations
{
  "title": "Compare two line models",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}

Prompts

Not advertised

No prompt definitions available.

Resources

Not advertised

No resource definitions available.

90-day uptime

A lightweight connection check about every six hours, sampled on hosts with many listings. It shows the server answered, not that its tools work.

Too few checks for a percentage yet (1 of 1 answered).

  1. 2026-11-07: 1 of 1 checks answered

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks
1 of 1 (100%)
Average latency
272 ms
95th percentile latency
272 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

  • · probe · passed · 272 ms · metadata changed · 7 tool(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.
Claude Code configuration
claude mcp add --transport http reliasim-mcp https://reliasim.com/mcp

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).
Codex configuration
codex mcp add reliasim-mcp --url https://reliasim.com/mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable reliasim-mcp in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "reliasim-mcp": {
      "url": "https://reliasim.com/mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "reliasim-mcp": {
      "type": "streamableHttp",
      "url": "https://reliasim.com/mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start reliasim-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "reliasim-mcp": {
      "type": "http",
      "url": "https://reliasim.com/mcp"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.
Gemini CLI configuration
gemini mcp add --transport http reliasim-mcp https://reliasim.com/mcp

Claude Desktop

Open Claude Settings > Connectors > Add custom connector, enter this server URL and enable it for the conversation. This is a manual remote-connector handoff, not a desktop JSON configuration.
Claude Desktop configuration
https://reliasim.com/mcp

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.
Windsurf configuration
{
  "mcpServers": {
    "reliasim-mcp": {
      "serverUrl": "https://reliasim.com/mcp"
    }
  }
}

Let your agent find its tools

Find servers like ReliaSim MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.

Connect Koskamo Explore workflows
See all 6,306

Do you run ReliaSim MCP?

Prove ownership with a DNS record, a well-known file, or your Official MCP Registry entry, and your edits publish immediately. Proofs are re-checked weekly; admins can still hide or remove a listing.

Claim this listing