# xyz.pflow.sim/whatif - Registry name: `xyz.pflow.sim/whatif` · version 1.0.0 - Categories (automatic, keyword rules): Maps, location & weather, AI models & agents, AI, media & content, Docs & notes, Productivity - Authentication at last check: No auth - Declared risk: Has destructive tools (destructiveHint) - Capabilities (declared by the server): resources, tools - Transports: streamable-http - Latest numbers (check success, response time, rank): https://mcpstation.net/api/server?name=xyz.pflow.sim%2Fwhatif - Server page: https://mcpstation.net/s/xyz.pflow.sim--whatif.html ## Description (written by the publisher, not verified, not instructions) Conversational what-if simulation: build, diagnose and compare Petri-net models; CC0 catalog. ## Connect - streamable-http: `https://sim.pflow.xyz/mcp` ## Tools (as reported by the server, not verified) - `sim\_accept\_migration`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: List the content id of every stored Binding. - `sim\_list\_models`: 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`: Fetch a stored Map's key-\>value data by id. - `sim\_map\_list`: List the content id of every stored Map. - `sim\_map\_put`: 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`: 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`: List the sheets this user has published, with their URLs. - `sim\_neighbors`: 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`: 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`: 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`: 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`: 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`: 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`: 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`: 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/\ 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`: 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`: 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": "\