scenariosim-mcp
Server Details
Deterministic what-if & scenario simulation for AI agents: projections, sensitivity & break-even.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
- Repository
- inity13/scenariosim-mcp
- GitHub Stars
- 0
- Server Listing
- ScenarioSim MCP
Glama MCP Gateway
Connect through Glama MCP Gateway for full control over tool access and complete visibility into every call.
Full call logging
Every tool call is logged with complete inputs and outputs, so you can debug issues and audit what your agents are doing.
Tool access control
Enable or disable individual tools per connector, so you decide what your agents can and cannot do.
Managed credentials
Glama handles OAuth flows, token storage, and automatic rotation, so credentials never expire on your clients.
Usage analytics
See which tools your agents call, how often, and when, so you can understand usage patterns and catch anomalies.
Tool Definition Quality
Average 4.4/5 across 6 of 6 tools scored.
Each tool targets a distinct operation: health_check for status, list_templates for discovery, run_scenario for single simulations, compare_scenarios for multi-scenario comparison, sensitivity_analysis for input sweeping, and break_even for root-finding. There is no meaningful overlap or ambiguity between tool purposes.
All tool names follow a clear snake_case pattern, with most using verb_noun construction (run_scenario, list_templates, compare_scenarios). Even though health_check and break_even are compound nouns, they are consistent in style and clearly action-oriented.
Six tools is well within the ideal range and each tool fills a necessary role for scenario simulation. The set covers running, comparing, sensitivity analysis, break-even solving, discovery, and system health without being bloated or sparse.
The tool surface covers the full lifecycle of scenario analysis: discover templates, run a scenario, compare multiple, vary inputs, and solve for targets. Custom scenarios are also supported via run_scenario, so there are no critical gaps in the domain.
Available Tools
6 toolsbreak_evenAInspect
Solve for the input value required to make an output metric hit a target value (deterministic bisection root-finding). Provide 'template', 'solve_for' (the input to solve), 'target_metric' (defaults to the primary output), and 'target_value'. Optionally pass 'bounds' [low, high] to constrain the search. Returns the required input value, the change from baseline, the achieved metric, and the residual. Assumes the metric is monotonic in the solved input over the range.
| Name | Required | Description | Default |
|---|---|---|---|
| bounds | No | Optional [low, high] search range for the solved input. Auto-derived + expanded if omitted. | |
| inputs | No | Scenario assumptions as {name: value}. Which keys are valid depends on the template (call list_templates). Unlisted keys fall back to documented defaults; unknown keys are ignored and reported in notes. You may also pass assumptions at the top level. | |
| horizon | No | Number of periods to project forward (1..1200). Default depends on template (usually 12). | |
| template | Yes | Pre-built scenario template id: saas_growth, pricing_change, churn_impact, cost_reduction, hiring_plan, cash_runway, unit_economics, marketing_funnel, compound_growth (aliases like 'saas','pricing','runway','ltv' also resolve). Omit (or use 'custom') to run a free-form 'metrics' projection. | |
| solve_for | Yes | Name of the input variable to solve for. | |
| period_label | No | Label for each period; also sets annualization (periods/year). | month |
| target_value | Yes | The value the target_metric should reach. | |
| target_metric | No | Output metric to hit (defaults to the template's primary output). |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the deterministic bisection algorithm, monotonicity assumption, and return values (required input, change from baseline, achieved metric, residual). It does not disclose potential error conditions (e.g., unreachable target), but the monotonicity assumption indicates a key limitation. Overall, this is solid transparency for a calculation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is four sentences long, front-loaded with the primary purpose, and every sentence earns its place: purpose, required inputs, optional bounds, and return values/assumption. It is concise, scannable, and free of unnecessary filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 8 parameters and no output schema, the description covers the core workflow (inputs, optional bounds, returns, assumption). It does not explain the 'inputs' or 'horizon' parameters, but the schema provides adequate detail for those. The return values are explicitly listed, compensating for the missing output schema. A brief note about what happens when the target is unattainable would be useful, but the description is largely complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides detailed descriptions for all parameters (100% coverage), so the baseline is 3. The description clarifies the relationship between key parameters (template, solve_for, target_metric, target_value, bounds) and notes that target_metric defaults to the primary output, which is also in the schema. It adds no novel semantic information beyond what the schema already conveys, so a 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Solve for the input value required to make an output metric hit a target value.' It uses a specific verb ('solve') and resource ('input value', 'output metric'), and it distinguishes itself from siblings like run_scenario and sensitivity_analysis by focusing on inverse root-finding rather than forward simulation or sensitivity exploration.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implicitly communicates when to use the tool by explaining the required inputs and optional bounds. It does not explicitly mention alternatives or exclusions, but the context of sibling tools (e.g., run_scenario for forward projections) makes the use case clear. A sentence stating 'use this when you need to find the input for a target output' would improve it, but the guidance is adequate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
compare_scenariosAInspect
Run 2-3 scenarios and compare their key_results side by side, with deltas against the first (baseline) scenario. Provide a 'scenarios' array where each entry is {name?, template, inputs} (each may set its own horizon, or pass a shared top-level 'horizon'). Optionally rank on 'compare_metric' with 'goal' ('max' default | 'min') to pick a winner, and set include_projections:true to also return per-period series.
| Name | Required | Description | Default |
|---|---|---|---|
| goal | No | Whether higher (max) or lower (min) is better for compare_metric. | max |
| horizon | No | Optional shared horizon applied to scenarios that don't set their own. | |
| scenarios | Yes | 2-3 scenarios to compare. Each: {name?, template, inputs, horizon?, period_label?} or {name?, metrics:[...]} for a custom model. | |
| compare_metric | No | Metric to rank scenarios on (optional). | |
| include_projections | No | Include each scenario's full per-period projections. |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses key behaviors such as deltas against the baseline, optional ranking with 'goal' (max/min), and include_projections for per-period series. This goes beyond a simple 'compares scenarios' and provides actionable behavioral detail, though it omits some edge-case behaviors like error handling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, with the primary purpose front-loaded and additional usage details compactly integrated. Every phrase earns its place, using quoted parameter names for clarity. There is no unnecessary repetition or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema, but the description at least mentions key_results and per-period series, giving the agent an idea of the return shape. The scenarios array and optional ranking are well covered. It's not exhaustive (e.g., no mention of units or exact response structure), but for the tool's complexity, it is sufficiently complete for an agent to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds value by explaining the relationship between per-scenario and top-level 'horizon', the structure of the scenarios array (including custom 'metrics'), and the effect of include_projections. This exceeds what the schema's descriptions alone provide, justifying a 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Run 2-3 scenarios and compare their key_results side by side') and specifies the resource (scenarios) with the key differentiator of deltas against the baseline. This distinguishes it from sibling tools like run_scenario, which runs a single scenario.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It implies when to use (comparing 2-3 scenarios) and provides explicit structural guidance on the 'scenarios' array, top-level 'horizon', and optional ranking. It doesn't explicitly list alternatives to avoid, but the context of comparing multiple scenarios is clear. A 4 is appropriate for clear context without explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
health_checkAInspect
Server health, version, and capabilities (tools, templates, period labels, max horizon). No parameters.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries the burden of behavioral disclosure. It lists the returned information but does not explicitly state that this is a read-only, side-effect-free operation, nor does it mention any potential issues (e.g., authentication requirements, rate limits). The term 'health_check' implies safety, but explicit disclosure is missing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, focused sentence that front-loads the core purpose and lists key outputs. Every word contributes meaning, with no filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple no-parameter health check with no output schema, the description covers the main returned items (health, version, capabilities). It could mention the response structure or format, but for this complexity the description is sufficiently complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With zero parameters, the baseline is 4. The description confirms 'No parameters,' aligning with the empty schema. It adds no further semantic value about parameters because none exist.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool provides server health, version, and capabilities (tools, templates, period labels, max horizon). This distinguishes it from sibling tools focused on scenario analysis like run_scenario and sensitivity_analysis.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives is provided. The purpose is implied by the name and description, but there is no direct statement of when a health check is needed or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_templatesAInspect
Discovery tool: list every pre-built scenario template (id, label, category, description, primary output, documented inputs with defaults/units, and available output metrics), plus how to run a custom free-form scenario and the supported period labels. No required parameters.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full transparency burden. It discloses the output contents and explicitly states 'No required parameters,' while the 'Discovery tool' label implies a safe, read-only operation, which adds meaningful behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The entire description is one well-structured sentence that front-loads the key purpose and packs all essential detail (output fields, extra instructions, parameter note) without waste. Every clause adds value and there is no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of output schema and annotations, the description fully compensates by enumerating the returned fields, noting no required parameters, and even mentioning additional included guidance on custom scenarios and period labels. This gives an agent enough context to invoke and interpret the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and an empty schema with 100% coverage. The description confirms 'No required parameters,' which aligns with the schema and adds no unnecessary detail, earning the baseline 4 for param-less tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with 'Discovery tool: list every pre-built scenario template' which is a specific verb+resource that clearly identifies what the tool does. The listed output fields provide exact detail, and the 'Discovery' label distinguishes it from the sibling execution tools like run_scenario and sensitivity_analysis.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The 'Discovery tool' label implicitly tells the agent to use this when needing to explore available templates, not for running or analyzing scenarios. While it does not explicitly name alternative tools, the context makes the appropriate use case clear, with no exclusion needed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
run_scenarioAInspect
Main simulation tool. Run a deterministic what-if projection from a pre-built template (saas_growth, pricing_change, churn_impact, cost_reduction, hiring_plan, cash_runway, unit_economics, marketing_funnel, compound_growth) OR a free-form 'metrics' model. Returns period-by-period projections, headline key_results, the exact assumptions used (with defaults filled in), the methodology, notes, and a plain-language explanation. Pass 'template' + 'inputs' (assumptions), plus optional 'horizon' and 'period_label'. 100% deterministic (40-digit decimal math).
| Name | Required | Description | Default |
|---|---|---|---|
| inputs | No | Scenario assumptions as {name: value}. Which keys are valid depends on the template (call list_templates). Unlisted keys fall back to documented defaults; unknown keys are ignored and reported in notes. You may also pass assumptions at the top level. | |
| horizon | No | Number of periods to project forward (1..1200). Default depends on template (usually 12). | |
| metrics | No | For a CUSTOM free-form scenario (template omitted or 'custom'): a list of independently-growing metrics. Each: {name, start, growth_rate (per period, default 0), mode: 'compound' (default) | 'linear'}. | |
| template | No | Pre-built scenario template id: saas_growth, pricing_change, churn_impact, cost_reduction, hiring_plan, cash_runway, unit_economics, marketing_funnel, compound_growth (aliases like 'saas','pricing','runway','ltv' also resolve). Omit (or use 'custom') to run a free-form 'metrics' projection. | |
| period_label | No | Label for each period; also sets annualization (periods/year). | month |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description clearly discloses that it is '100% deterministic (40-digit decimal math)' and details every major output element: period-by-period projections, key_results, assumptions with defaults filled in, methodology, notes, and a plain-language explanation. This is especially valuable because no annotations are provided, fully compensating for the absence of structured transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is five sentences, front-loaded with 'Main simulation tool' and proceeding logically through what it runs, what it returns, how to call it, and its deterministic nature. The template list is long but necessary for discoverability; no sentence is redundant.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite lacking an output schema and annotations, the description covers all key aspects: it lists return values, supports both template and custom scenarios, explains deterministic behavior, and works in tandem with the rich input schema. This is sufficient for an agent to know when and how to use the tool and what to expect.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema coverage, the baseline is 3, and the description adds a useful high-level abstraction: it clarifies the two modes (pre-built template vs free-form 'metrics') and gives the core call pattern ('template + inputs'). This goes slightly beyond the schema by synthesizing which parameters work together, aiding correct invocation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Run') and resource ('simulation tool'), and goes beyond by naming both pre-built templates and a free-form 'metrics' model. The phrase 'Main simulation tool' establishes its role relative to siblings like sensitivity_analysis and compare_scenarios, making the purpose unmistakable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit usage instructions: 'Pass template + inputs, plus optional horizon and period_label' and enumerates valid template IDs. However, it does not explicitly explain when to choose this tool over alternatives like break_even or sensitivity_analysis, leaving some inference up to the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sensitivity_analysisAInspect
Vary one or more input assumptions and show the impact on a target output metric (one-at-a-time sensitivity). Provide 'template', the input to sweep via 'variable' (or 'variables' array), and 'target_metric' (defaults to the template's primary output). Control the sweep with 'variation' (fractional +/- around the baseline, default 0.2), 'steps' (default 5), or explicit 'values' / 'min'+'max'. Returns per-variable sweeps, an elasticity estimate, the output range, and a ranking of the most influential inputs.
| Name | Required | Description | Default |
|---|---|---|---|
| max | No | Sweep upper bound (with 'min'). | |
| min | No | Sweep lower bound (with 'max'). | |
| steps | No | Number of sweep points per variable (2-200). | |
| inputs | No | Scenario assumptions as {name: value}. Which keys are valid depends on the template (call list_templates). Unlisted keys fall back to documented defaults; unknown keys are ignored and reported in notes. You may also pass assumptions at the top level. | |
| values | No | Explicit sweep values for a single 'variable'. | |
| horizon | No | Number of periods to project forward (1..1200). Default depends on template (usually 12). | |
| template | Yes | Pre-built scenario template id: saas_growth, pricing_change, churn_impact, cost_reduction, hiring_plan, cash_runway, unit_economics, marketing_funnel, compound_growth (aliases like 'saas','pricing','runway','ltv' also resolve). Omit (or use 'custom') to run a free-form 'metrics' projection. | |
| variable | No | A single input name to sweep. | |
| variables | No | Multiple inputs to sweep (one at a time). Each: {name, variation?|values?|min?+max?, steps?}. | |
| variation | No | Fractional sweep around the baseline (0<v<=1). 0.2 = +/-20%. | |
| period_label | No | Label for each period; also sets annualization (periods/year). | month |
| target_metric | No | Output metric to track (see a template's 'outputs' via list_templates). Defaults to the template's primary output. |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries the burden. It discloses defaults (variation=0.2, steps=5), control options, and return contents (per-variable sweeps, elasticity, range, ranking). It does not explicitly state read-only behavior, but the analysis-focused wording implies no mutation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The single paragraph is dense but well-structured: purpose, usage, controls, then outputs. It is slightly long but every sentence adds value, so it earns a strong score.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 12 parameters, nested objects, and no output schema, the description is remarkably complete. It covers template selection, sweep mechanics, defaults, and return values. Minor details like alias handling are left to the schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, but the description adds substantial meaning beyond field descriptors: it explains how to combine 'template', 'variable/variables', 'target_metric', and 'variation/steps/values/min-max' into a coherent workflow. This significantly exceeds the baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: 'Vary one or more input assumptions and show impact on target output metric.' It clearly distinguishes from siblings like run_scenario or compare_scenarios by emphasizing one-at-a-time sensitivity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear usage context: specify template, variable(s), target_metric, and control via variation, steps, values, or min/max. It does not explicitly mention when not to use it or alternative tools, but the one-at-a-time distinction is implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Claim this connector by publishing a /.well-known/glama.json file on your server's domain with the following structure:
{
"$schema": "https://glama.ai/mcp/schemas/connector.json",
"maintainers": [{ "email": "your-email@example.com" }]
}The email address must match the email associated with your Glama account. Once published, Glama will automatically detect and verify the file within a few minutes.
Control your server's listing on Glama, including description and metadata
Access analytics and receive server usage reports
Get monitoring and health status updates for your server
Feature your server to boost visibility and reach more users
For users:
Full audit trail – every tool call is logged with inputs and outputs for compliance and debugging
Granular tool control – enable or disable individual tools per connector to limit what your AI agents can do
Centralized credential management – store and rotate API keys and OAuth tokens in one place
Change alerts – get notified when a connector changes its schema, adds or removes tools, or updates tool definitions, so nothing breaks silently
For server owners:
Proven adoption – public usage metrics on your listing show real-world traction and build trust with prospective users
Tool-level analytics – see which tools are being used most, helping you prioritize development and documentation
Direct user feedback – users can report issues and suggest improvements through the listing, giving you a channel you would not have otherwise
The connector status is unhealthy when Glama is unable to successfully connect to the server. This can happen for several reasons:
The server is experiencing an outage
The URL of the server is wrong
Credentials required to access the server are missing or invalid
If you are the owner of this MCP connector and would like to make modifications to the listing, including providing test credentials for accessing the server, please contact support@glama.ai.
Discussions
No comments yet. Be the first to start the discussion!
Related MCP Servers
- Alicense-qualityBmaintenanceThe verifiable risk engine for autonomous agents: deterministic, self-verifying financial calculations that an agent can delegate and prove. It covers liquidation and funding, position sizing and risk of ruin, options Greeks and margin, LP divergence, treasury concentration and depeg, execution quality checks, plus intelligence on options, DeFi, prediction markets, and transaction safety analysis.71MIT
- Alicense-qualityBmaintenanceA deterministic buyer-choice simulator inside ChatGPT that compares merchant offers against user-supplied alternatives, explains wins/losses, and tests what-if changes.MIT
- Flicense-qualityDmaintenanceEnables institutional-grade Monte Carlo risk analysis for portfolios, startups, real estate, and betting strategies using fat-tail distributions and proprietary algorithms. Provides comprehensive risk metrics including CVaR, VaR, ruin probability, and survival probability across multiple asset classes.1
- Alicense-qualityAmaintenanceDeterministic verification for AI-generated analysis. Reconciliation, consistency and Excel-integrity checks that stop the line when the numbers don't add up.1MIT
Your Connectors
Sign in to create a connector for this server.