Monte Carlo Analysis

Convert an unstructured risk question into a structured Monte Carlo run via the bundled scripts/monte_carlo.py toolkit. Sample from the right distribution, summarise percentiles, and return a histogram PNG plus spreadsheet export. Offer an interactive HTML chart when the user asks for it.

Instructions

1. Cognitive intake. Detect the core question (timeline, financial risk, yield, downtime, claims, etc.). If the user did not give enough numbers to parameterise a distribution, stop and ask — do not invent bounds. Prompt with the distribution options below.

2. Choose a distribution:

   • Triangular — user gives Minimum, Most Likely (peak), Maximum.
   • Normal — user gives Mean and Std Dev (optional base_modifier for portfolio / compounding style: outcome = base * (1 + return)).
   • Uniform — every value between Minimum and Maximum is equally likely.
   • Log-normal — non-negative, right-skewed risks; user gives log-scale mean and sigma. Highlight the Mean vs P50 gap when skew is large.
   • Poisson — count of rare events in a fixed interval; user gives lambda (expected count per interval, e.g. outages per month).
   • Weibull — time-to-failure / reliability; user gives shape (k) and scale (λ). Shape < 1 → infant mortality, = 1 → exponential, > 1 → wear-out.
   • Beta — bounded probability [0, 1] or percentage; user gives alpha and beta. Useful for proportions, conversion rates, or task-completion estimates.
   • Exponential — memoryless inter-arrival times; user gives scale (mean = 1 / rate). Good for time between random events (calls, failures, requests).

3. Defaults. If simulations are unspecified, use 10000. Prefer a clear chart_title and x_axis_label in the user's domain units (days, USD, hours).

4. Execute with the toolkit (import or CLI). Always produce:

   • Summary stats: mean, P5, P50, P95
   • PNG histogram with P5 / P50 / P95 marker lines
   • CSV of all iterations (opens in Excel)

   Also produce when asked:

   • Interactive HTML — self-contained Chart.js page with live sliders per distribution parameter, a simulations count slider, and a P-threshold calculator (P(outcome < X) = ?)
   • .xlsx workbook (requires openpyxl; otherwise point them to the CSV)

import sys
sys.path.insert(0, "scripts")
from monte_carlo import simulate

result = simulate({
    "distribution": "triangular",
    "low": 12, "peak": 18, "high": 45,
    "simulations": 10000,
    "chart_title": "Cloud migration duration (days)",
    "x_axis_label": "Days",
    "html": True,          # optional interactive Chart.js page with live controls
    "excel": True,         # optional .xlsx (falls back to CSV if openpyxl missing)
    "out_prefix": "simulation",
})
# result keys: mean, p5, p50, p95, brief_summary, chart_path, csv_path, …

5. Present results in domain language:

   • P5 = downside / late / risk baseline
   • P50 = median expectation
   • P95 = optimistic / upper ceiling (or severe upside for cost/risk)
   • Show or link the PNG; mention CSV/Excel paths; offer HTML if not requested yet.
   • Always end with a brief summary (2–3 sentences). Prefer result["brief_summary"] from the toolkit; you may lightly rephrase it into the user's domain (days, dollars, hours) without changing the numbers.

6. Response layout (adapt labels to the domain):

### Simulation Analytics Report
Ran {simulations} iterations ({distribution}).

| Metric | Value |
| --- | --- |
| P5 (risk baseline) | {p5} |
| P50 (median) | {p50} |
| P95 (upper) | {p95} |
| Mean | {mean} |

Histogram: {chart_path}
Raw iterations: {csv_path}

### Brief summary
{brief_summary}

Guardrails

• Never run the script when required parameters are missing — ask first.
• Do not fabricate distribution parameters or claim false precision.
• Prefer the bundled toolkit over hand-rolled NumPy each time, for consistent charts and exports.
• Keep LLM replies to the summary payload; do not dump all iteration rows into chat.

Bundled files

• scripts/monte_carlo.py — simulation engine, PNG, CSV/Excel, interactive HTML
• references/cheatsheet.md — parameters, CLI, test prompts
• assets/sample_triangular.json — demo payload (project timeline)
• assets/sample_normal.json — demo payload (portfolio returns)
• assets/sample_lognormal.json — demo payload (skewed downtime)
• assets/sample_poisson.json — demo payload (event count per interval)
• assets/sample_weibull.json — demo payload (component lifetime)
• assets/sample_exponential.json — demo payload (time between arrivals)

Run this — do not improvise

This capability's deterministic implementation is a RAPP single-file agent, linked beside this file as monte_carlo_analysis_agent.py and embedded as the fenced Python below (sha256 30c674a5f46cdc92…; a byte-exact copy is also vaulted in the capsule comment at the end of this file). On a host with sandbox execution, run the linked file directly — if it is missing, write the fence contents verbatim to monte_carlo_analysis_agent.py first:

