MCP server

Pflow Whatif Official

xyz.pflow.sim/whatif

Checked 26 Oct 2026, 08:29 UTC · Connected to it and listed its tools

Conversational what-if simulation: build, diagnose and compare Petri-net models; CC0 catalog.

Website

At a glance

Type

MCP server

Publisher

pflow.xyz (verified by the MCP Registry)

Status

Working at last check

Tools

59

Token cost

About 29,065 tokens per request

Sets up in

Claude Code, Claude Desktop, Codex, Gemini CLI, Cursor, VS Code, Antigravity, ChatGPT, OpenAI API, Grok

Last checked

26 Oct 2026, 08:29 UTC

Connect it to your agent

Add to CursorAdd to VS CodeVS Code Insiders

Opens the app, which shows the server and asks you to confirm. For other apps, copy the setup below.

Claude Code

claude mcp add --transport http whatif https://sim.pflow.xyz/mcp

Claude Desktop

Settings → Connectors → Add custom connector, and paste the URL.

Codex (config.toml)

[mcp_servers.whatif]
url = "https://sim.pflow.xyz/mcp"

Gemini CLI

{"mcpServers":{"whatif":{"httpUrl":"https://sim.pflow.xyz/mcp"}}}

Cursor

{"mcpServers":{"whatif":{"url":"https://sim.pflow.xyz/mcp"}}}

VS Code

{"servers":{"whatif":{"type":"http","url":"https://sim.pflow.xyz/mcp"}}}

Antigravity

agy mcp add whatif https://sim.pflow.xyz/mcp

ChatGPT

Settings → Apps & Connectors → Advanced settings: turn on Developer mode, then Create a connector and paste the URL. Which plans can do this varies.

OpenAI API (Responses tools)

{"type":"mcp","server_label":"whatif","server_url":"https://sim.pflow.xyz/mcp","require_approval":"always"}

Grok (xAI API tools)

{"type":"mcp","server_label":"whatif","server_url":"https://sim.pflow.xyz/mcp"}

Tools

• sim_accept_migration ~483 tokens
  Carry offered taxonomic edges of a superseded model forward to its current successor. edges lists 1 to 25 edge ids that sim_migration_offers(model) offered; pass successor (the current it returned) so a different current successor — a re-point or a chain that grew since — is refused rather than foll
• sim_bind ~1097 tokens
  Record a checked connection between two stored models' declared ports, fromModel's fromPort (a place tagged port.output) feeding toModel's toPort (a transition tagged port.input), as a content-addressed Binding (ROADMAP.md Phase 9/11f). Checked now, by the same binds-port-v1 rule sim_run_pipeline ap
• sim_calibrate ~627 tokens
  Calibrate a model against YOUR event log — the reading that meets reality. Upload CSV (case_id, activity, timestamp; the shape sim_dataset emits, activities = transition ids), and rates are learned from the observed timings: sources from inter-arrival times, services from the gap before their comple
• sim_canonical ~432 tokens
  Tell whether two differently-labelled models are actually the same net: an isomorphism-invariant id computed from the model's EXACT automorphism orbits (orbits.go), not the colour-refinement (WL) kind sim_classify falls back to when the exact search can't decide. Two models differing only by renamin
• sim_check_witness ~825 tokens
  Re-check a stored structural witness against both stored models with the independent checker (pkg/morphism), which does no search. Given a structural edge's id, checks every witness of that edge; an edge with none answers unwitnessed (unproven, not disproved). Verdicts: valid, invalid (the map is no
• sim_classify ~381 tokens
  Discover the parameter classes of a stored model and return them as JSON-LD with empty annotation slots for you to fill in (label, comment, unit, domain, substitutes — nothing else; membership/kind/evidence are derived and settled by measurement, not yours to edit). With verify=true a shared colour