python3 monte_carlo_analysis_agent.py '{"key": "value"}'      # arguments as one JSON object
echo '{"key": "value"}' | python3 monte_carlo_analysis_agent.py   # or on stdin
python3 monte_carlo_analysis_agent.py --tool                      # emit the JSON tool contract

Treat stdout as a tool result. If it reports missing or unresolved inputs, stop and collect them. If it returns steps, execute those steps in order exactly as returned; if it returns instructions, follow them with the supplied inputs. Otherwise use the result verbatim. Do not invent behavior beyond that output. On a host without code execution, treat the Parameters schema and the code below as the exact specification and never paraphrase a step. Never edit inside the generated markers; a converter-equipped host can instead restore the original file checksum-verified with the installed rapp-agent-converter/scripts/toast.py convert SKILL.md --to agent.

"""MonteCarloAnalysis -- Use this skill whenever the user asks to run a Monte Carlo simulation, model risk or uncertainty with random sampling, estimate P5/P50/P95 outcomes, or produce a probability distribution for project timelines, portfolio returns, downtime, costs, or similar uncertain variables. Trigger on phrases like 'run a Monte Carlo', 'simulate outcomes', 'probability chart for best and worst case', or when they give min/most-likely/max (or mean/std) and want thousands of iterations. Do NOT trigger for deterministic forecasts with no uncertainty, or for generic charts unrelated to simulation.

Generated by the rapp skill from monte-carlo-analysis. The RCI capsule at the bottom of this file carries the full original; `toast.py convert` restores it byte-exact."""

import json
import re
import sys

try:
    from agents.basic_agent import BasicAgent
except ImportError:  # running OUTSIDE a brainstem -- stay executable anyway.
    class BasicAgent:  # noqa: D101 - minimal stand-in, same contract
        def __init__(self, name=None, metadata=None):
            if name:
                self.name = name
            if metadata:
                self.metadata = metadata

        def perform(self, **kwargs):
            return "Not implemented."

        def system_context(self):
            return None

        def to_tool(self):
            return {"type": "function", "function": {
                "name": self.name,
                "description": self.metadata.get("description", ""),
                "parameters": self.metadata.get("parameters", {})}}