• sim_code_to_flow ~494 tokens
  Derive a Petri-net model from source code with the configured LLM (control-flow, state-machine, resources or concurrency focus) and store it as a NEW model you own when it passes sim_create_model's decode and the model validator. Stored, it returns stored: true with id, url, name, usage and warnings
• sim_compare ~639 tokens
  Run several scenarios against one model on one shared seed and return them side by side — the seed sharing is server-enforced, so differences are the scenarios, not the dice. Returns a summary by default (finals with finalStdDev, each final count's spread across realizations, throughput/mean/P95 met
• sim_components ~138 tokens
  List the component registry: pre-baked subnet templates (arrivals, service, hazard, inventory, decision, mailbox, datastore) with the calibration discipline baked into the arcs and rates. Each entry names its ports (places you can attach onto existing places), its params with recommended defaults, a
• sim_compose ~387 tokens
  Instantiate a registry component into a model and store the result as a NEW content-addressed model you own (lineage recorded when composing onto an existing id). Omit id to start a model from the component alone; pass attach to fuse a component port onto one of the model's existing places (e.g. att
• sim_conformance ~457 tokens
  Check how well a stored model matches an observed event log WITHOUT rewriting its rates — the read sim_calibrate bundles into calibration, offered on its own and in full: fitness (can the model replay each case?), precision (does it allow behaviour never observed?), generalization and simplicity, wi
• sim_conformance_stream ~889 tokens
  Online conformance: replay an ORDERED event stream against a stored model and get a running verdict — does the model still match, or which event was the first that did not, and why. Unlike sim_conformance (whole finished cases, aggregate fitness) the order of events IS the stream's order, cases may
• sim_create_collection ~373 tokens
  Mint a named Collection you own and return its content id. A collection carries no member list of its own — a mutable list would change the collection's own id every time something joined it, the same reason Lineage lives beside a model rather than inside it. Add members with sim_link(collectionID,
• sim_create_model ~648 tokens
  Store a Petri-net model and return its content id and url, plus warnings (omitted when there are none) for a model that stores but probably does not say what was meant: transitions with no rate, which simulations run at the engine default of 1 per hour (each stage of a staged one, in a run without a
• sim_create_system ~746 tokens
  Define a System (ROADMAP.md Phase 11f): a content-addressed, stored set of models and the bindings between them, so the catalog can answer questions about them together. Pass collection (snapshot its model and binding members now; other members are listed under skipped, and a grown collection is a n
• sim_crosscheck ~290 tokens
  Run every applicable READING of a model against the others and report agreement or divergence with the reason: discrete SSA means vs the continuous mean-field solve, algebraically derived conservation laws vs simulated means, and (for game-schema models) the closed-form incidence ranking vs rollouts
• sim_dataset ~132 tokens
  Generate a synthetic event log from a stored model (seeded SSA playout; case-per-arrival). Returns CSV. Deterministic: same id, same seed, same bytes.
• sim_delete_model Deletes data · ~115 tokens
  Delete a model you created signed in. Refused for the curated catalog, for models you do not own (a model created without sign-in is nobody's, for good), and for models already dedicated to the commons (a dedication is irrevocable).
• sim_diagnose ~743 tokens
  Returns what one more of each resource (and a change in each rate) is worth to the outcome, each ranked against a measured noise floor — no fitness test to write. Also reports generic gates (mass balance, dormant sources, staffing knee and practical knee, whether any knob binds), parameter classes a
• sim_diff ~150 tokens
  Structural difference between two stored models: places, transitions and arcs added or removed, and surviving elements whose numbers changed (initial, capacity, rate, stages, arc weight or kind). The readout for what a builder turn, a sim_extend or a sim_refine actually changed between two ids in a
• sim_distill ~570 tokens
  Distill exact search into the play scorer: fit rate multipliers for named transition groups so play's rankings agree with exact minimax, on positions sampled by random self-play and labeled by search. This is TACTICAL calibration — the counterpart of sim_calibrate, which learns rates from an event l
• sim_distinguish ~890 tokens
  Compare the behaviour of two stored models of one process — typically a net formalized from a document and a net sim_code_to_flow read out of code — and return proved (no word of visible steps separates them), refuted (with separation: the shortest firing sequence one net can make and the other cann
• sim_edges ~286 tokens
  List every relation touching an entity, as either subject or object. Answered from an index by subject and object; each call re-lists the store so edges written by other instances are seen. Legacy edges whose predicate predates the registry are included with axis "unregistered". Structural edges (is
• sim_evaluate ~373 tokens
  Score a player's legal next moves with the PLAY method (the blog post's move picker): apply each candidate hypothetically and score the expected objective of the position it leads to, by seeded SSA rollouts (seed 11, shared across candidates so a difference measures the move, not the dice) — the bes
• sim_extend ~296 tokens
  Apply structural edits to a stored model and store the result as a NEW model you own, with lineage back to the original — the same vocabulary the guided builder uses behind its interview, now callable directly. Operations (JSON array, each with "op"): add_place {id, initial}, add_transition {id, gua
• sim_generate ~922 tokens
  Write a Petri-net model from a plain-language description with the configured LLM, with the levers that moved the pass rate in the benchmark behind it, each optional. The model is checked as it arrives (decode, validator, then the builder's behavioural checks: disconnected parts, transitions that ne
• sim_get_artifact ~432 tokens
  Fetch a stored prompt or artifact by id as JSON-LD: the two records sim_prompt and sim_reroll store besides a model. An artifact (@type Artifact) is an LLM reply that was not stored as a model — a report, code, or model JSON that failed validation — returned whole as content (the store caps an artif
• sim_get_binding ~177 tokens
  Fetch a stored Binding by id, with its check computed now (binds-port-v1; binds-port-v2 for a binding that declares a unit conversion, which is returned as convert; binds-port-v3 for one that declares a delay, returned as delay in hours): ok (with the unit verdict: agree, converted or unchecked), re
• sim_get_model ~214 tokens
  Fetch a stored model's full Petri-net JSON by its content id. A name in place of an id is refused saying to search with sim_list_models' query, and that a model created without sign-in is listed for nobody, so its id is the one its create returned; or naming the curated model's id when a curated mod
• sim_invariants ~254 tokens
  Derive a model's full algebraic invariant structure: conservation laws (Farkas P-invariants — weighted place sums every run preserves, the arithmetic a trust panel should show), firing cycles (T-invariants, named per-cycle with a readable detail sentence, each tagged StructuralProof), and the siphon
• sim_license_model ~191 tokens
  Dedicate a model you created to the commons under CC0-1.0, CC-BY-4.0, CC-BY-SA-4.0. It then appears in every user's listing with the license shown, and the dedication is IRREVOCABLE — it cannot be changed or deleted afterwards, which is what makes it safe for others to build on. CC0-1.0 is the clean
• sim_link ~714 tokens
  Record a typed edge between two stored entities (models, prompts, artifacts, maps, collections, bindings, relations — not witnesses), using a registered predicate. sim_link writes these (subject → object): @type (model → a https://sim.pflow.xyz/ns/models/v1 type name); about (artifact/prompt/map/col
• sim_list_bindings ~35 tokens
  List the content id of every stored Binding.
• sim_list_models ~553 tokens
  List the models visible to you, as a JSON array of {id, name, description, license, curated, mine} sorted by name (a field that does not apply is left out): the curated catalog (curated: true), models dedicated to the commons (each carries its license), and your own (mine: true). The curated models
• sim_map_get ~56 tokens
  Fetch a stored Map's key->value data by id.
• sim_map_list ~33 tokens
  List the content id of every stored Map.
• sim_map_put ~145 tokens
  Store a key->value lookup table as its own content-addressed entity — a generated parameter sweep, a rate table, a component registry, anything shaped as key->value rather than free text (an artifact) or a Petri net (a model). Returns its content id; the same data, even with keys inserted in a diffe
• sim_migration_offers ~646 tokens
  List what happens to the edges of a superseded model. Taxonomic edges (hasMember, @type, broader, related, closeMatch, cites, about) are OFFERED: each row gives the edge as it would read on the model's current successor (followed through its supersession chain), whether sim_link's checks pass for it
• sim_my_sheets ~38 tokens
  List the sheets this user has published, with their URLs.
• sim_neighbors ~440 tokens
  One-hop traversal from an entity, read through the predicate registry. With no predicate: the object of every relation where the entity is the subject. With a predicate: the entities one hop along it — for an inverse name that is never stored (narrower) the stored predicate is read backwards (the su
• sim_optimize ~368 tokens
  Multi-objective optimisation over transition rates for a stored model: Monte Carlo samples the rate ranges, runs each combination to the horizon with the continuous engine, and returns every sample with a Pareto flag — the non-dominated set is the trade-off frontier ('which staffing is non-dominated
• sim_param_heatmap ~372 tokens
  Two-rate grid for a stored model: vary two transition rates over ranges, run each combination to the horizon with the continuous engine, and return the observable's final value as a grid — 'which regime of arrivals × restock keeps the queue empty'. Continuous reading: a model with a schedule or a ga
• sim_prompt ~742 tokens
  Ask an LLM to derive something from a stored entity: a variant model, a report, a piece of generated code — whatever the prompt asks for. The parent's JSON rides along as context after a fixed instruction: answer a request for a new or changed model with only the complete model JSON (the shape sim_c
• sim_propose_types ~448 tokens
  Propose candidate @type values for one or more stored models, e.g. "QueueingSystem" or "ResourcePool", from a small Diagnose run this tool performs on each model (nothing is cached or reused between calls). Every rule is a hand-written assumption about what a shape of knobs/loss/siphons/classes tend
• sim_prove ~851 tokens
  Prove a structural relation between two stored models and record it with its witness. isomorphicTo: an exact canonical-labelling search (the one behind sim_canonical, seeded with exactly what the check compares) finds a place/transition bijection preserving arcs (direction, type, weight, kinetic), p
• sim_publish Sends messages · ~191 tokens
  Publish a stored model into the signed-in user's Google Sheets: the model workbook (live formulas when honest, a refusal tab when not), a server-run scenario as data tabs, and trajectory + contention charts. Returns the sheet URL. Counts against the daily quota, and costs 1 token from your account's
• sim_publish_app Sends messages · ~488 tokens
  Publish the generated application for a model you own — the single-file HTML a generator produced from the model's `view` prompt. Served at /app/<id> in a sandboxed opaque origin (no cookies, no session; only the CORS-open public API is reachable). START FROM THE RUNTIME, not from scratch: /lib/app-
• sim_publish_compare Sends messages · ~293 tokens
  Publish a multi-scenario comparison into the signed-in user's Google Sheets — sim_compare's export, the counterpart of sim_publish for a single scenario. Runs every scenario on one shared seed (the same server-enforced sharing sim_compare uses, so differences are the scenarios and not the dice) and
• sim_query ~659 tokens
  Answer a question over the edge graph between stored models: bounded paths, closure over transitive predicates, and conjunctive patterns of up to 4 triples joined on shared ?variables. The query argument is JSON: {"select": ["?m"], "where": [{"subject": "?m", "predicate": "subnetOf", "object": "<con
• sim_reach ~765 tokens
  Returns whether the marking to is reachable from the marking from in ONE stored net (a model, or a system that is one net): yes with a firing trace, no with a re-checkable P-invariant (or after an exhaustive search), or unknown with every reason. A sim_compose result is one fused net, so it qualifie
• sim_receipt ~750 tokens
  Run a seeded scenario and get back the result PLUS a signed run receipt: an Ed25519 certificate over (model id, scenario, result hash, service revision) and the inputs the engine recorded for this run: inputs.modelDigest (the model after params), method, hours, samples, realizations and seed as run
• sim_refine ~713 tokens
  Refine a model's parameter classes by editing what the model SAYS (tags on a place or transition, or assertedClasses), then re-derive. Returns a NEW model id (ids are content addresses, so the original stays reachable) plus a before/after class diff. tags can only split classes; assertedClasses decl
• sim_reroll ~693 tokens
  Re-run a stored sim_prompt against the SAME parent it originally ran against — a sibling attempt, never a chain: it never derives from the previous attempt's output, only from the original parent, so rerolling ten times leaves ten independent siblings in lineage rather than a chain of ten. Reuses th
• sim_run_pipeline ~795 tokens
  Returns one scenario result per model that a set of stored Bindings (see sim_bind) touches, run as a composed pipeline (each result's contention split into contended, waitingForWork and neverFired exactly as sim_scenario's is), with the assumptions the composition makes, inTransit (per delayed bindi
• sim_scenario ~760 tokens
  Run a seeded what-if scenario against a stored model: marking overrides, rate overrides, piecewise rate schedules, and params assignments to the model's declared structural parameters (arc weights, capacities — batch sizes and shelf sizes). Pure read — asking cannot change the model. Returns traject
• sim_sequences ~780 tokens
  Returns a deterministic suite of firing sequences generated from ONE stored model, for replaying against an implementation outside sim (for example the code a sim_code_to_flow model came from): every transition fired once, a refusal probe for each transition at a marking where the model refuses it,
• sim_supersede_model ~310 tokens
  Mark an old version of your model as replaced by a newer one. The old id keeps working and its commons dedication (if any) stands — only the listing moves on to the successor. Both models must be yours. It also records a supersededBy edge (old → new), so sim_edges(old) and sim_neighbors(old, "supers
• sim_system ~770 tokens
  Returns a stored System's view ({id}), the models whose ports can bind to one declared port ({model, port, direction?, among?}), or the stored systems that name a model or a binding ({naming}); one form per call. {id}: the system's view, computed now and never stored (system-view-v2): each model (pr
• sim_verify ~1006 tokens
  Verify declared properties of a stored model: a report with one verdict per property, proved, refuted or unknown (unknown is never a pass, and ok is true only when every property is proved), with evidence for a proof and a counterexample for a refutation, plus caveats naming anything the analysis ne

Browse

• Fuse tools
• Website monitoring
• Spreadsheets
• Customer support
• Legal research

Related MCP servers

• PT Chart
  PT chart lookups, superheat/subcooling calculators, and diagnostics for HVAC technicians.
• Apostle — AI Men's Skincare Commerce
  Search, compare, and buy Apostle men's skincare: tinted moisturizer, face wash, and sets.
• CrystalRAM Open Commons
  Read CrystalRAM public research and request discussion-only Open Commons visitor access.
• ElectionsMCP
  Model and map any 2028 U.S. race down to the precinct: scenarios, swing, turnout, and roll-ups.
• Vendooly
  Amazon Seller Central, Ads and Vendor Central in ChatGPT & Claude. 106 tools; writes need approval.
• Vitals Vault
  Find public biomarker education, available blood tests, panels, and budget-aware starting points.
• RQM Studio Jobs
  Delegate 20 fail-closed RQM Studio quantum work products with fixed-request x402.
• Pokemon TCG Pocket Catalog
  Look up Pokemon TCG Pocket cards, sets, packs, and evaluate decks with battle simulations.

Badge for your README

[![AptLynx](https://aptlynx.net/badge/xyz.pflow.sim/whatif.svg)](https://aptlynx.net/servers/xyz.pflow.sim/whatif)

Listing text is written by the maker; AptLynx lists tools and does not vouch for them. Find another tool · Browse by topic · For agents