# The procedural layer, verbatim from the source capability.
INSTRUCTIONS = 'Convert an unstructured risk question into a structured Monte Carlo run via the\nbundled `scripts/monte_carlo.py` toolkit. Sample from the right distribution,\nsummarise percentiles, and return a histogram PNG plus spreadsheet export.\nOffer an interactive HTML chart when the user asks for it.\n\n## Instructions\n\n1. **Cognitive intake.** Detect the core question (timeline, financial risk,\n   yield, downtime, claims, etc.). If the user did not give enough numbers to\n   parameterise a distribution, **stop and ask** — do not invent bounds. Prompt\n   with the distribution options below.\n\n2. **Choose a distribution:**\n   - **Triangular** — user gives Minimum, Most Likely (peak), Maximum.\n   - **Normal** — user gives Mean and Std Dev (optional `base_modifier` for\n     portfolio / compounding style: `outcome = base * (1 + return)`).\n   - **Uniform** — every value between Minimum and Maximum is equally likely.\n   - **Log-normal** — non-negative, right-skewed risks; user gives log-scale\n     `mean` and `sigma`. Highlight the Mean vs P50 gap when skew is large.\n   - **Poisson** — count of rare events in a fixed interval; user gives `lambda`\n     (expected count per interval, e.g. outages per month).\n   - **Weibull** — time-to-failure / reliability; user gives `shape` (k) and\n     `scale` (λ). Shape < 1 → infant mortality, = 1 → exponential, > 1 → wear-out.\n   - **Beta** — bounded probability [0, 1] or percentage; user gives `alpha` and\n     `beta`. Useful for proportions, conversion rates, or task-completion estimates.\n   - **Exponential** — memoryless inter-arrival times; user gives `scale` (mean =\n     1 / rate). Good for time between random events (calls, failures, requests).\n\n3. **Defaults.** If simulations are unspecified, use `10000`. Prefer a clear\n   `chart_title` and `x_axis_label` in the user's domain units (days, USD, hours).\n\n4. **Execute** with the toolkit (import or CLI). Always produce:\n   - Summary stats: mean, P5, P50, P95\n   - PNG histogram with P5 / P50 / P95 marker lines\n   - CSV of all iterations (opens in Excel)\n\n   Also produce when asked:\n   - Interactive HTML — self-contained Chart.js page with live sliders per\n     distribution parameter, a simulations count slider, and a P-threshold\n     calculator (`P(outcome < X) = ?`)\n   - `.xlsx` workbook (requires `openpyxl`; otherwise point them to the CSV)\n\n```python\nimport sys\nsys.path.insert(0, "scripts")\nfrom monte_carlo import simulate\n\nresult = simulate({\n    "distribution": "triangular",\n    "low": 12, "peak": 18, "high": 45,\n    "simulations": 10000,\n    "chart_title": "Cloud migration duration (days)",\n    "x_axis_label": "Days",\n    "html": True,          # optional interactive Chart.js page with live controls\n    "excel": True,         # optional .xlsx (falls back to CSV if openpyxl missing)\n    "out_prefix": "simulation",\n})\n# result keys: mean, p5, p50, p95, brief_summary, chart_path, csv_path, …\n```\n\n5. **Present results** in domain language:\n   - P5 = downside / late / risk baseline\n   - P50 = median expectation\n   - P95 = optimistic / upper ceiling (or severe upside for cost/risk)\n   - Show or link the PNG; mention CSV/Excel paths; offer HTML if not requested yet.\n   - Always end with a **brief summary** (2–3 sentences). Prefer\n     `result["brief_summary"]` from the toolkit; you may lightly rephrase it into\n     the user's domain (days, dollars, hours) without changing the numbers.\n\n6. **Response layout** (adapt labels to the domain):\n\n```markdown\n### Simulation Analytics Report\nRan {simulations} iterations ({distribution}).\n\n| Metric | Value |\n| --- | --- |\n| P5 (risk baseline) | {p5} |\n| P50 (median) | {p50} |\n| P95 (upper) | {p95} |\n| Mean | {mean} |\n\nHistogram: {chart_path}\nRaw iterations: {csv_path}\n\n### Brief summary\n{brief_summary}\n```\n\n## Guardrails\n\n- Never run the script when required parameters are missing — ask first.\n- Do not fabricate distribution parameters or claim false precision.\n- Prefer the bundled toolkit over hand-rolled NumPy each time, for consistent\n  charts and exports.\n- Keep LLM replies to the summary payload; do not dump all iteration rows\n  into chat.\n\n## Bundled files\n\n- `scripts/monte_carlo.py` — simulation engine, PNG, CSV/Excel, interactive HTML\n- `references/cheatsheet.md` — parameters, CLI, test prompts\n- `assets/sample_triangular.json` — demo payload (project timeline)\n- `assets/sample_normal.json` — demo payload (portfolio returns)\n- `assets/sample_lognormal.json` — demo payload (skewed downtime)\n- `assets/sample_poisson.json` — demo payload (event count per interval)\n- `assets/sample_weibull.json` — demo payload (component lifetime)\n- `assets/sample_exponential.json` — demo payload (time between arrivals)'

# Ordered commands lifted verbatim from the capability's own documentation.
STEPS = []


class MonteCarloAnalysisAgent(BasicAgent):
    def __init__(self):
        self.name = 'MonteCarloAnalysis'
        self.metadata = {
          "name": "MonteCarloAnalysis",
          "description": "Use this skill whenever the user asks to run a Monte Carlo simulation, model risk or uncertainty with random sampling, estimate P5/P50/P95 outcomes, or produce a probability distribution for project timelines, portfolio returns, downtime, costs, or similar uncertain variables. Trigger on phrases like 'run a Monte Carlo', 'simulate outcomes', 'probability chart for best and worst case', or when they give min/most-likely/max (or mean/std) and want thousands of iterations. Do NOT trigger for deterministic forecasts with no uncertainty, or for generic charts unrelated to simulation.",
          "parameters": {
            "type": "object",
            "properties": {},
            "required": []
          }
        }
        super().__init__(name=self.name, metadata=self.metadata)

    def perform(self, **kwargs):  # toaster:generated-perform
        return json.dumps({"status": "ok", "instructions": INSTRUCTIONS,
                           "inputs": kwargs,
                           "note": "Prose-only capability: follow INSTRUCTIONS "
                                   "with the given inputs."}, indent=2)

if __name__ == "__main__":
    #     echo '{"arg": "value"}' | python3 monte_carlo_analysis_agent.py
    #     python3 monte_carlo_analysis_agent.py '{"arg": "value"}'
    #     python3 monte_carlo_analysis_agent.py --tool          # emit the JSON tool contract
    _a = sys.argv[1:]
    if _a and _a[0] == "--tool":
        print(json.dumps(MonteCarloAnalysisAgent().to_tool(), indent=2))
    else:
        _raw = _a[0] if _a else (sys.stdin.read().strip() or "{}")
        print(MonteCarloAnalysisAgent().perform(**json.loads(_raw)))

# rci-capsule:v1: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