From 64fb83257d0a9d564234ced52cbcdb81215805a4 Mon Sep 17 00:00:00 2001 From: Robert Helewka Date: Wed, 10 Jun 2026 14:26:49 -0400 Subject: [PATCH] feat: add GenesysCX study and fix Streamlit chart key collisions - Add 202512_GenesysCX TEI study (config, seed data, notebooks, README) with NPV $10.8M / ROI 266% including AI-token cost line - Add explicit `key` parameter to all chart wrappers in app/components to prevent StreamlitDuplicateElementId errors when the same figure type renders across Summary/Benefits/Costs tabs - Render benefits bar and cost pie charts on their respective tabs - Add benefits_vs_costs_by_year chart wrapper --- README.md | 4 + app/components/charts.py | 32 +- app/views/benefits.py | 5 + app/views/costs.py | 16 + app/views/summary.py | 64 +- core/notebook_helpers/charts.py | 146 +- studies/202512_GenesysCX/README.md | 51 + studies/202512_GenesysCX/__init__.py | 0 studies/202512_GenesysCX/config.py | 38 + .../ctm-token-calculator/.gitignore | 4 + .../ctm-token-calculator/README.md | 82 + .../ctm-token-calculator/app/streamlit_app.py | 576 ++ .../notebooks/ctm_token_calculator.ipynb | 7052 +++++++++++++++++ .../ctm-token-calculator/pyproject.toml | 31 + .../ctm-token-calculator/requirements.txt | 9 + .../tests/test_benefit_model.py | 107 + .../tests/test_business_case.py | 117 + .../tests/test_cost_model.py | 140 + .../ctm-token-calculator/tests/test_meters.py | 66 + .../tokencalc/__init__.py | 77 + .../tokencalc/benefit_model.py | 379 + .../tokencalc/business_case.py | 188 + .../tokencalc/cost_model.py | 301 + .../tokencalc/defaults.py | 356 + .../ctm-token-calculator/tokencalc/exports.py | 131 + .../ctm-token-calculator/tokencalc/inputs.py | 149 + .../ctm-token-calculator/tokencalc/meters.py | 87 + .../ctm-token-calculator/tokencalc/rollout.py | 81 + .../tokencalc/scenarios.py | 112 + studies/202512_GenesysCX/exports/.gitkeep | 0 .../notebooks/00_provision.ipynb | 929 +++ .../notebooks/01_business_case.ipynb | 376 + studies/202512_GenesysCX/seed_data.py | 231 + .../notebooks/02_costs.ipynb | 1004 ++- 34 files changed, 12902 insertions(+), 39 deletions(-) create mode 100644 studies/202512_GenesysCX/README.md create mode 100644 studies/202512_GenesysCX/__init__.py create mode 100644 studies/202512_GenesysCX/config.py create mode 100644 studies/202512_GenesysCX/ctm-token-calculator/.gitignore create mode 100644 studies/202512_GenesysCX/ctm-token-calculator/README.md create mode 100644 studies/202512_GenesysCX/ctm-token-calculator/app/streamlit_app.py create mode 100644 studies/202512_GenesysCX/ctm-token-calculator/notebooks/ctm_token_calculator.ipynb create mode 100644 studies/202512_GenesysCX/ctm-token-calculator/pyproject.toml create mode 100644 studies/202512_GenesysCX/ctm-token-calculator/requirements.txt create mode 100644 studies/202512_GenesysCX/ctm-token-calculator/tests/test_benefit_model.py create mode 100644 studies/202512_GenesysCX/ctm-token-calculator/tests/test_business_case.py create mode 100644 studies/202512_GenesysCX/ctm-token-calculator/tests/test_cost_model.py create mode 100644 studies/202512_GenesysCX/ctm-token-calculator/tests/test_meters.py create mode 100644 studies/202512_GenesysCX/ctm-token-calculator/tokencalc/__init__.py create mode 100644 studies/202512_GenesysCX/ctm-token-calculator/tokencalc/benefit_model.py create mode 100644 studies/202512_GenesysCX/ctm-token-calculator/tokencalc/business_case.py create mode 100644 studies/202512_GenesysCX/ctm-token-calculator/tokencalc/cost_model.py create mode 100644 studies/202512_GenesysCX/ctm-token-calculator/tokencalc/defaults.py create mode 100644 studies/202512_GenesysCX/ctm-token-calculator/tokencalc/exports.py create mode 100644 studies/202512_GenesysCX/ctm-token-calculator/tokencalc/inputs.py create mode 100644 studies/202512_GenesysCX/ctm-token-calculator/tokencalc/meters.py create mode 100644 studies/202512_GenesysCX/ctm-token-calculator/tokencalc/rollout.py create mode 100644 studies/202512_GenesysCX/ctm-token-calculator/tokencalc/scenarios.py create mode 100644 studies/202512_GenesysCX/exports/.gitkeep create mode 100644 studies/202512_GenesysCX/notebooks/00_provision.ipynb create mode 100644 studies/202512_GenesysCX/notebooks/01_business_case.ipynb create mode 100644 studies/202512_GenesysCX/seed_data.py diff --git a/README.md b/README.md index b7bb5dd..443c7f5 100644 --- a/README.md +++ b/README.md @@ -264,6 +264,10 @@ palladium/ │ ├── views/ # benefits, costs, summary, versions (NOT `pages/` — avoids Streamlit auto-multipage) │ └── components/ # tables, charts ├── studies/ # One folder per TEI engagement +│ ├── 202512_GenesysCX/ # CX Cloud (Genesys + Salesforce) TEI +│ │ ├── README.md # NPV $10.8M · ROI 266% + AI-token line +│ │ ├── config.py / seed_data.py # study-scoped PALLADIUM_GENESYSCX_* keys +│ │ └── notebooks/ # 00_provision, 01_business_case │ └── 202602_AmazonConnect/ │ ├── README.md │ ├── config.py # TOOL_PUBLIC_ID, REPORT_PUBLIC_ID diff --git a/app/components/charts.py b/app/components/charts.py index edd4c6d..87dbbd9 100644 --- a/app/components/charts.py +++ b/app/components/charts.py @@ -1,4 +1,9 @@ -"""Streamlit-friendly chart wrappers (delegate to core.notebook_helpers.charts).""" +"""Streamlit-friendly chart wrappers (delegate to core.notebook_helpers.charts). + +Every wrapper takes a ``key`` — the same figure type renders on multiple +tabs (Summary, Benefits, Costs) within one script run, so Streamlit needs +explicit element IDs to avoid StreamlitDuplicateElementId errors. +""" from __future__ import annotations @@ -7,26 +12,31 @@ import streamlit as st from core.notebook_helpers import charts as core_charts -def cashflow(yearly_breakdown, *, initial_cost: float = 0.0) -> None: +def cashflow(yearly_breakdown, *, initial_cost: float = 0.0, key: str = "cashflow") -> None: fig = core_charts.cashflow_chart(yearly_breakdown, initial_cost=initial_cost) - st.plotly_chart(fig, width="stretch") + st.plotly_chart(fig, width="stretch", key=key) -def benefits_bar(items) -> None: +def benefits_bar(items, *, key: str = "benefits_bar") -> None: fig = core_charts.benefits_bar(items) - st.plotly_chart(fig, width="stretch") + st.plotly_chart(fig, width="stretch", key=key) -def cost_pie(items) -> None: +def cost_pie(items, *, key: str = "cost_pie") -> None: fig = core_charts.cost_breakdown_pie(items) - st.plotly_chart(fig, width="stretch") + st.plotly_chart(fig, width="stretch", key=key) -def scenario_bars(scenarios) -> None: +def benefits_vs_costs_by_year(benefit_items, cost_items, *, key: str = "by_year") -> None: + fig = core_charts.benefits_vs_costs_by_year(benefit_items, cost_items) + st.plotly_chart(fig, width="stretch", key=key) + + +def scenario_bars(scenarios, *, key: str = "scenario_bars") -> None: fig = core_charts.scenario_comparison(scenarios) - st.plotly_chart(fig, width="stretch") + st.plotly_chart(fig, width="stretch", key=key) -def waterfall(values) -> None: +def waterfall(values, *, key: str = "waterfall") -> None: fig = core_charts.waterfall(values) - st.plotly_chart(fig, width="stretch") + st.plotly_chart(fig, width="stretch", key=key) diff --git a/app/views/benefits.py b/app/views/benefits.py index 9c56e22..232654d 100644 --- a/app/views/benefits.py +++ b/app/views/benefits.py @@ -4,6 +4,7 @@ from __future__ import annotations import streamlit as st +from app.components import charts from app.components.tables import df_to_values, value_editor from app.utils import icon @@ -50,3 +51,7 @@ def render(client: TEIClient, tool: dict) -> None: "applied at calculate time. Use the Recalculate button in the " "sidebar after saving to refresh the summary." ) + + if values: + st.divider() + charts.benefits_bar(values, key=f"benefits_tab_bar_{public_id}") diff --git a/app/views/costs.py b/app/views/costs.py index 3eb0fe0..40b20b8 100644 --- a/app/views/costs.py +++ b/app/views/costs.py @@ -4,6 +4,7 @@ from __future__ import annotations import streamlit as st +from app.components import charts from app.components.tables import df_to_values, value_editor from app.utils import icon @@ -50,3 +51,18 @@ def render(client: TEIClient, tool: dict) -> None: "are end-of-year cashflows. Costs are risk-adjusted upward " "(higher risk → higher cost)." ) + + if values: + st.divider() + col_pie, col_year = st.columns(2) + with col_pie: + charts.cost_pie(values, key=f"costs_tab_pie_{public_id}") + with col_year: + benefit_values = [ + v + for v in safe(client.get_values, public_id) or [] + if v.get("table") == "benefits" + ] + charts.benefits_vs_costs_by_year( + benefit_values, values, key=f"costs_tab_by_year_{public_id}" + ) diff --git a/app/views/summary.py b/app/views/summary.py index fd6139e..875e20d 100644 --- a/app/views/summary.py +++ b/app/views/summary.py @@ -56,19 +56,61 @@ def render(client: TEIClient, tool: dict) -> None: st.divider() - # Build the yearly breakdown from the documented per-year summary keys - # (benefits_year_N / costs_year_N) when no pre-built breakdown exists. - yb = summary.get("yearly_breakdown") or [] + # ── Financial visualizations ──────────────────────────────────── + # Built from the live value rows so Year-0 "Initial" amounts stay + # separate (Athena's per-year summary folds them into Year 1). + values = safe(client.get_values, public_id) or [] + benefit_rows = [v for v in values if v.get("table") == "benefits"] + cost_rows = [v for v in values if v.get("table") == "costs"] + + if benefit_rows or cost_rows: + col_pie, col_bar = st.columns(2) + with col_pie: + charts.cost_pie(cost_rows, key=f"summary_pie_{public_id}") + with col_bar: + charts.benefits_bar(benefit_rows, key=f"summary_bar_{public_id}") + charts.benefits_vs_costs_by_year( + benefit_rows, cost_rows, key=f"summary_by_year_{public_id}" + ) + + # Cash flow + cumulative net — the Forrester-style exhibit. + def _yearly_breakdown_from_values(): + initial = sum(float(c.get("initial") or 0) for c in cost_rows) + years: set[int] = set() + for v in [*benefit_rows, *cost_rows]: + years.update(int(y) for y in (v.get("year_values") or {})) + rows, cumulative = [], -initial + for y in sorted(years): + b = sum( + float((v.get("year_values") or {}).get(str(y), 0) or 0) + * (1 - float(v.get("risk_adjustment") or 0)) + for v in benefit_rows + ) + c = sum( + float((v.get("year_values") or {}).get(str(y), 0) or 0) + for v in cost_rows + ) + cumulative += b - c + rows.append( + {"year": y, "benefits": b, "costs": c, "net": b - c, + "cumulative_net": cumulative} + ) + return rows, initial + + yb, initial = ([], 0.0) + if benefit_rows or cost_rows: + yb, initial = _yearly_breakdown_from_values() if not yb: + # Fallback: documented per-year summary keys (initial folded in Y1). n = 1 while f"benefits_year_{n}" in summary or f"costs_year_{n}" in summary: b = float(summary.get(f"benefits_year_{n}") or 0) c = float(summary.get(f"costs_year_{n}") or 0) yb.append({"year": n, "benefits": b, "costs": c, "net": b - c}) n += 1 - initial = float(summary.get("initial_costs") or 0) + initial = float(summary.get("initial_costs") or 0) if yb: - charts.cashflow(yb, initial_cost=initial) + charts.cashflow(yb, initial_cost=initial, key=f"summary_cashflow_{public_id}") with st.expander("Cash flow table"): _cur = currency_fmt() st.dataframe( @@ -85,6 +127,14 @@ def render(client: TEIClient, tool: dict) -> None: else: st.caption("No yearly breakdown in this summary.") + # Waterfall — Benefits PV down to NPV. + if bpv or cpv: + charts.waterfall([ + ("Benefits PV", bpv), + ("Costs PV", -cpv), + ("NPV", npv), + ], key=f"summary_waterfall_{public_id}") + # Scenario comparison — computed locally from current values with st.expander("Scenario analysis (conservative / moderate / aggressive)"): envelope = safe( @@ -95,7 +145,9 @@ def render(client: TEIClient, tool: dict) -> None: study_slug=report.get("name", ""), ) if envelope and envelope.get("scenarios"): - charts.scenario_bars(envelope["scenarios"]) + charts.scenario_bars( + envelope["scenarios"], key=f"summary_scenarios_{public_id}" + ) rows = [ { "Scenario": k, diff --git a/core/notebook_helpers/charts.py b/core/notebook_helpers/charts.py index 16c018a..52b3593 100644 --- a/core/notebook_helpers/charts.py +++ b/core/notebook_helpers/charts.py @@ -20,6 +20,70 @@ PALETTE = { "cumulative": "#616161", # grey } +#: Visual theme — override per study/client with :func:`apply_theme`. +#: Hex colours; fonts are CSS font-family strings. +THEME = { + "heading_font": "Helvetica Neue, Arial, sans-serif", + "body_font": "Helvetica, Arial, sans-serif", + "font_color": "#1F2937", + # Circle-chart slice colours a–j, used in order. + "pie_colors": [ + "#1565C0", # a + "#2E7D32", # b + "#C62828", # c + "#F9A825", # d + "#6A1B9A", # e + "#00838F", # f + "#EF6C00", # g + "#5D4037", # h + "#37474F", # i + "#AD1457", # j + ], + "bar_green": "#2E7D32", + "bar_red": "#C62828", +} + + +def apply_theme(**overrides) -> dict: + """ + Override theme values for all charts in this session. + + Accepts any THEME key. ``pie_colors`` may be a list (used in order) or + a dict keyed ``"a"``–``"j"`` (sorted alphabetically). Returns the + active theme. Example:: + + from core.notebook_helpers import charts + charts.apply_theme( + heading_font="Georgia, serif", + font_color="#102A43", + pie_colors={"a": "#1565C0", "b": "#2E7D32"}, + bar_green="#1B5E20", + bar_red="#B71C1C", + ) + """ + for key, value in overrides.items(): + if key not in THEME: + raise KeyError( + f"Unknown theme key {key!r}. Valid keys: {sorted(THEME)}" + ) + if key == "pie_colors" and isinstance(value, dict): + value = [value[k] for k in sorted(value)] + THEME[key] = value + return THEME + + +def _themed(fig: go.Figure) -> go.Figure: + """Apply theme fonts/colours to a figure's layout.""" + fig.update_layout( + font={"family": THEME["body_font"], "color": THEME["font_color"]}, + title_font={ + "family": THEME["heading_font"], + "color": THEME["font_color"], + }, + legend_font={"family": THEME["body_font"], "color": THEME["font_color"]}, + ) + return fig + def cashflow_chart( yearly_breakdown: list[dict], @@ -50,13 +114,13 @@ def cashflow_chart( name="Total benefits", x=years, y=benefits, - marker_color=PALETTE["benefits"], + marker_color=THEME["bar_green"], ) fig.add_bar( name="Total costs", x=years, y=costs, - marker_color=PALETTE["costs"], + marker_color=THEME["bar_red"], ) fig.add_scatter( name="Cumulative net benefits", @@ -72,7 +136,7 @@ def cashflow_chart( legend={"orientation": "h", "y": -0.15}, margin={"l": 40, "r": 20, "t": 60, "b": 40}, ) - return fig + return _themed(fig) def benefits_bar(items: list[dict], *, title: str = "Benefits (Three-Year)") -> go.Figure: @@ -91,7 +155,7 @@ def benefits_bar(items: list[dict], *, title: str = "Benefits (Three-Year)") -> x=totals, y=labels, orientation="h", - marker_color=PALETTE["benefits"], + marker_color=THEME["bar_green"], text=[f"${t/1_000_000:,.1f}M" for t in totals], textposition="auto", ) @@ -102,7 +166,7 @@ def benefits_bar(items: list[dict], *, title: str = "Benefits (Three-Year)") -> yaxis={"autorange": "reversed"}, margin={"l": 40, "r": 20, "t": 60, "b": 40}, ) - return fig + return _themed(fig) def cost_breakdown_pie( @@ -122,9 +186,64 @@ def cost_breakdown_pie( labels.append(it.get("label", "") or it.get("field_key", "")) values.append(ra_total) - fig = go.Figure(go.Pie(labels=labels, values=values, hole=0.35)) + fig = go.Figure(go.Pie(labels=labels, values=values, hole=0.35, + marker={"colors": THEME["pie_colors"]})) fig.update_layout(title=title, margin={"l": 40, "r": 20, "t": 60, "b": 40}) - return fig + return _themed(fig) + + +def benefits_vs_costs_by_year( + benefit_items: list[dict], + cost_items: list[dict], + *, + title: str = "Benefits vs Costs by Year (Risk-Adjusted)", +) -> go.Figure: + """ + Grouped bars of risk-adjusted benefits and costs per year, with an + Initial (Year 0) column for one-time costs. + + Accepts the friendly value rows from ``TEIClient.get_values``: + benefit values are nominal (field-level risk adjustment applied here); + cost values are stored already risk-adjusted (Palladium convention), + with ``initial`` carrying the Year-0 amount. + """ + years: set[int] = set() + for it in [*benefit_items, *cost_items]: + years.update(int(y) for y in (it.get("year_values") or {})) + year_list = sorted(years) or [1, 2, 3] + + benefits_by_year: dict[int, float] = dict.fromkeys(year_list, 0.0) + costs_by_year: dict[int, float] = dict.fromkeys(year_list, 0.0) + initial_total = 0.0 + + for it in benefit_items: + rf = float(it.get("risk_adjustment") or 0.0) + for y, v in (it.get("year_values") or {}).items(): + benefits_by_year[int(y)] += float(v or 0) * (1.0 - rf) + for it in cost_items: + initial_total += float(it.get("initial") or 0.0) + for y, v in (it.get("year_values") or {}).items(): + costs_by_year[int(y)] += float(v or 0) + + x = ["Initial"] + [f"Year {y}" for y in year_list] + benefits = [0.0] + [benefits_by_year[y] for y in year_list] + costs = [initial_total] + [costs_by_year[y] for y in year_list] + + fig = go.Figure() + fig.add_bar(name="Benefits", x=x, y=benefits, marker_color=THEME["bar_green"], + text=[f"${v/1_000_000:,.1f}M" if v else "" for v in benefits], + textposition="outside") + fig.add_bar(name="Costs", x=x, y=costs, marker_color=THEME["bar_red"], + text=[f"${v/1_000_000:,.1f}M" if v else "" for v in costs], + textposition="outside") + fig.update_layout( + title=title, + barmode="group", + yaxis_tickformat="$,.0f", + legend={"orientation": "h", "y": -0.15}, + margin={"l": 40, "r": 20, "t": 60, "b": 40}, + ) + return _themed(fig) def scenario_comparison(scenarios: dict) -> go.Figure: @@ -137,8 +256,8 @@ def scenario_comparison(scenarios: dict) -> go.Figure: npvs = [float(scenarios[k].get("npv") or 0) for k in keys] fig = go.Figure() - fig.add_bar(name="Benefits PV", x=keys, y=benefits, marker_color=PALETTE["benefits"]) - fig.add_bar(name="Costs PV", x=keys, y=costs, marker_color=PALETTE["costs"]) + fig.add_bar(name="Benefits PV", x=keys, y=benefits, marker_color=THEME["bar_green"]) + fig.add_bar(name="Costs PV", x=keys, y=costs, marker_color=THEME["bar_red"]) fig.add_bar(name="NPV", x=keys, y=npvs, marker_color=PALETTE["net_positive"]) fig.update_layout( title="Scenario Comparison", @@ -146,7 +265,7 @@ def scenario_comparison(scenarios: dict) -> go.Figure: yaxis_tickformat="$,.0f", legend={"orientation": "h", "y": -0.15}, ) - return fig + return _themed(fig) def cumulative_benefits_chart( @@ -169,7 +288,7 @@ def cumulative_benefits_chart( ) ) fig.update_layout(title=title, yaxis_tickformat="$,.0f") - return fig + return _themed(fig) def waterfall(values: Iterable[tuple[str, float]], *, title: str = "TEI Waterfall") -> go.Figure: @@ -187,7 +306,10 @@ def waterfall(values: Iterable[tuple[str, float]], *, title: str = "TEI Waterfal measure=measures, text=[f"${v/1_000_000:,.1f}M" for v in amounts], textposition="outside", + increasing={"marker": {"color": THEME["bar_green"]}}, + decreasing={"marker": {"color": THEME["bar_red"]}}, + totals={"marker": {"color": PALETTE["net_positive"]}}, ) ) fig.update_layout(title=title, yaxis_tickformat="$,.0f") - return fig + return _themed(fig) diff --git a/studies/202512_GenesysCX/README.md b/studies/202512_GenesysCX/README.md new file mode 100644 index 0000000..585dbd9 --- /dev/null +++ b/studies/202512_GenesysCX/README.md @@ -0,0 +1,51 @@ +# Genesys CX Cloud TEI — December 2025 + +Source: Forrester, *The Total Economic Impact™ Of CX Cloud — Cost Savings And +Business Benefits Enabled By Genesys And Salesforce* (commissioned by Genesys +and Salesforce, December 2025). PDF in `docs/`. + +## Headline (published, 3-yr risk-adjusted PV @ 10%) + +| Metric | Value | +|---|---| +| Benefits PV | $14,840,638 | +| Costs PV | $4,057,170 | +| **NPV** | **$10,783,468** | +| **ROI** | **266%** | +| Payback | ~4 months (computed; not headlined in the study) | + +Composite: global supply company, $2.5B revenue, 10,000 employees, 600 CX +agents (400 concurrent licenses), 80,000 weekly interactions @ 12 min. + +## Structure + +4 benefits (legacy retirement ↓5%, self-service savings ↓15%, agent +efficiency ↓10%, agent-assist sales ↓5%) and 3 published costs (licenses ↑5%, +implementation ↑10% — initial-only, ongoing management ↑10%), **plus one +Palladium addition**: `genesys_ai_tokens`, an AI Experience token consumption +line the published study omits (it models $0 AI cost while three of four +benefits depend on AI). Stored exactly as Athena stores it — a single annual +cost value, entered from the Genesys quote in `01_business_case.ipynb` (which +includes a sensitivity sweep), with quote details kept in the field notes. +Seeded at $0 to reproduce the published totals. + +## Study quirks (documented, handled) + +- p.14 prints implementation initial as $1,304,600; correct figure is + $1,309,000 (= 1,190,000 × 1.10) per the detail table and cash-flow analysis. +- B7's printed formula cites B2 (15%) where the 12-minute interaction length + is meant; the result (40 FTEs) is correct. +- The initial cost is ~32% of cost PV, so Athena's discount-initial-as-Year-1 + behaviour shifts ROI to ~277%. Verification matches `ATHENA_EXPECTED` + tightly, then reconciles to `PUBLISHED` with this explained delta. + +## Notebooks + +| Notebook | Purpose | +|---|---| +| `00_provision.ipynb` | Create template + fields + tool in Athena (client/proposal selection), seed, calculate, verify | +| `01_business_case.ipynb` | Working business case + Genesys AI token quantity × price sensitivity | + +Env keys are study-scoped: `PALLADIUM_GENESYSCX_REPORT_PUBLIC_ID`, +`PALLADIUM_GENESYSCX_TOOL_PUBLIC_ID`, `PALLADIUM_GENESYSCX_PROPOSAL_ID` / +`PALLADIUM_GENESYSCX_ENGAGEMENT_ID`. diff --git a/studies/202512_GenesysCX/__init__.py b/studies/202512_GenesysCX/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/studies/202512_GenesysCX/config.py b/studies/202512_GenesysCX/config.py new file mode 100644 index 0000000..1dc9792 --- /dev/null +++ b/studies/202512_GenesysCX/config.py @@ -0,0 +1,38 @@ +""" +Study configuration for the Genesys CX Cloud TEI (Forrester, December 2025). + +Env keys are *study-scoped* (PALLADIUM_GENESYSCX_*) so this study can coexist +with the Amazon Connect tool IDs in the same .env. 00_provision.ipynb writes +them for you. +""" + +from __future__ import annotations + +import os + +#: Human-friendly study identifier — used in export metadata + filenames. +STUDY_SLUG = "202512_GenesysCX" + + +def _int_env(name: str) -> int | None: + raw = os.getenv(name, "").strip() + return int(raw) if raw else None + + +#: TEI Report template public_id (12-char short UUID). +REPORT_PUBLIC_ID: str = os.getenv("PALLADIUM_GENESYSCX_REPORT_PUBLIC_ID", "") + +#: TEI Tool instance public_id. +TOOL_PUBLIC_ID: str = os.getenv("PALLADIUM_GENESYSCX_TOOL_PUBLIC_ID", "") + +#: Default discount rate used for local validation of the study numbers. +DISCOUNT_RATE = 0.10 + +#: Analysis horizon (years). +ANALYSIS_YEARS = 3 + +#: Athena Proposal PK (a TEI tool attaches to a Proposal OR an Engagement). +PROPOSAL_ID: int | None = _int_env("PALLADIUM_GENESYSCX_PROPOSAL_ID") + +#: Athena Engagement PK (alternative attachment point). +ENGAGEMENT_ID: int | None = _int_env("PALLADIUM_GENESYSCX_ENGAGEMENT_ID") diff --git a/studies/202512_GenesysCX/ctm-token-calculator/.gitignore b/studies/202512_GenesysCX/ctm-token-calculator/.gitignore new file mode 100644 index 0000000..cb31128 --- /dev/null +++ b/studies/202512_GenesysCX/ctm-token-calculator/.gitignore @@ -0,0 +1,4 @@ +exports/ +__pycache__/ +*.pyc +.ipynb_checkpoints/ diff --git a/studies/202512_GenesysCX/ctm-token-calculator/README.md b/studies/202512_GenesysCX/ctm-token-calculator/README.md new file mode 100644 index 0000000..49e8992 --- /dev/null +++ b/studies/202512_GenesysCX/ctm-token-calculator/README.md @@ -0,0 +1,82 @@ +# CTM Token Calculator + +**Genesys AI Token Cost & Business Case Calculator** — interactive, +defensible modeling of Genesys Cloud **CX 3** platform + AI feature costs +against realistic benefit scenarios, replacing single-point vendor ROI +outputs with sensitivity-aware **Floor / Realistic / Stretch** analysis. + +> ⚠️ **Planning tool.** Uses published Genesys list rates unless overridden — +> explicitly not a replacement for contractual pricing. No Genesys API +> integration; this is a forward-looking model, not a production-consumption +> dashboard. + +## CTM context + +- 9 sites (NAM, EMEA, AUZ, 6× APAC), **2,088 contracted named users** +- NAM volumes from CTM discovery; **all other site data is estimated — + confirm with CTM** (flagged throughout the UI) +- Cost takeouts include the NICE IEX (NAM) retirement placeholder ($1.3M/yr, + estimated) +- Every meter carries a confidence flag: 🟢 confirmed (published rate) · + 🟡 estimated · 🔴 unknown (working default, rate not yet sourced) + +## Install & run + +```bash +cd ctm-token-calculator +python -m venv .venv && source .venv/bin/activate +pip install -r requirements.txt + +# Streamlit app (7 pages: Inputs → Export) +streamlit run app/streamlit_app.py + +# JupyterLab notebook variant (same numbers, same library) +jupyter lab notebooks/ctm_token_calculator.ipynb + +# Tests +pytest +``` + +## Architecture + +All math lives in the pure-Python `tokencalc/` library; the notebook and +Streamlit app are thin presentation layers calling the same functions — +Run-All in the notebook produces identical headline numbers to the app on +default inputs. + +| Module | Purpose | +|---|---| +| `meters.py` | Token meter + pricing dataclasses, confidence enum | +| `defaults.py` | Genesys meter catalogue, CTM sites/takeouts/phasing, CX 3 rate ($111.28/user/mo) | +| `inputs.py` | Validated input dataclasses (sites, feature scopes, takeouts) | +| `scenarios.py` | Floor/Realistic/Stretch + benefit params (Genesys claim vs pressure-tested) | +| `cost_model.py` | Platform, per-user AI, consumption AI cost engines | +| `benefit_model.py` | AHT/ACW/email/deflection/STA benefit engines | +| `business_case.py` | 3-year P&L, NPV @ 8%, payback, ROI | +| `exports.py` | Multi-sheet Excel, CSV, JSON scenario save/load | + +### Correctness rules encoded in the model + +1. **Agent Copilot covers Supervisor AI Summary** — AI Summary & Insights is + never billed at sites where Copilot is enabled (Copilot's 40 tokens/user/mo + includes summarization). Implemented and tested. +2. **Billing-style rounding** — monthly consumption token totals are rounded + up (`ceil`) per site before pricing; per-user totals are exact. +3. **Regional pricing** — every site resolves its token rate through its + pricing region (US/EU/AU/APAC); nothing is hardcoded to US. +4. **Adoption ramp** — consumption features ramp (default Y1 = 70%); per-user + licences are paid in full from their phase year. Phasing is per-site, + per-feature, per-phase (1/2/3/off). + +### Verified reference numbers + +- STA: 2,088 users × 30 tokens × 12 × $1 = **$751,680** ✓ (test) +- Agent Copilot: 2,088 × 40 × 12 × $1 = **$1,002,240** ✓ (test) +- NPV hand-check: 100/yr × 3 @ 8% = 257.710 ✓ (test) + +## Auditability + +Every number traces to an input and a meter: cost rows carry the feature, +scope (sites), and confidence; benefit rows carry the driver line and scope; +the Excel export includes input, meter, cost-detail, benefit-detail, business +case, and three-scenario comparison sheets. diff --git a/studies/202512_GenesysCX/ctm-token-calculator/app/streamlit_app.py b/studies/202512_GenesysCX/ctm-token-calculator/app/streamlit_app.py new file mode 100644 index 0000000..3153594 --- /dev/null +++ b/studies/202512_GenesysCX/ctm-token-calculator/app/streamlit_app.py @@ -0,0 +1,576 @@ +""" +NTT DATA — CTM Token Calculator (Streamlit). + +Run from the ctm-token-calculator root:: + + streamlit run app/streamlit_app.py + +Thin presentation layer over ``tokencalc`` — all math lives in the +library, shared with the JupyterLab notebook. +""" + +from __future__ import annotations + +import dataclasses +import io +import json +import sys +from pathlib import Path + +# Import tokencalc from the project root without install +_ROOT = Path(__file__).resolve().parent.parent +if str(_ROOT) not in sys.path: + sys.path.insert(0, str(_ROOT)) + +import numpy as np +import pandas as pd +import plotly.express as px +import plotly.graph_objects as go +import streamlit as st + +import tokencalc.scenarios as tc_scenarios +from tokencalc import ( + CONTRACTED_NAMED_USERS, + CTM_DEFAULT_FEATURE_SCOPES, + CTM_DEFAULT_SITES, + CTM_DEFAULT_TAKEOUTS, + DEFAULT_METERS, + DEFAULT_PRICING, + Confidence, + CostTakeout, + FeatureScope, + SiteInput, + build_business_case, + calculate_total_benefit, + calculate_total_cost, + export_excel, + get_scenario, + meters_dataframe, + scenario_state_from_json, + scenario_state_to_json, + sites_dataframe, +) + +st.set_page_config(page_title="NTT DATA — CTM Token Calculator", + page_icon="🧮", layout="wide") + +YEARS = (1, 2, 3) +FEATURES = list(DEFAULT_METERS) +_DEFAULT_REALISTIC = { + k: v["realistic"] for k, v in tc_scenarios.BENEFIT_PARAMS.items() +} + + +# ── State ──────────────────────────────────────────────────────────── + +def _init_state(force: bool = False) -> None: + if force or "sites" not in st.session_state: + st.session_state.sites = list(CTM_DEFAULT_SITES) + st.session_state.takeouts = list(CTM_DEFAULT_TAKEOUTS) + st.session_state.scopes = [ + dataclasses.replace(s) for s in CTM_DEFAULT_FEATURE_SCOPES + ] + st.session_state.meters = dict(DEFAULT_METERS) + st.session_state.pricing = dict(DEFAULT_PRICING) + st.session_state.use_contracted = False + st.session_state.implementation_cost = 0.0 + for k, v in _DEFAULT_REALISTIC.items(): # reset benefit sliders + tc_scenarios.BENEFIT_PARAMS[k]["realistic"] = v + + +_init_state() + + +def _state_key() -> str: + """Stable serialization of inputs for st.cache_data keys.""" + return scenario_state_to_json( + st.session_state.sites, st.session_state.takeouts, st.session_state.scopes + ) + json.dumps( + { + "params": {k: v["realistic"] for k, v in tc_scenarios.BENEFIT_PARAMS.items()}, + "contracted": st.session_state.use_contracted, + "impl": st.session_state.implementation_cost, + "meters": {f: m.tokens_per_unit for f, m in st.session_state.meters.items()}, + "pricing": { + r: (p.list_rate_per_token, p.contracted_rate_per_token) + for r, p in st.session_state.pricing.items() + }, + } + ) + + +@st.cache_data(show_spinner=False) +def _cached_case(state_key: str, scenario: str) -> dict: + return build_business_case( + st.session_state.sites, st.session_state.scopes, + st.session_state.meters, st.session_state.pricing, + st.session_state.takeouts, scenario, + implementation_cost=st.session_state.implementation_cost, + use_contracted=st.session_state.use_contracted, + ) + + +def _case(scenario: str) -> dict: + return _cached_case(_state_key(), scenario) + + +# ── Sidebar ────────────────────────────────────────────────────────── + +st.sidebar.title("NTT DATA — CTM Token Calculator") +page = st.sidebar.radio("Page", [ + "1. Inputs", "2. Token Meters", "3. Cost Model", "4. Benefit Model", + "5. Business Case", "6. Sensitivity Analysis", "7. Export", +]) +st.sidebar.divider() +scenario_name = st.sidebar.radio( + "Scenario", ["floor", "realistic", "stretch"], index=1, horizontal=True +) +year = st.sidebar.radio("Year", YEARS, horizontal=True) +if st.sidebar.button("Reset to CTM defaults"): + _init_state(force=True) + st.cache_data.clear() + st.rerun() +st.sidebar.caption( + "⚠️ Planning tool — published list rates unless overridden; " + "not contractual pricing." +) + +sites: list[SiteInput] = st.session_state.sites +scopes: list[FeatureScope] = st.session_state.scopes +meters = st.session_state.meters +pricing = st.session_state.pricing +scenario = get_scenario(scenario_name) + + +def _users_warning() -> None: + total = sum(s.named_users for s in sites) + if total != CONTRACTED_NAMED_USERS: + st.warning( + f"Named users across sites = {total:,} ≠ contracted licence " + f"count {CONTRACTED_NAMED_USERS:,}." + ) + + +# ── Page 1: Inputs ─────────────────────────────────────────────────── + +if page == "1. Inputs": + st.header("Inputs") + st.caption("Site data outside NAM is **estimated — confirm with CTM data**.") + _users_warning() + + df = sites_dataframe(sites) + edited = st.data_editor(df, num_rows="dynamic", key="sites_editor") + if st.button("Apply site changes"): + try: + st.session_state.sites = [ + SiteInput( + **{ + **row, + "languages": [ + x.strip() for x in str(row["languages"]).split(",") if x.strip() + ], + } + ) + for row in edited.to_dict("records") + ] + st.cache_data.clear() + st.success("Sites updated.") + st.rerun() + except (ValueError, TypeError) as e: + st.error(f"Validation failed: {e}") + + st.subheader("Cost takeouts") + tdf = pd.DataFrame( + [ + {"name": t.name, "annual_cost": t.annual_cost, + "start_year": t.start_year, "confidence": t.confidence.value, + "notes": t.notes} + for t in st.session_state.takeouts + ] + ) + tedit = st.data_editor( + tdf, num_rows="dynamic", key="takeouts_editor", + column_config={ + "confidence": st.column_config.SelectboxColumn( + options=[c.value for c in Confidence] + ) + }, + ) + if st.button("Apply takeout changes"): + try: + st.session_state.takeouts = [ + CostTakeout( + name=r["name"], annual_cost=float(r["annual_cost"] or 0), + start_year=int(r["start_year"] or 1), + confidence=Confidence(r["confidence"]), notes=r["notes"] or "", + ) + for r in tedit.to_dict("records") + ] + st.cache_data.clear() + st.success("Takeouts updated.") + st.rerun() + except (ValueError, TypeError) as e: + st.error(f"Validation failed: {e}") + + st.subheader("Save / load scenario") + col1, col2 = st.columns(2) + with col1: + st.download_button( + "Download scenario JSON", + scenario_state_to_json(sites, st.session_state.takeouts, scopes), + file_name="ctm_scenario.json", mime="application/json", + ) + with col2: + up = st.file_uploader("Load scenario JSON", type="json") + if up is not None and st.button("Load"): + s, t, sc = scenario_state_from_json(up.read().decode()) + st.session_state.sites, st.session_state.takeouts = s, t + st.session_state.scopes = sc + st.cache_data.clear() + st.success("Scenario loaded.") + st.rerun() + +# ── Page 2: Token Meters ───────────────────────────────────────────── + +elif page == "2. Token Meters": + st.header("Token Meters") + st.dataframe(meters_dataframe(meters), width="stretch", hide_index=True) + + st.subheader("Override a meter rate") + feature = st.selectbox("Feature", FEATURES) + m = meters[feature] + override = st.toggle("Override default", key=f"ovr_{feature}") + if override: + new_rate = st.number_input( + "tokens per unit (per user/month for per-user meters)", + value=float(m.tokens_per_unit), min_value=0.0, step=0.005, + format="%.4f", + ) + if st.button("Apply override"): + meters[feature] = dataclasses.replace( + m, + tokens_per_unit=new_rate, + units_per_token=(1 / new_rate if new_rate and m.units_per_token else 0.0), + confidence=Confidence.ESTIMATED, + notes=m.notes + " [rate overridden by user]", + ) + st.cache_data.clear() + st.success(f"{feature} now {new_rate} tokens/unit (flagged estimated).") + + st.subheader("Token pricing per region") + st.session_state.use_contracted = st.toggle( + "Apply contracted rate (if known) instead of list rate", + value=st.session_state.use_contracted, + ) + for region, p in pricing.items(): + c1, c2 = st.columns(2) + with c1: + lr = st.number_input( + f"{region} — list $/token", value=float(p.list_rate_per_token), + min_value=0.0, key=f"list_{region}", + ) + with c2: + cr = st.number_input( + f"{region} — contracted $/token (0 = unknown)", + value=float(p.contracted_rate_per_token or 0.0), + min_value=0.0, key=f"con_{region}", + ) + pricing[region] = dataclasses.replace( + p, list_rate_per_token=lr, + contracted_rate_per_token=cr or None, + ) + +# ── Page 3: Cost Model ─────────────────────────────────────────────── + +elif page == "3. Cost Model": + st.header("Cost Model") + _users_warning() + + st.subheader("Feature enablement & phasing") + st.caption("Phase = model year the feature switches on at that site; 0 = off.") + site_names = [s.site_name for s in sites] + matrix = pd.DataFrame(0, index=site_names, columns=FEATURES, dtype=int) + for sc in scopes: + for sn in sc.enabled_sites: + if sn in matrix.index: + matrix.loc[sn, sc.feature] = sc.phase + edited_matrix = st.data_editor(matrix, key="phasing_matrix") + if st.button("Apply phasing"): + new_scopes: list[FeatureScope] = [] + for feature in FEATURES: + for phase in (1, 2, 3): + enabled = [sn for sn in site_names + if int(edited_matrix.loc[sn, feature]) == phase] + if enabled: + template = next( + (s for s in scopes if s.feature == feature), None + ) + new_scopes.append( + FeatureScope( + feature, enabled, phase=phase, + adoption_curve=( + template.adoption_curve if template else {} + ), + deflection_target=( + template.deflection_target if template else None + ), + eligibility_pct=( + template.eligibility_pct if template else None + ), + ) + ) + st.session_state.scopes = new_scopes + st.cache_data.clear() + st.success("Phasing updated.") + st.rerun() + + frames = [] + for y in YEARS: + d = calculate_total_cost( + sites, scopes, meters, pricing, scenario, y, + use_contracted=st.session_state.use_contracted, + ) + d["year"] = f"Y{y}" + frames.append(d) + cost_3y = pd.concat(frames, ignore_index=True) + + this_year = frames[year - 1] + total = this_year["annual_cost"].sum() + unknown = this_year[this_year["confidence"] == "unknown"]["annual_cost"].sum() + c1, c2 = st.columns(2) + c1.metric(f"Year {year} total cost ({scenario_name})", f"${total:,.0f}") + c2.metric("of which 🔴 unknown-rate features", f"${unknown:,.0f}", + help="Range driven by unsourced meter rates — total could move " + "materially once these are confirmed.") + + st.plotly_chart( + px.bar(cost_3y, x="year", y="annual_cost", color="cost_line", + title=f"Cost breakdown by feature — {scenario_name}", + labels={"annual_cost": "$/yr"}), + width="stretch", key="cost_stack", + ) + icon_map = {c.value: c.icon for c in Confidence} + show = this_year.copy() + show["confidence"] = show["confidence"].map( + lambda v: f"{icon_map.get(v, '')} {v}" + ) + st.dataframe(show.sort_values("annual_cost", ascending=False), + width="stretch", hide_index=True) + +# ── Page 4: Benefit Model ──────────────────────────────────────────── + +elif page == "4. Benefit Model": + st.header("Benefit Model") + st.caption("Sliders adjust the pressure-tested (realistic) parameters; " + "the Genesys-claim figures stay fixed for comparison.") + + cols = st.columns(3) + for i, (key, vals) in enumerate(tc_scenarios.BENEFIT_PARAMS.items()): + with cols[i % 3]: + tc_scenarios.BENEFIT_PARAMS[key]["realistic"] = st.slider( + key.replace("_", " "), + 0.0, max(1.0, vals["claim"]), + value=float(vals["realistic"]), step=0.005, format="%.3f", + key=f"bp_{key}", + ) + + frames = [] + for y in YEARS: + d = calculate_total_benefit(sites, scopes, scenario, y, params="realistic") + d["year"] = f"Y{y}" + frames.append(d) + ben_3y = pd.concat(frames, ignore_index=True) + + st.metric(f"Year {year} total benefit ({scenario_name})", + f"${frames[year - 1]['annual_value'].sum():,.0f}") + st.plotly_chart( + px.bar(ben_3y, x="year", y="annual_value", color="benefit_line", + title=f"Benefit breakdown by source — {scenario_name}", + labels={"annual_value": "$/yr"}), + width="stretch", key="benefit_stack", + ) + + claim = calculate_total_benefit(sites, scopes, scenario, year, params="claim") + realistic = frames[year - 1] + comp = pd.merge( + claim[["benefit_line", "annual_value"]].rename( + columns={"annual_value": "Genesys claim"}), + realistic[["benefit_line", "annual_value"]].rename( + columns={"annual_value": "Pressure-tested"}), + on="benefit_line", how="outer", + ).fillna(0) + fig = go.Figure([ + go.Bar(name="Genesys claim", x=comp.benefit_line, y=comp["Genesys claim"]), + go.Bar(name="Pressure-tested realistic", x=comp.benefit_line, + y=comp["Pressure-tested"]), + ]) + fig.update_layout(barmode="group", yaxis_tickformat="$,.0f", + title=f"Genesys claim vs pressure-tested — Year {year}") + st.plotly_chart(fig, width="stretch", key="claim_vs_real") + +# ── Page 5: Business Case ──────────────────────────────────────────── + +elif page == "5. Business Case": + st.header("Business Case") + st.session_state.implementation_cost = st.number_input( + "One-off implementation cost (amortized over 3 years)", + value=float(st.session_state.implementation_cost), min_value=0.0, + step=50_000.0, + ) + case = _case(scenario_name) + + pb = case["payback_period_years"] + c1, c2, c3 = st.columns(3) + c1.metric("NPV @ 8%", f"${case['npv']:,.0f}") + c2.metric("Payback", f"{pb:.2f} yrs" if pb is not None else "never") + c3.metric("3-Year ROI", f"{case['roi_3yr']:.0%}" if case["roi_3yr"] else "n/a") + + pnl = pd.concat( + [ + case["cost_by_year"].drop(columns="confidence"), + case["takeouts_by_year"].drop(columns="confidence"), + case["benefit_by_year"].drop(columns="confidence"), + case["net_by_year"], + ], + ignore_index=True, + ) + pnl["3-yr Total"] = pnl[["Y1", "Y2", "Y3"]].sum(axis=1) + st.dataframe( + pnl, width="stretch", hide_index=True, + column_config={ + c: st.column_config.NumberColumn(c, format="$%,.0f") + for c in ("Y1", "Y2", "Y3", "3-yr Total") + }, + ) + + fig = go.Figure() + for name in ("floor", "realistic", "stretch"): + c = _case(name) + fig.add_scatter( + x=c["cumulative_net"].year, y=c["cumulative_net"].cumulative_net, + mode="lines+markers", name=name.capitalize(), + ) + fig.update_layout(title="Cumulative net cash flow by scenario", + xaxis_title="Year", yaxis_tickformat="$,.0f") + st.plotly_chart(fig, width="stretch", key="cum_net") + +# ── Page 6: Sensitivity ────────────────────────────────────────────── + +elif page == "6. Sensitivity Analysis": + st.header("Sensitivity Analysis") + base_npv = _case(scenario_name)["npv"] + st.caption(f"Base 3-yr NPV ({scenario_name}): ${base_npv:,.0f}") + + def _npv_with(**overrides) -> float: + sc = dataclasses.replace(scenario, **overrides) + return build_business_case( + sites, scopes, meters, pricing, st.session_state.takeouts, sc, + implementation_cost=st.session_state.implementation_cost, + use_contracted=st.session_state.use_contracted, + )["npv"] + + drivers = [ + "voice_bot_deflection", "voice_bot_avg_minutes", "agentic_va_deflection", + "voice_summarization_eligibility", "voice_knowledge_eligibility", + "email_auto_respond_rate", "email_auto_suggest_acceptance", + ] + rows = [] + for d in drivers: + base_v = getattr(scenario, d) + lo = base_v * 0.75 if d == "voice_bot_avg_minutes" else min(base_v * 0.75, 1.0) + hi = base_v * 1.25 if d == "voice_bot_avg_minutes" else min(base_v * 1.25, 1.0) + rows.append({"driver": d, + "low": _npv_with(**{d: lo}) - base_npv, + "high": _npv_with(**{d: hi}) - base_npv}) + torn = pd.DataFrame(rows) + torn["swing"] = (torn.high - torn.low).abs() + torn = torn.sort_values("swing") + fig = go.Figure([ + go.Bar(y=torn.driver, x=torn.low, orientation="h", name="-25%"), + go.Bar(y=torn.driver, x=torn.high, orientation="h", name="+25%"), + ]) + fig.update_layout(barmode="overlay", title="Tornado — NPV impact of ±25%", + xaxis_tickformat="$,.0f") + st.plotly_chart(fig, width="stretch", key="tornado") + + st.subheader("Two-variable heatmap") + xs = np.linspace(0.0, 0.50, 6) # Email Auto-Respond rate + ys = np.linspace(0.0, 0.25, 6) # Agentic VA deflection + z = [[_npv_with(email_auto_respond_rate=float(x), + agentic_va_deflection=float(yv)) for x in xs] for yv in ys] + fig = go.Figure(go.Heatmap( + x=[f"{x:.0%}" for x in xs], y=[f"{yv:.0%}" for yv in ys], z=z, + colorbar={"title": "3-yr NPV"}, + )) + fig.update_layout(title="NPV: Email Auto-Respond rate × Agentic VA deflection", + xaxis_title="Email Auto-Respond rate", + yaxis_title="Agentic VA deflection") + st.plotly_chart(fig, width="stretch", key="heatmap") + + st.subheader("Break-even finder") + rates = np.linspace(0.0, 0.50, 26) + npvs = [_npv_with(email_auto_respond_rate=float(r)) for r in rates] + breakeven = next((r for r, v in zip(rates, npvs) if v >= 0), None) + if npvs[0] >= 0: + st.success(f"Case is NPV-positive even at 0% Auto-Respond " + f"(${npvs[0]:,.0f}).") + elif breakeven is not None: + st.info(f"Break-even at ~{breakeven:.0%} email Auto-Respond rate.") + else: + st.error("No break-even within 0–50% Auto-Respond.") + st.plotly_chart( + px.line(x=rates, y=npvs, + labels={"x": "Email Auto-Respond rate", "y": "3-yr NPV ($)"}), + width="stretch", key="breakeven", + ) + +# ── Page 7: Export ─────────────────────────────────────────────────── + +elif page == "7. Export": + st.header("Export") + case = _case(scenario_name) + cost_frames, ben_frames = [], [] + for y in YEARS: + d = calculate_total_cost(sites, scopes, meters, pricing, scenario, y, + use_contracted=st.session_state.use_contracted) + d["year"] = f"Y{y}" + cost_frames.append(d) + b = calculate_total_benefit(sites, scopes, scenario, y) + b["year"] = f"Y{y}" + ben_frames.append(b) + + comparison = pd.DataFrame([ + {"scenario": n, "NPV": _case(n)["npv"], + "payback_years": _case(n)["payback_period_years"], + "roi_3yr": _case(n)["roi_3yr"]} + for n in ("floor", "realistic", "stretch") + ]) + + pnl = pd.concat( + [case["cost_by_year"].drop(columns="confidence"), + case["takeouts_by_year"].drop(columns="confidence"), + case["benefit_by_year"].drop(columns="confidence"), + case["net_by_year"]], + ignore_index=True, + ) + + buf = io.BytesIO() + with pd.ExcelWriter(buf, engine="openpyxl") as writer: + sites_dataframe(sites).to_excel(writer, sheet_name="Inputs", index=False) + meters_dataframe(meters).to_excel(writer, sheet_name="Meters", index=False) + pd.concat(cost_frames).to_excel(writer, sheet_name="Cost detail", index=False) + pd.concat(ben_frames).to_excel(writer, sheet_name="Benefit detail", index=False) + pnl.to_excel(writer, sheet_name="Business case", index=False) + comparison.to_excel(writer, sheet_name="Scenario comparison", index=False) + st.download_button( + "⬇️ Download Excel workbook", + buf.getvalue(), + file_name=f"ctm_token_calculator_{scenario_name}.xlsx", + mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", + ) + st.download_button( + "⬇️ Download scenario JSON", + scenario_state_to_json(sites, st.session_state.takeouts, scopes), + file_name="ctm_scenario.json", mime="application/json", + ) + st.dataframe(comparison, width="stretch", hide_index=True) diff --git a/studies/202512_GenesysCX/ctm-token-calculator/notebooks/ctm_token_calculator.ipynb b/studies/202512_GenesysCX/ctm-token-calculator/notebooks/ctm_token_calculator.ipynb new file mode 100644 index 0000000..bbc184f --- /dev/null +++ b/studies/202512_GenesysCX/ctm-token-calculator/notebooks/ctm_token_calculator.ipynb @@ -0,0 +1,7052 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "758e4c36", + "metadata": {}, + "source": [ + "# CTM Token Calculator — Genesys AI Cost & Business Case\n", + "\n", + "**Version 0.1.0** · interactive working analysis for Robert / CTM stakeholders / NTT delivery.\n", + "\n", + "Models Genesys Cloud **CX 3** platform + AI feature costs (published token meters,\n", + "confidence-flagged) against pressure-tested benefit scenarios — replacing single-point\n", + "vendor ROI outputs with **Floor / Realistic / Stretch** sensitivity-aware analysis.\n", + "\n", + "> ⚠️ **Planning tool.** List rates unless overridden; not contractual pricing.\n", + "> Site data outside NAM is **estimated — confirm with CTM**.\n", + "\n", + "Same `tokencalc` library as the Streamlit app (`streamlit run app/streamlit_app.py`) —\n", + "Run-All here produces identical headline numbers on default inputs." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "57efb206", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tokencalc loaded — 9 sites, 2,088 named users (contracted: 2,088)\n" + ] + } + ], + "source": [ + "# ── Setup ──────────────────────────────────────────────────────────\n", + "import sys, pathlib\n", + "_ROOT = pathlib.Path.cwd()\n", + "if not (_ROOT / \"tokencalc\").exists(): # notebook lives in notebooks/\n", + " _ROOT = _ROOT.parent\n", + "sys.path.insert(0, str(_ROOT))\n", + "\n", + "import dataclasses\n", + "import pandas as pd\n", + "import plotly.express as px\n", + "import plotly.graph_objects as go\n", + "\n", + "from tokencalc import *\n", + "from tokencalc.scenarios import BENEFIT_PARAMS\n", + "\n", + "pd.options.display.float_format = \"{:,.0f}\".format\n", + "print(f\"tokencalc loaded — {len(CTM_DEFAULT_SITES)} sites, \"\n", + " f\"{sum(s.named_users for s in CTM_DEFAULT_SITES):,} named users \"\n", + " f\"(contracted: {CONTRACTED_NAMED_USERS:,})\")" + ] + }, + { + "cell_type": "markdown", + "id": "cbf6851d", + "metadata": {}, + "source": [ + "## Inputs\n", + "\n", + "Sites, cost takeouts, and feature scoping as Python objects (CTM defaults).\n", + "To resume a saved scenario instead:\n", + "`sites, takeouts, scopes = scenario_state_from_json(\"my_scenario.json\")`" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "361bde24", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
site_nameregion_pricingagentssupervisorsvoice_volume_monthlyemail_volume_monthlychat_volume_monthlysms_volume_monthlyvoice_aht_secondsemail_aht_secondschat_aht_secondsvoice_acw_secondsfully_loaded_agent_cost_annualfully_loaded_supervisor_cost_annuallanguages
0NAMUS8906012143582758001101040300600480606500095000English, French, Spanish
1EMEAEU320254200009500040400300600480606000088000English, French, German, Italian, Spanish
2AUZAU1801525000056000252503006004806070000100000English
3APAC HKAPAC120101600003800015150300600480605500080000English, Cantonese, Mandarin
4APAC SGAPAC110101500003400015120300600480605500080000English, Mandarin, Malay
5APAC SHAPAC130101750004000015130300600480603500055000Mandarin
6APAC GZAPAC9081200002800010100300600480603500055000Mandarin, Cantonese
7APAC JPAPAC6068000019000880300600480606000085000Japanese
8APAC TWAPAC4045400012000550300600480604000060000Mandarin
\n", + "
" + ], + "text/plain": [ + " site_name region_pricing agents supervisors voice_volume_monthly \\\n", + "0 NAM US 890 60 1214358 \n", + "1 EMEA EU 320 25 420000 \n", + "2 AUZ AU 180 15 250000 \n", + "3 APAC HK APAC 120 10 160000 \n", + "4 APAC SG APAC 110 10 150000 \n", + "5 APAC SH APAC 130 10 175000 \n", + "6 APAC GZ APAC 90 8 120000 \n", + "7 APAC JP APAC 60 6 80000 \n", + "8 APAC TW APAC 40 4 54000 \n", + "\n", + " email_volume_monthly chat_volume_monthly sms_volume_monthly \\\n", + "0 275800 110 1040 \n", + "1 95000 40 400 \n", + "2 56000 25 250 \n", + "3 38000 15 150 \n", + "4 34000 15 120 \n", + "5 40000 15 130 \n", + "6 28000 10 100 \n", + "7 19000 8 80 \n", + "8 12000 5 50 \n", + "\n", + " voice_aht_seconds email_aht_seconds chat_aht_seconds voice_acw_seconds \\\n", + "0 300 600 480 60 \n", + "1 300 600 480 60 \n", + "2 300 600 480 60 \n", + "3 300 600 480 60 \n", + "4 300 600 480 60 \n", + "5 300 600 480 60 \n", + "6 300 600 480 60 \n", + "7 300 600 480 60 \n", + "8 300 600 480 60 \n", + "\n", + " fully_loaded_agent_cost_annual fully_loaded_supervisor_cost_annual \\\n", + "0 65000 95000 \n", + "1 60000 88000 \n", + "2 70000 100000 \n", + "3 55000 80000 \n", + "4 55000 80000 \n", + "5 35000 55000 \n", + "6 35000 55000 \n", + "7 60000 85000 \n", + "8 40000 60000 \n", + "\n", + " languages \n", + "0 English, French, Spanish \n", + "1 English, French, German, Italian, Spanish \n", + "2 English \n", + "3 English, Cantonese, Mandarin \n", + "4 English, Mandarin, Malay \n", + "5 Mandarin \n", + "6 Mandarin, Cantonese \n", + "7 Japanese \n", + "8 Mandarin " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
takeoutannual_coststart_yearconfidencenotes
0NICE IEX (NAM)13000001🟡 estimatedMid-band estimate; needs CTM contract confirma...
1Legacy CC platform02🔴 unknownPlaceholder — populate once retirement scope i...
\n", + "
" + ], + "text/plain": [ + " takeout annual_cost start_year confidence \\\n", + "0 NICE IEX (NAM) 1300000 1 🟡 estimated \n", + "1 Legacy CC platform 0 2 🔴 unknown \n", + "\n", + " notes \n", + "0 Mid-band estimate; needs CTM contract confirma... \n", + "1 Placeholder — populate once retirement scope i... " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sites = list(CTM_DEFAULT_SITES)\n", + "takeouts = list(CTM_DEFAULT_TAKEOUTS)\n", + "scopes = list(CTM_DEFAULT_FEATURE_SCOPES)\n", + "meters = dict(DEFAULT_METERS)\n", + "pricing = dict(DEFAULT_PRICING)\n", + "\n", + "total_users = sum(s.named_users for s in sites)\n", + "if total_users != CONTRACTED_NAMED_USERS:\n", + " print(f\"⚠️ Named users ({total_users:,}) ≠ contracted licences \"\n", + " f\"({CONTRACTED_NAMED_USERS:,})\")\n", + "\n", + "display(sites_dataframe(sites))\n", + "display(pd.DataFrame([{\"takeout\": t.name, \"annual_cost\": t.annual_cost,\n", + " \"start_year\": t.start_year,\n", + " \"confidence\": t.confidence.icon + \" \" + t.confidence.value,\n", + " \"notes\": t.notes} for t in takeouts]))" + ] + }, + { + "cell_type": "markdown", + "id": "51e84f75", + "metadata": {}, + "source": [ + "## Token meters\n", + "\n", + "🟢 confirmed (published Genesys rate) · 🟡 estimated · 🔴 unknown (working default,\n", + "rate not yet sourced). **Rule:** Agent Copilot includes summarization, so\n", + "AI Summary & Insights is never billed at Copilot sites." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "72311955", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
featuremeter_typeunits_per_tokentokens_per_unitconfidencenotessource
0Voice Botper_minute170🟢 confirmedIVR self-service voice bot minutes; 17 min per...https://help.mypurecloud.com/articles/genesys-...
1Virtual Agent (legacy)per_interaction20🟢 confirmedLegacy (non-agentic) virtual agent; 2 interact...https://help.mypurecloud.com/articles/genesys-...
2Agentic Virtual Agentper_interaction11🟢 confirmedAgentic VA; 1.2 tokens per interaction.https://help.mypurecloud.com/articles/genesys-...
3AI Summary & Insightsper_summary500🟢 confirmedSupervisor standalone summarization; 50 summar...https://help.mypurecloud.com/articles/genesys-...
4Direct Messagingper_message4000🟢 confirmedFB/IG/WhatsApp messages; 400 messages per token.https://help.mypurecloud.com/articles/genesys-...
5Social Listeningper_message4000🟢 confirmed400 messages per token.https://help.mypurecloud.com/articles/genesys-...
6Social Responsesper_message4000🟢 confirmed400 messages per token.https://help.mypurecloud.com/articles/genesys-...
7Speech & Text Analyticsper_user_per_monthNaN30🟢 confirmedSTA: 30 tokens per named user per month.https://help.mypurecloud.com/articles/genesys-...
8Agent Copilotper_user_per_monthNaN40🟢 confirmed40 tokens per named user per month. Includes i...https://help.mypurecloud.com/articles/genesys-...
9Email AI (Auto-Suggest)per_user_per_monthNaN30🔴 unknownRate not yet sourced. Working default 30 token...
10Email AI (Auto-Respond)per_message20🔴 unknownRate not yet sourced. Working default 0.5 toke...
11AI Translateper_user_per_monthNaN20🔴 unknownRate not yet sourced. Working default 20 token...
\n", + "
" + ], + "text/plain": [ + " feature meter_type units_per_token \\\n", + "0 Voice Bot per_minute 17 \n", + "1 Virtual Agent (legacy) per_interaction 2 \n", + "2 Agentic Virtual Agent per_interaction 1 \n", + "3 AI Summary & Insights per_summary 50 \n", + "4 Direct Messaging per_message 400 \n", + "5 Social Listening per_message 400 \n", + "6 Social Responses per_message 400 \n", + "7 Speech & Text Analytics per_user_per_month NaN \n", + "8 Agent Copilot per_user_per_month NaN \n", + "9 Email AI (Auto-Suggest) per_user_per_month NaN \n", + "10 Email AI (Auto-Respond) per_message 2 \n", + "11 AI Translate per_user_per_month NaN \n", + "\n", + " tokens_per_unit confidence \\\n", + "0 0 🟢 confirmed \n", + "1 0 🟢 confirmed \n", + "2 1 🟢 confirmed \n", + "3 0 🟢 confirmed \n", + "4 0 🟢 confirmed \n", + "5 0 🟢 confirmed \n", + "6 0 🟢 confirmed \n", + "7 30 🟢 confirmed \n", + "8 40 🟢 confirmed \n", + "9 30 🔴 unknown \n", + "10 0 🔴 unknown \n", + "11 20 🔴 unknown \n", + "\n", + " notes \\\n", + "0 IVR self-service voice bot minutes; 17 min per... \n", + "1 Legacy (non-agentic) virtual agent; 2 interact... \n", + "2 Agentic VA; 1.2 tokens per interaction. \n", + "3 Supervisor standalone summarization; 50 summar... \n", + "4 FB/IG/WhatsApp messages; 400 messages per token. \n", + "5 400 messages per token. \n", + "6 400 messages per token. \n", + "7 STA: 30 tokens per named user per month. \n", + "8 40 tokens per named user per month. Includes i... \n", + "9 Rate not yet sourced. Working default 30 token... \n", + "10 Rate not yet sourced. Working default 0.5 toke... \n", + "11 Rate not yet sourced. Working default 20 token... \n", + "\n", + " source \n", + "0 https://help.mypurecloud.com/articles/genesys-... \n", + "1 https://help.mypurecloud.com/articles/genesys-... \n", + "2 https://help.mypurecloud.com/articles/genesys-... \n", + "3 https://help.mypurecloud.com/articles/genesys-... \n", + "4 https://help.mypurecloud.com/articles/genesys-... \n", + "5 https://help.mypurecloud.com/articles/genesys-... \n", + "6 https://help.mypurecloud.com/articles/genesys-... \n", + "7 https://help.mypurecloud.com/articles/genesys-... \n", + "8 https://help.mypurecloud.com/articles/genesys-... \n", + "9 \n", + "10 \n", + "11 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "display(meters_dataframe(meters))" + ] + }, + { + "cell_type": "markdown", + "id": "6c308d2f", + "metadata": {}, + "source": [ + "## Controls\n", + "\n", + "Plain variables (always work). Run the optional widget cell below for sliders —\n", + "either way, re-run the calculation cells after changing anything." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8b24676f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Scenario: realistic · Year 1 · benefit params: realistic\n" + ] + } + ], + "source": [ + "SCENARIO = \"realistic\" # \"floor\" | \"realistic\" | \"stretch\"\n", + "YEAR = 1 # 1 | 2 | 3\n", + "BENEFIT_PARAMS_MODE = \"realistic\" # \"realistic\" (pressure-tested) | \"claim\" (Genesys)\n", + "USE_CONTRACTED_RATES = False\n", + "IMPLEMENTATION_COST = 0.0 # one-off, amortized over 3 years\n", + "\n", + "scenario = get_scenario(SCENARIO)\n", + "print(f\"Scenario: {SCENARIO} · Year {YEAR} · benefit params: {BENEFIT_PARAMS_MODE}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "810e9dae", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ipywidgets not installed — use the plain variables above.\n" + ] + } + ], + "source": [ + "# Optional: ipywidgets controls (skip if ipywidgets unavailable)\n", + "try:\n", + " import ipywidgets as W\n", + " from IPython.display import display as _disp\n", + "\n", + " _scen = W.ToggleButtons(options=[\"floor\", \"realistic\", \"stretch\"],\n", + " value=SCENARIO, description=\"Scenario\")\n", + " _year = W.ToggleButtons(options=[1, 2, 3], value=YEAR, description=\"Year\")\n", + "\n", + " def _on_change(change):\n", + " global SCENARIO, YEAR, scenario\n", + " SCENARIO, YEAR = _scen.value, _year.value\n", + " scenario = get_scenario(SCENARIO)\n", + " print(f\"→ {SCENARIO}, year {YEAR} — re-run the cells below.\")\n", + "\n", + " _scen.observe(_on_change, \"value\"); _year.observe(_on_change, \"value\")\n", + " _disp(_scen, _year)\n", + "except ImportError:\n", + " print(\"ipywidgets not installed — use the plain variables above.\")" + ] + }, + { + "cell_type": "markdown", + "id": "3079316e", + "metadata": {}, + "source": [ + "## Cost model" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3ac4fee1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cost_linescopeannual_costconfidence
0Genesys CX 3 platform licencesall sites2,788,232confirmed
4Agent CopilotNAM, EMEA, AUZ, APAC HK, APAC SG, APAC SH, APA...1,002,240confirmed
3Speech & Text AnalyticsNAM, EMEA, AUZ, APAC HK, APAC SG, APAC SH, APA...751,680confirmed
1Voice BotNAM, EMEA, AUZ, APAC HK, APAC SG, APAC SH, APA...680,592confirmed
6Direct MessagingNAM, EMEA, AUZ, APAC HK, APAC SG, APAC SH, APA...132confirmed
2Agentic Virtual Agent—0confirmed
5AI Summary & Insights—0confirmed
7Email AI (Auto-Suggest)—0unknown
8Email AI (Auto-Respond)—0unknown
9AI Translate—0unknown
\n", + "
" + ], + "text/plain": [ + " cost_line \\\n", + "0 Genesys CX 3 platform licences \n", + "4 Agent Copilot \n", + "3 Speech & Text Analytics \n", + "1 Voice Bot \n", + "6 Direct Messaging \n", + "2 Agentic Virtual Agent \n", + "5 AI Summary & Insights \n", + "7 Email AI (Auto-Suggest) \n", + "8 Email AI (Auto-Respond) \n", + "9 AI Translate \n", + "\n", + " scope annual_cost confidence \n", + "0 all sites 2,788,232 confirmed \n", + "4 NAM, EMEA, AUZ, APAC HK, APAC SG, APAC SH, APA... 1,002,240 confirmed \n", + "3 NAM, EMEA, AUZ, APAC HK, APAC SG, APAC SH, APA... 751,680 confirmed \n", + "1 NAM, EMEA, AUZ, APAC HK, APAC SG, APAC SH, APA... 680,592 confirmed \n", + "6 NAM, EMEA, AUZ, APAC HK, APAC SG, APAC SH, APA... 132 confirmed \n", + "2 — 0 confirmed \n", + "5 — 0 confirmed \n", + "7 — 0 unknown \n", + "8 — 0 unknown \n", + "9 — 0 unknown " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Year 1 total: $5,222,876 (of which 🔴 unknown-rate features: $0)\n" + ] + } + ], + "source": [ + "cost_df = calculate_total_cost(sites, scopes, meters, pricing, scenario, YEAR,\n", + " use_contracted=USE_CONTRACTED_RATES)\n", + "display(cost_df.sort_values(\"annual_cost\", ascending=False))\n", + "unknown_cost = cost_df[cost_df.confidence == \"unknown\"][\"annual_cost\"].sum()\n", + "print(f\"Year {YEAR} total: ${cost_df['annual_cost'].sum():,.0f}\"\n", + " f\" (of which 🔴 unknown-rate features: ${unknown_cost:,.0f})\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fa4c9cdc", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "hovertemplate": "cost_line=Genesys CX 3 platform licences
year=%{x}
$/yr=%{y}", + "legendgroup": "Genesys CX 3 platform licences", + "marker": { + "color": "#636efa", + "pattern": { + "shape": "" + } + }, + "name": "Genesys CX 3 platform licences", + "orientation": "v", + "showlegend": true, + "textposition": "auto", + "type": "bar", + "x": [ + "Y1", + "Y2", + "Y3" + ], + "xaxis": "x", + "y": { + "bdata": "cT0K18NFRUFxPQrXw0VFQXE9CtfDRUVB", + "dtype": "f8" + }, + "yaxis": "y" + }, + { + "hovertemplate": "cost_line=Voice Bot
year=%{x}
$/yr=%{y}", + "legendgroup": "Voice Bot", + "marker": { + "color": "#EF553B", + "pattern": { + "shape": "" + } + }, + "name": "Voice Bot", + "orientation": "v", + "showlegend": true, + "textposition": "auto", + "type": "bar", + "x": [ + "Y1", + "Y2", + "Y3" + ], + "xaxis": "x", + "y": { + "bdata": "AAAAACDFJEEAAAAAoKstQQAAAACgqy1B", + "dtype": "f8" + }, + "yaxis": "y" + }, + { + "hovertemplate": "cost_line=Agentic Virtual Agent
year=%{x}
$/yr=%{y}", + "legendgroup": "Agentic Virtual Agent", + "marker": { + "color": "#00cc96", + "pattern": { + "shape": "" + } + }, + "name": "Agentic Virtual Agent", + "orientation": "v", + "showlegend": true, + "textposition": "auto", + "type": "bar", + "x": [ + "Y1", + "Y2", + "Y3" + ], + "xaxis": "x", + "y": { + "bdata": "AAAAAAAAAAAAAAAAfNpCQQAAAAD27kpB", + "dtype": "f8" + }, + "yaxis": "y" + }, + { + "hovertemplate": "cost_line=Speech & Text Analytics
year=%{x}
$/yr=%{y}", + "legendgroup": "Speech & Text Analytics", + "marker": { + "color": "#ab63fa", + "pattern": { + "shape": "" + } + }, + "name": "Speech & Text Analytics", + "orientation": "v", + "showlegend": true, + "textposition": "auto", + "type": "bar", + "x": [ + "Y1", + "Y2", + "Y3" + ], + "xaxis": "x", + "y": { + "bdata": "AAAAAIDwJkEAAAAAgPAmQQAAAACA8CZB", + "dtype": "f8" + }, + "yaxis": "y" + }, + { + "hovertemplate": "cost_line=Agent Copilot
year=%{x}
$/yr=%{y}", + "legendgroup": "Agent Copilot", + "marker": { + "color": "#FFA15A", + "pattern": { + "shape": "" + } + }, + "name": "Agent Copilot", + "orientation": "v", + "showlegend": true, + "textposition": "auto", + "type": "bar", + "x": [ + "Y1", + "Y2", + "Y3" + ], + "xaxis": "x", + "y": { + "bdata": "AAAAAACWLkEAAAAAAJYuQQAAAAAAli5B", + "dtype": "f8" + }, + "yaxis": "y" + }, + { + "hovertemplate": "cost_line=AI Summary & Insights
year=%{x}
$/yr=%{y}", + "legendgroup": "AI Summary & Insights", + "marker": { + "color": "#19d3f3", + "pattern": { + "shape": "" + } + }, + "name": "AI Summary & Insights", + "orientation": "v", + "showlegend": true, + "textposition": "auto", + "type": "bar", + "x": [ + "Y1", + "Y2", + "Y3" + ], + "xaxis": "x", + "y": { + "bdata": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "dtype": "f8" + }, + "yaxis": "y" + }, + { + "hovertemplate": "cost_line=Direct Messaging
year=%{x}
$/yr=%{y}", + "legendgroup": "Direct Messaging", + "marker": { + "color": "#FF6692", + "pattern": { + "shape": "" + } + }, + "name": "Direct Messaging", + "orientation": "v", + "showlegend": true, + "textposition": "auto", + "type": "bar", + "x": [ + "Y1", + "Y2", + "Y3" + ], + "xaxis": "x", + "y": { + "bdata": "AAAAAACAYEAAAAAAAABiQAAAAAAAAGJA", + "dtype": "f8" + }, + "yaxis": "y" + }, + { + "hovertemplate": "cost_line=Email AI (Auto-Suggest)
year=%{x}
$/yr=%{y}", + "legendgroup": "Email AI (Auto-Suggest)", + "marker": { + "color": "#B6E880", + "pattern": { + "shape": "" + } + }, + "name": "Email AI (Auto-Suggest)", + "orientation": "v", + "showlegend": true, + "textposition": "auto", + "type": "bar", + "x": [ + "Y1", + "Y2", + "Y3" + ], + "xaxis": "x", + "y": { + "bdata": "AAAAAAAAAAAAAAAAYHQcQQAAAABgdBxB", + "dtype": "f8" + }, + "yaxis": "y" + }, + { + "hovertemplate": "cost_line=Email AI (Auto-Respond)
year=%{x}
$/yr=%{y}", + "legendgroup": "Email AI (Auto-Respond)", + "marker": { + "color": "#FF97FF", + "pattern": { + "shape": "" + } + }, + "name": "Email AI (Auto-Respond)", + "orientation": "v", + "showlegend": true, + "textposition": "auto", + "type": "bar", + "x": [ + "Y1", + "Y2", + "Y3" + ], + "xaxis": "x", + "y": { + "bdata": "AAAAAAAAAAAAAAAAwAITQQAAAACAKBtB", + "dtype": "f8" + }, + "yaxis": "y" + }, + { + "hovertemplate": "cost_line=AI Translate
year=%{x}
$/yr=%{y}", + "legendgroup": "AI Translate", + "marker": { + "color": "#FECB52", + "pattern": { + "shape": "" + } + }, + "name": "AI Translate", + "orientation": "v", + "showlegend": true, + "textposition": "auto", + "type": "bar", + "x": [ + "Y1", + "Y2", + "Y3" + ], + "xaxis": "x", + "y": { + "bdata": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAhQFB", + "dtype": "f8" + }, + "yaxis": "y" + } + ], + "layout": { + "barmode": "relative", + "legend": { + "title": { + "text": "cost_line" + }, + "tracegroupgap": 0 + }, + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "fillpattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermap": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermap" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "title": { + "text": "Cost breakdown by feature — realistic" + }, + "xaxis": { + "anchor": "y", + "domain": [ + 0, + 1 + ], + "title": { + "text": "year" + } + }, + "yaxis": { + "anchor": "x", + "domain": [ + 0, + 1 + ], + "title": { + "text": "$/yr" + } + } + } + }, + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Stacked bar — cost by feature, one bar per year\n", + "frames = []\n", + "for y in (1, 2, 3):\n", + " d = calculate_total_cost(sites, scopes, meters, pricing, scenario, y,\n", + " use_contracted=USE_CONTRACTED_RATES)\n", + " d[\"year\"] = f\"Y{y}\"\n", + " frames.append(d)\n", + "cost_3y = pd.concat(frames, ignore_index=True)\n", + "px.bar(cost_3y, x=\"year\", y=\"annual_cost\", color=\"cost_line\",\n", + " title=f\"Cost breakdown by feature — {SCENARIO}\",\n", + " labels={\"annual_cost\": \"$/yr\"})" + ] + }, + { + "cell_type": "markdown", + "id": "326602c1", + "metadata": {}, + "source": [ + "## Benefit model" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "380914e0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
benefit_linescopeannual_valueconfidence
0Voice Bot deflection (labour avoided)APAC GZ, APAC HK, APAC JP, APAC SG, APAC SH, A...13,122,330estimated
3Voice ACW (summarization)APAC GZ, APAC HK, APAC JP, APAC SG, APAC SH, A...2,099,573estimated
2Voice AHT (knowledge surfacing)APAC GZ, APAC HK, APAC JP, APAC SG, APAC SH, A...1,237,248estimated
1STA coaching (AHT)APAC GZ, APAC HK, APAC JP, APAC SG, APAC SH, A...562,386estimated
4Supervisor time (AI summaries/insights)APAC GZ, APAC HK, APAC JP, APAC SG, APAC SH, A...318,500estimated
\n", + "
" + ], + "text/plain": [ + " benefit_line \\\n", + "0 Voice Bot deflection (labour avoided) \n", + "3 Voice ACW (summarization) \n", + "2 Voice AHT (knowledge surfacing) \n", + "1 STA coaching (AHT) \n", + "4 Supervisor time (AI summaries/insights) \n", + "\n", + " scope annual_value confidence \n", + "0 APAC GZ, APAC HK, APAC JP, APAC SG, APAC SH, A... 13,122,330 estimated \n", + "3 APAC GZ, APAC HK, APAC JP, APAC SG, APAC SH, A... 2,099,573 estimated \n", + "2 APAC GZ, APAC HK, APAC JP, APAC SG, APAC SH, A... 1,237,248 estimated \n", + "1 APAC GZ, APAC HK, APAC JP, APAC SG, APAC SH, A... 562,386 estimated \n", + "4 APAC GZ, APAC HK, APAC JP, APAC SG, APAC SH, A... 318,500 estimated " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Year 1 total benefit: $17,340,037\n" + ] + } + ], + "source": [ + "benefit_df = calculate_total_benefit(sites, scopes, scenario, YEAR,\n", + " params=BENEFIT_PARAMS_MODE)\n", + "display(benefit_df.sort_values(\"annual_value\", ascending=False))\n", + "print(f\"Year {YEAR} total benefit: ${benefit_df['annual_value'].sum():,.0f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "ae5fb48b", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "hovertemplate": "benefit_line=Voice Bot deflection (labour avoided)
year=%{x}
$/yr=%{y}", + "legendgroup": "Voice Bot deflection (labour avoided)", + "marker": { + "color": "#636efa", + "pattern": { + "shape": "" + } + }, + "name": "Voice Bot deflection (labour avoided)", + "orientation": "v", + "showlegend": true, + "textposition": "auto", + "type": "bar", + "x": [ + "Y1", + "Y2", + "Y3" + ], + "xaxis": "x", + "y": { + "bdata": "O7ETTWMHaUFiJ3YK6QV0QcVObLwEx3dB", + "dtype": "f8" + }, + "yaxis": "y" + }, + { + "hovertemplate": "benefit_line=STA coaching (AHT)
year=%{x}
$/yr=%{y}", + "legendgroup": "STA coaching (AHT)", + "marker": { + "color": "#EF553B", + "pattern": { + "shape": "" + } + }, + "name": "STA coaching (AHT)", + "orientation": "v", + "showlegend": true, + "textposition": "auto", + "type": "bar", + "x": [ + "Y1", + "Y2", + "Y3" + ], + "xaxis": "x", + "y": { + "bdata": "ndiJLaMpIUFjJ3bi0XUrQWIndp70TTBB", + "dtype": "f8" + }, + "yaxis": "y" + }, + { + "hovertemplate": "benefit_line=Voice AHT (knowledge surfacing)
year=%{x}
$/yr=%{y}", + "legendgroup": "Voice AHT (knowledge surfacing)", + "marker": { + "color": "#00cc96", + "pattern": { + "shape": "" + } + }, + "name": "Voice AHT (knowledge surfacing)", + "orientation": "v", + "showlegend": true, + "textposition": "auto", + "type": "bar", + "x": [ + "Y1", + "Y2", + "Y3" + ], + "xaxis": "x", + "y": { + "bdata": "FDuxSwDhMkGGXuhFzTQ+QR/4geFZ70FB", + "dtype": "f8" + }, + "yaxis": "y" + }, + { + "hovertemplate": "benefit_line=Voice ACW (summarization)
year=%{x}
$/yr=%{y}", + "legendgroup": "Voice ACW (summarization)", + "marker": { + "color": "#ab63fa", + "pattern": { + "shape": "" + } + }, + "name": "Voice ACW (summarization)", + "orientation": "v", + "showlegend": true, + "textposition": "auto", + "type": "bar", + "x": [ + "Y1", + "Y2", + "Y3" + ], + "xaxis": "x", + "y": { + "bdata": "T+zEbroEQEFLrdRKKqFJQcmN3Dhib05B", + "dtype": "f8" + }, + "yaxis": "y" + }, + { + "hovertemplate": "benefit_line=Supervisor time (AI summaries/insights)
year=%{x}
$/yr=%{y}", + "legendgroup": "Supervisor time (AI summaries/insights)", + "marker": { + "color": "#FFA15A", + "pattern": { + "shape": "" + } + }, + "name": "Supervisor time (AI summaries/insights)", + "orientation": "v", + "showlegend": true, + "textposition": "auto", + "type": "bar", + "x": [ + "Y1", + "Y2", + "Y3" + ], + "xaxis": "x", + "y": { + "bdata": "AAAAAJBwE0EAAAAAgBofQQAAAAC8dyJB", + "dtype": "f8" + }, + "yaxis": "y" + }, + { + "hovertemplate": "benefit_line=Agentic Virtual Agent deflection (labour avoided)
year=%{x}
$/yr=%{y}", + "legendgroup": "Agentic Virtual Agent deflection (labour avoided)", + "marker": { + "color": "#19d3f3", + "pattern": { + "shape": "" + } + }, + "name": "Agentic Virtual Agent deflection (labour avoided)", + "orientation": "v", + "showlegend": true, + "textposition": "auto", + "type": "bar", + "x": [ + "Y2", + "Y3" + ], + "xaxis": "x", + "y": { + "bdata": "ip3YKeLqVkEUO7GR7DZbQQ==", + "dtype": "f8" + }, + "yaxis": "y" + }, + { + "hovertemplate": "benefit_line=Email Auto-Respond (displaced handling)
year=%{x}
$/yr=%{y}", + "legendgroup": "Email Auto-Respond (displaced handling)", + "marker": { + "color": "#FF6692", + "pattern": { + "shape": "" + } + }, + "name": "Email Auto-Respond (displaced handling)", + "orientation": "v", + "showlegend": true, + "textposition": "auto", + "type": "bar", + "x": [ + "Y2", + "Y3" + ], + "xaxis": "x", + "y": { + "bdata": "ip3YiXW7S0GKndjJTXdQQQ==", + "dtype": "f8" + }, + "yaxis": "y" + }, + { + "hovertemplate": "benefit_line=Email Auto-Suggest (drafting time)
year=%{x}
$/yr=%{y}", + "legendgroup": "Email Auto-Suggest (drafting time)", + "marker": { + "color": "#B6E880", + "pattern": { + "shape": "" + } + }, + "name": "Email Auto-Suggest (drafting time)", + "orientation": "v", + "showlegend": true, + "textposition": "auto", + "type": "bar", + "x": [ + "Y2", + "Y3" + ], + "xaxis": "x", + "y": { + "bdata": "FDuxE3ufOkEndmInYp0/QQ==", + "dtype": "f8" + }, + "yaxis": "y" + } + ], + "layout": { + "barmode": "relative", + "legend": { + "title": { + "text": "benefit_line" + }, + "tracegroupgap": 0 + }, + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "fillpattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermap": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermap" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "title": { + "text": "Benefit breakdown by source — realistic" + }, + "xaxis": { + "anchor": "y", + "domain": [ + 0, + 1 + ], + "title": { + "text": "year" + } + }, + "yaxis": { + "anchor": "x", + "domain": [ + 0, + 1 + ], + "title": { + "text": "$/yr" + } + } + } + }, + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "name": "Genesys claim", + "type": "bar", + "x": [ + "STA coaching (AHT)", + "Supervisor time (AI summaries/insights)", + "Voice ACW (summarization)", + "Voice AHT (knowledge surfacing)", + "Voice Bot deflection (labour avoided)" + ], + "y": { + "bdata": "J3Zi5y7iNkEAAAAAkHAjQWIndgrpBVRB8AM/6AQiQEE7sRNNYwdpQQ==", + "dtype": "f8" + } + }, + { + "name": "Pressure-tested realistic", + "type": "bar", + "x": [ + "STA coaching (AHT)", + "Supervisor time (AI summaries/insights)", + "Voice ACW (summarization)", + "Voice AHT (knowledge surfacing)", + "Voice Bot deflection (labour avoided)" + ], + "y": { + "bdata": "ndiJLaMpIUEAAAAAkHATQU/sxG66BEBBFDuxSwDhMkE7sRNNYwdpQQ==", + "dtype": "f8" + } + } + ], + "layout": { + "barmode": "group", + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "fillpattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermap": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermap" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "title": { + "text": "Claim vs pressure-tested — Year 1" + }, + "yaxis": { + "tickformat": "$,.0f" + } + } + }, + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Stacked bar by source per year + Genesys claim vs pressure-tested comparison\n", + "frames = []\n", + "for y in (1, 2, 3):\n", + " d = calculate_total_benefit(sites, scopes, scenario, y, params=BENEFIT_PARAMS_MODE)\n", + " d[\"year\"] = f\"Y{y}\"\n", + " frames.append(d)\n", + "ben_3y = pd.concat(frames, ignore_index=True)\n", + "fig = px.bar(ben_3y, x=\"year\", y=\"annual_value\", color=\"benefit_line\",\n", + " title=f\"Benefit breakdown by source — {SCENARIO}\",\n", + " labels={\"annual_value\": \"$/yr\"})\n", + "fig.show()\n", + "\n", + "claim = calculate_total_benefit(sites, scopes, scenario, YEAR, params=\"claim\")\n", + "comp = pd.merge(\n", + " claim[[\"benefit_line\", \"annual_value\"]].rename(columns={\"annual_value\": \"Genesys claim\"}),\n", + " benefit_df[[\"benefit_line\", \"annual_value\"]].rename(columns={\"annual_value\": \"Pressure-tested\"}),\n", + " on=\"benefit_line\", how=\"outer\",\n", + ").fillna(0)\n", + "go.Figure([\n", + " go.Bar(name=\"Genesys claim\", x=comp.benefit_line, y=comp[\"Genesys claim\"]),\n", + " go.Bar(name=\"Pressure-tested realistic\", x=comp.benefit_line, y=comp[\"Pressure-tested\"]),\n", + "]).update_layout(barmode=\"group\", title=f\"Claim vs pressure-tested — Year {YEAR}\",\n", + " yaxis_tickformat=\"$,.0f\")" + ] + }, + { + "cell_type": "markdown", + "id": "33e2dc31", + "metadata": {}, + "source": [ + "## Business case — 3-year P&L, NPV @ 8%, payback, ROI" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7bd6456e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
lineY1Y2Y33-yr Total
0Genesys CX 3 platform licences2,788,2322,788,2322,788,2328,364,695
1Voice Bot680,592972,240972,2402,625,072
2Agentic Virtual Agent02,471,1603,530,2206,001,380
3Speech & Text Analytics751,680751,680751,6802,255,040
4Agent Copilot1,002,2401,002,2401,002,2403,006,720
5AI Summary & Insights0000
6Direct Messaging132144144420
7Email AI (Auto-Suggest)0466,200466,200932,400
8Email AI (Auto-Respond)0311,472444,960756,432
9AI Translate00143,520143,520
10NICE IEX (NAM)1,300,0001,300,0001,300,0003,900,000
11Legacy CC platform0000
12Voice Bot deflection (labour avoided)13,122,33020,995,72924,932,42859,050,487
13STA coaching (AHT)562,386899,8171,068,5332,530,735
14Voice AHT (knowledge surfacing)1,237,2481,979,5972,350,7725,567,617
15Voice ACW (summarization)2,099,5733,359,3173,989,1889,448,078
16Supervisor time (AI summaries/insights)318,500509,600605,1501,433,250
17Agentic Virtual Agent deflection (labour avoided)06,007,6897,134,13013,141,819
18Email Auto-Respond (displaced handling)03,634,9234,316,4717,951,394
19Email Auto-Suggest (drafting time)01,744,7632,071,9063,816,669
20TOTAL COSTS5,222,8768,763,36810,099,43624,085,679
21TOTAL TAKEOUTS1,300,0001,300,0001,300,0003,900,000
22TOTAL BENEFITS17,340,03739,131,43446,468,578102,940,050
23NET13,417,16131,668,06737,669,14382,754,371
24Cumulative net13,417,16145,085,22882,754,371141,256,760
\n", + "
" + ], + "text/plain": [ + " line Y1 Y2 \\\n", + "0 Genesys CX 3 platform licences 2,788,232 2,788,232 \n", + "1 Voice Bot 680,592 972,240 \n", + "2 Agentic Virtual Agent 0 2,471,160 \n", + "3 Speech & Text Analytics 751,680 751,680 \n", + "4 Agent Copilot 1,002,240 1,002,240 \n", + "5 AI Summary & Insights 0 0 \n", + "6 Direct Messaging 132 144 \n", + "7 Email AI (Auto-Suggest) 0 466,200 \n", + "8 Email AI (Auto-Respond) 0 311,472 \n", + "9 AI Translate 0 0 \n", + "10 NICE IEX (NAM) 1,300,000 1,300,000 \n", + "11 Legacy CC platform 0 0 \n", + "12 Voice Bot deflection (labour avoided) 13,122,330 20,995,729 \n", + "13 STA coaching (AHT) 562,386 899,817 \n", + "14 Voice AHT (knowledge surfacing) 1,237,248 1,979,597 \n", + "15 Voice ACW (summarization) 2,099,573 3,359,317 \n", + "16 Supervisor time (AI summaries/insights) 318,500 509,600 \n", + "17 Agentic Virtual Agent deflection (labour avoided) 0 6,007,689 \n", + "18 Email Auto-Respond (displaced handling) 0 3,634,923 \n", + "19 Email Auto-Suggest (drafting time) 0 1,744,763 \n", + "20 TOTAL COSTS 5,222,876 8,763,368 \n", + "21 TOTAL TAKEOUTS 1,300,000 1,300,000 \n", + "22 TOTAL BENEFITS 17,340,037 39,131,434 \n", + "23 NET 13,417,161 31,668,067 \n", + "24 Cumulative net 13,417,161 45,085,228 \n", + "\n", + " Y3 3-yr Total \n", + "0 2,788,232 8,364,695 \n", + "1 972,240 2,625,072 \n", + "2 3,530,220 6,001,380 \n", + "3 751,680 2,255,040 \n", + "4 1,002,240 3,006,720 \n", + "5 0 0 \n", + "6 144 420 \n", + "7 466,200 932,400 \n", + "8 444,960 756,432 \n", + "9 143,520 143,520 \n", + "10 1,300,000 3,900,000 \n", + "11 0 0 \n", + "12 24,932,428 59,050,487 \n", + "13 1,068,533 2,530,735 \n", + "14 2,350,772 5,567,617 \n", + "15 3,989,188 9,448,078 \n", + "16 605,150 1,433,250 \n", + "17 7,134,130 13,141,819 \n", + "18 4,316,471 7,951,394 \n", + "19 2,071,906 3,816,669 \n", + "20 10,099,436 24,085,679 \n", + "21 1,300,000 3,900,000 \n", + "22 46,468,578 102,940,050 \n", + "23 37,669,143 82,754,371 \n", + "24 82,754,371 141,256,760 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NPV @ 8%: $69,476,540 Payback: 0.00 years 3-yr ROI: 344%\n" + ] + } + ], + "source": [ + "case = build_business_case(sites, scopes, meters, pricing, takeouts, scenario,\n", + " implementation_cost=IMPLEMENTATION_COST,\n", + " use_contracted=USE_CONTRACTED_RATES,\n", + " benefit_params=BENEFIT_PARAMS_MODE)\n", + "\n", + "pnl = pd.concat([\n", + " case[\"cost_by_year\"].drop(columns=\"confidence\"),\n", + " case[\"takeouts_by_year\"].drop(columns=\"confidence\"),\n", + " case[\"benefit_by_year\"].drop(columns=\"confidence\"),\n", + " case[\"net_by_year\"],\n", + "], ignore_index=True)\n", + "pnl[\"3-yr Total\"] = pnl[[\"Y1\", \"Y2\", \"Y3\"]].sum(axis=1)\n", + "display(pnl)\n", + "\n", + "pb = case[\"payback_period_years\"]\n", + "pb_text = f\"{pb:.2f} years\" if pb is not None else \"never\"\n", + "print(f\"NPV @ 8%: ${case['npv']:,.0f} Payback: {pb_text} \"\n", + " f\"3-yr ROI: {case['roi_3yr']:.0%}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c869422e", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "mode": "lines+markers", + "name": "Floor", + "type": "scatter", + "x": { + "bdata": "AQID", + "dtype": "i1" + }, + "y": { + "bdata": "Jh2fUphIRkF0ls26PqRrQZDCdUr8mn1B", + "dtype": "f8" + } + }, + { + "mode": "lines+markers", + "name": "Realistic", + "type": "scatter", + "x": { + "bdata": "AQID", + "dtype": "i1" + }, + "y": { + "bdata": "4CFRL1mXaUEbRntgkX+FQQJZQwrtupNB", + "dtype": "f8" + } + }, + { + "mode": "lines+markers", + "name": "Stretch", + "type": "scatter", + "x": { + "bdata": "AQID", + "dtype": "i1" + }, + "y": { + "bdata": "3FW3T0n4fUHmLFufJruVQWoygHZnKKJB", + "dtype": "f8" + } + } + ], + "layout": { + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "fillpattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermap": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermap" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "title": { + "text": "Cumulative net cash flow by scenario" + }, + "xaxis": { + "title": { + "text": "Year" + } + }, + "yaxis": { + "tickformat": "$,.0f" + } + } + }, + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Cumulative net cash flow — all three scenarios\n", + "fig = go.Figure()\n", + "for name in (\"floor\", \"realistic\", \"stretch\"):\n", + " c = build_business_case(sites, scopes, meters, pricing, takeouts, name,\n", + " implementation_cost=IMPLEMENTATION_COST,\n", + " benefit_params=BENEFIT_PARAMS_MODE)\n", + " fig.add_scatter(x=c[\"cumulative_net\"].year, y=c[\"cumulative_net\"].cumulative_net,\n", + " mode=\"lines+markers\", name=name.capitalize())\n", + "fig.update_layout(title=\"Cumulative net cash flow by scenario\",\n", + " xaxis_title=\"Year\", yaxis_tickformat=\"$,.0f\")" + ] + }, + { + "cell_type": "markdown", + "id": "855966ce", + "metadata": {}, + "source": [ + "## Sensitivity — tornado & break-even" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "bab4c657", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "name": "-25%", + "orientation": "h", + "type": "bar", + "x": { + "bdata": "ADho8SUOIUGArP2C+/UnwYDS8BGK9jHBQLa9ZjWZM8HAsDQbx3o2wcAuqPeUez7BBOFkAqq/ZsE=", + "dtype": "f8" + }, + "y": [ + "voice_bot_avg_minutes", + "email_auto_suggest_acceptance", + "voice_knowledge_eligibility", + "email_auto_respond_rate", + "agentic_va_deflection", + "voice_summarization_eligibility", + "voice_bot_deflection" + ] + }, + { + "name": "+25%", + "orientation": "h", + "type": "bar", + "x": { + "bdata": "gCS5F+gNIcGArP2C+/UnQUDS8BGK9jFBwDDyxQ2ZM0GAX/Nk0Xo2QYAuqPeUez5BMNL/362/ZkE=", + "dtype": "f8" + }, + "y": [ + "voice_bot_avg_minutes", + "email_auto_suggest_acceptance", + "voice_knowledge_eligibility", + "email_auto_respond_rate", + "agentic_va_deflection", + "voice_summarization_eligibility", + "voice_bot_deflection" + ] + } + ], + "layout": { + "barmode": "overlay", + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "fillpattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermap": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermap" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "title": { + "text": "Tornado — NPV swing vs input ±25%" + }, + "xaxis": { + "tickformat": "$,.0f", + "title": { + "text": "Δ 3-yr NPV ($)" + } + } + } + }, + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Tornado: vary each scenario driver ±25% (clamped to 0–1), hold others\n", + "DRIVERS = [\"voice_bot_deflection\", \"voice_bot_avg_minutes\", \"agentic_va_deflection\",\n", + " \"voice_summarization_eligibility\", \"voice_knowledge_eligibility\",\n", + " \"email_auto_respond_rate\", \"email_auto_suggest_acceptance\"]\n", + "\n", + "def npv_with(field, factor):\n", + " v = getattr(scenario, field) * factor\n", + " if field != \"voice_bot_avg_minutes\":\n", + " v = min(max(v, 0.0), 1.0)\n", + " sc = dataclasses.replace(scenario, **{field: v})\n", + " return build_business_case(sites, scopes, meters, pricing, takeouts, sc,\n", + " benefit_params=BENEFIT_PARAMS_MODE)[\"npv\"]\n", + "\n", + "base_npv = case[\"npv\"]\n", + "rows = [{\"driver\": d, \"low\": npv_with(d, 0.75) - base_npv,\n", + " \"high\": npv_with(d, 1.25) - base_npv} for d in DRIVERS]\n", + "torn = pd.DataFrame(rows)\n", + "torn[\"swing\"] = (torn.high - torn.low).abs()\n", + "torn = torn.sort_values(\"swing\")\n", + "go.Figure([\n", + " go.Bar(y=torn.driver, x=torn.low, orientation=\"h\", name=\"-25%\"),\n", + " go.Bar(y=torn.driver, x=torn.high, orientation=\"h\", name=\"+25%\"),\n", + "]).update_layout(barmode=\"overlay\", title=\"Tornado — NPV swing vs input ±25%\",\n", + " xaxis_title=\"Δ 3-yr NPV ($)\", xaxis_tickformat=\"$,.0f\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "2b3dee90", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Break-even auto-respond rate: 0% (NPV already $64,339,036 at 0%)\n" + ] + }, + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "hovertemplate": "Email Auto-Respond rate=%{x}
3-yr NPV ($)=%{y}", + "legendgroup": "", + "line": { + "color": "#636efa", + "dash": "solid" + }, + "marker": { + "symbol": "circle" + }, + "mode": "lines", + "name": "", + "orientation": "v", + "showlegend": false, + "type": "scatter", + "x": { + "bdata": "AAAAAAAAAAB7FK5H4XqUP3sUrkfheqQ/uB6F61G4rj97FK5H4Xq0P5qZmZmZmbk/uB6F61G4vj/sUbgehevBP3sUrkfhesQ/CtejcD0Kxz+amZmZmZnJPylcj8L1KMw/uB6F61G4zj+kcD0K16PQP+xRuB6F69E/MzMzMzMz0z97FK5H4XrUP8P1KFyPwtU/CtejcD0K1z9SuB6F61HYP5qZmZmZmdk/4XoUrkfh2j8pXI/C9SjcP3E9CtejcN0/uB6F61G43j8AAAAAAADgPw==", + "dtype": "f8" + }, + "xaxis": "x", + "y": { + "bdata": "vbmd4OKtjkEnJxdzmeyOQZCUkAVQK49BcfdX6gZqj0HbZNF8vaiPQbvHmGF0549BkhoJehUTkEGpmBB3cDKQQbiCqTXMUZBBbDnmfidxkEHd6knxgpCQQZGhhjrer5BBRljDgznPkEG3CSf2lO6QQc6HLvPvDZFB3HHHsUstkUGRKAT7pkyRQfdCJh4CbJFBtpCktl2LkUFqR+H/uKqRQdv4RHIUypFBkK+Bu2/pkUFFZr4EywiSQbUXIncmKJJBas5ewIFHkkHaf8Iy3WaSQQ==", + "dtype": "f8" + }, + "yaxis": "y" + } + ], + "layout": { + "legend": { + "tracegroupgap": 0 + }, + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "fillpattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermap": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermap" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "title": { + "text": "NPV vs email Auto-Respond rate" + }, + "xaxis": { + "anchor": "y", + "domain": [ + 0, + 1 + ], + "title": { + "text": "Email Auto-Respond rate" + } + }, + "yaxis": { + "anchor": "x", + "domain": [ + 0, + 1 + ], + "title": { + "text": "3-yr NPV ($)" + } + } + } + }, + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Break-even: at what email Auto-Respond rate does the case break even?\n", + "import numpy as np\n", + "\n", + "rates = np.linspace(0.0, 0.5, 26)\n", + "npvs = [build_business_case(\n", + " sites, scopes, meters, pricing, takeouts,\n", + " dataclasses.replace(scenario, email_auto_respond_rate=float(r)),\n", + " benefit_params=BENEFIT_PARAMS_MODE)[\"npv\"]\n", + " for r in rates]\n", + "breakeven = next((r for r, v in zip(rates, npvs) if v >= 0), None)\n", + "print(\"Break-even auto-respond rate:\",\n", + " f\"{breakeven:.0%}\" if breakeven is not None else \"not reached ≤50%\",\n", + " f\"(NPV already ${npvs[0]:,.0f} at 0%)\" if npvs[0] >= 0 else \"\")\n", + "px.line(x=rates, y=npvs, labels={\"x\": \"Email Auto-Respond rate\", \"y\": \"3-yr NPV ($)\"},\n", + " title=\"NPV vs email Auto-Respond rate\")" + ] + }, + { + "cell_type": "markdown", + "id": "2c4d5a54", + "metadata": {}, + "source": [ + "## Export" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "57611721", + "metadata": {}, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'openpyxl'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mModuleNotFoundError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[14]\u001b[39m\u001b[32m, line 11\u001b[39m\n\u001b[32m 7\u001b[39m benefit_params=BENEFIT_PARAMS_MODE))\n\u001b[32m 8\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m n \u001b[38;5;28;01min\u001b[39;00m (\u001b[33m\"floor\"\u001b[39m, \u001b[33m\"realistic\"\u001b[39m, \u001b[33m\"stretch\"\u001b[39m))\n\u001b[32m 9\u001b[39m ])\n\u001b[32m 10\u001b[39m \n\u001b[32m---> \u001b[39m\u001b[32m11\u001b[39m xlsx = export_excel({\n\u001b[32m 12\u001b[39m \u001b[33m\"Inputs\"\u001b[39m: sites_dataframe(sites),\n\u001b[32m 13\u001b[39m \u001b[33m\"Meters\"\u001b[39m: meters_dataframe(meters),\n\u001b[32m 14\u001b[39m \u001b[33m\"Cost detail\"\u001b[39m: cost_3y,\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/git/palladium/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/exports.py:56\u001b[39m, in \u001b[36mexport_excel\u001b[39m\u001b[34m(sheets, path)\u001b[39m\n\u001b[32m 54\u001b[39m path = Path(path)\n\u001b[32m 55\u001b[39m path.parent.mkdir(parents=\u001b[38;5;28;01mTrue\u001b[39;00m, exist_ok=\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[32m---> \u001b[39m\u001b[32m56\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[30;43mpd\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mExcelWriter\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mpath\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mengine\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43m\"\u001b[39;49m\u001b[30;43mopenpyxl\u001b[39;49m\u001b[30;43m\"\u001b[39;49m\u001b[30;43m)\u001b[39;49m \u001b[38;5;28;01mas\u001b[39;00m writer:\n\u001b[32m 57\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m name, df \u001b[38;5;129;01min\u001b[39;00m sheets.items():\n\u001b[32m 58\u001b[39m df.to_excel(writer, sheet_name=name[:\u001b[32m31\u001b[39m], index=\u001b[38;5;28;01mFalse\u001b[39;00m)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/env/palladium/lib/python3.12/site-packages/pandas/io/excel/_openpyxl.py:58\u001b[39m, in \u001b[36mOpenpyxlWriter.__init__\u001b[39m\u001b[34m(self, path, engine, date_format, datetime_format, mode, storage_options, if_sheet_exists, engine_kwargs, **kwargs)\u001b[39m\n\u001b[32m 45\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__init__\u001b[39m( \u001b[38;5;66;03m# pyright: ignore[reportInconsistentConstructor]\u001b[39;00m\n\u001b[32m 46\u001b[39m \u001b[38;5;28mself\u001b[39m,\n\u001b[32m 47\u001b[39m path: FilePath | WriteExcelBuffer | ExcelWriter,\n\u001b[32m (...)\u001b[39m\u001b[32m 56\u001b[39m ) -> \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 57\u001b[39m \u001b[38;5;66;03m# Use the openpyxl module as the Excel writer.\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m58\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mopenpyxl\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mworkbook\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Workbook\n\u001b[32m 60\u001b[39m engine_kwargs = combine_kwargs(engine_kwargs, kwargs)\n\u001b[32m 62\u001b[39m \u001b[38;5;28msuper\u001b[39m().\u001b[34m__init__\u001b[39m(\n\u001b[32m 63\u001b[39m path,\n\u001b[32m 64\u001b[39m mode=mode,\n\u001b[32m (...)\u001b[39m\u001b[32m 67\u001b[39m engine_kwargs=engine_kwargs,\n\u001b[32m 68\u001b[39m )\n", + "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'openpyxl'" + ] + } + ], + "source": [ + "scenario_comparison = pd.DataFrame([\n", + " {\"scenario\": n,\n", + " **{f\"NPV\": c[\"npv\"], \"payback_years\": c[\"payback_period_years\"],\n", + " \"roi_3yr\": c[\"roi_3yr\"]}}\n", + " for n, c in ((n, build_business_case(sites, scopes, meters, pricing,\n", + " takeouts, n,\n", + " benefit_params=BENEFIT_PARAMS_MODE))\n", + " for n in (\"floor\", \"realistic\", \"stretch\"))\n", + "])\n", + "\n", + "xlsx = export_excel({\n", + " \"Inputs\": sites_dataframe(sites),\n", + " \"Meters\": meters_dataframe(meters),\n", + " \"Cost detail\": cost_3y,\n", + " \"Benefit detail\": ben_3y,\n", + " \"Business case\": pnl,\n", + " \"Scenario comparison\": scenario_comparison,\n", + "}, _ROOT / \"exports\" / f\"ctm_token_calculator_{SCENARIO}.xlsx\")\n", + "json_path = _ROOT / \"exports\" / f\"ctm_scenario_{SCENARIO}.json\"\n", + "scenario_state_to_json(sites, takeouts, scopes, json_path)\n", + "print(f\"Excel → {xlsx}\\nJSON → {json_path}\")" + ] + }, + { + "cell_type": "markdown", + "id": "ec9f50a0", + "metadata": {}, + "source": [ + "## Scratchpad\n", + "\n", + "Ad-hoc analysis below — e.g. per-site cost detail:\n", + "```python\n", + "calculate_consumption_ai_cost(sites, scopes[0], meters[\"Voice Bot\"], scenario, pricing, year=YEAR)\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "76d303ce", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/studies/202512_GenesysCX/ctm-token-calculator/pyproject.toml b/studies/202512_GenesysCX/ctm-token-calculator/pyproject.toml new file mode 100644 index 0000000..688439f --- /dev/null +++ b/studies/202512_GenesysCX/ctm-token-calculator/pyproject.toml @@ -0,0 +1,31 @@ +[build-system] +requires = ["setuptools>=68"] +build-backend = "setuptools.build_meta" + +[project] +name = "ctm-token-calculator" +version = "0.1.0" +description = "Genesys AI Token Cost & Business Case Calculator (CTM)" +requires-python = ">=3.10" +dependencies = [ + "pandas>=2.0", + "numpy>=1.25", + "plotly>=5.18", + "openpyxl>=3.1", +] + +[project.optional-dependencies] +app = ["streamlit>=1.30"] +notebook = ["jupyterlab>=4.0", "ipywidgets>=8.0"] +dev = ["pytest>=7.4", "mypy>=1.8"] + +[tool.setuptools.packages.find] +include = ["tokencalc*"] + +[tool.pytest.ini_options] +testpaths = ["tests"] +addopts = "-q" + +[tool.mypy] +strict = true +packages = ["tokencalc"] diff --git a/studies/202512_GenesysCX/ctm-token-calculator/requirements.txt b/studies/202512_GenesysCX/ctm-token-calculator/requirements.txt new file mode 100644 index 0000000..7a47203 --- /dev/null +++ b/studies/202512_GenesysCX/ctm-token-calculator/requirements.txt @@ -0,0 +1,9 @@ +streamlit>=1.30 +pandas>=2.0 +numpy>=1.25 +plotly>=5.18 +openpyxl>=3.1 +pydantic>=2.0 +jupyterlab>=4.0 +ipywidgets>=8.0 +pytest>=7.4 diff --git a/studies/202512_GenesysCX/ctm-token-calculator/tests/test_benefit_model.py b/studies/202512_GenesysCX/ctm-token-calculator/tests/test_benefit_model.py new file mode 100644 index 0000000..f2b1dd8 --- /dev/null +++ b/studies/202512_GenesysCX/ctm-token-calculator/tests/test_benefit_model.py @@ -0,0 +1,107 @@ +"""Benefit engine.""" + +from __future__ import annotations + +import pytest + +from tokencalc.benefit_model import ( + calculate_acw_summarization_benefit, + calculate_email_ai_benefit, + calculate_total_benefit, +) +from tokencalc.defaults import CTM_DEFAULT_FEATURE_SCOPES, CTM_DEFAULT_SITES +from tokencalc.inputs import WORKING_SECONDS_PER_YEAR, FeatureScope, SiteInput + +ALL_SITES = [s.site_name for s in CTM_DEFAULT_SITES] + + +def _small_site() -> SiteInput: + return SiteInput( + "Small", "US", agents=10, supervisors=1, + voice_volume_monthly=10_000, email_volume_monthly=1_000, + chat_volume_monthly=0, sms_volume_monthly=0, + voice_aht_seconds=300, email_aht_seconds=600, + chat_aht_seconds=480, voice_acw_seconds=60, + fully_loaded_agent_cost_annual=74_880, # → $0.01/second exactly + fully_loaded_supervisor_cost_annual=95_000, + ) + + +def test_acw_benefit_hand_check(): + """10,000 calls × 12 × 70% eligible × 60s ACW × 40% reduction × + 50% Y1 realization × $0.01/s = $10,080.""" + site = _small_site() + assert site.agent_cost_per_second == pytest.approx(0.01) + df = calculate_acw_summarization_benefit( + [site], FeatureScope("Agent Copilot", ["Small"]), "realistic", year=1, + ) + expected = 10_000 * 12 * 0.70 * 60 * 0.40 * 0.50 * 0.01 + assert df["annual_value"].sum() == pytest.approx(expected) + + +def test_email_benefit_split(): + site = _small_site() + df = calculate_email_ai_benefit( + [site], FeatureScope("Email AI (Auto-Respond)", ["Small"]), + "realistic", year=1, + ) + lines = set(df["benefit_line"]) + assert lines == { + "Email Auto-Respond (displaced handling)", + "Email Auto-Suggest (drafting time)", + } + # auto-respond: 1,000×12 × 20% × 600s × 50% × $0.01 = $7,200 + respond = df[df["benefit_line"].str.contains("Respond")]["annual_value"].sum() + assert respond == pytest.approx(7_200) + + +def test_scenarios_produce_distinct_benefits(): + totals = { + name: calculate_total_benefit( + CTM_DEFAULT_SITES, CTM_DEFAULT_FEATURE_SCOPES, name, year=2 + )["annual_value"].sum() + for name in ("floor", "realistic", "stretch") + } + assert totals["floor"] < totals["realistic"] < totals["stretch"] + + +def test_claim_exceeds_realistic(): + realistic = calculate_total_benefit( + CTM_DEFAULT_SITES, CTM_DEFAULT_FEATURE_SCOPES, "realistic", year=1, + params="realistic", + )["annual_value"].sum() + claim = calculate_total_benefit( + CTM_DEFAULT_SITES, CTM_DEFAULT_FEATURE_SCOPES, "realistic", year=1, + params="claim", + )["annual_value"].sum() + assert claim > realistic + + +def test_benefits_ramp_by_year(): + by_year = [ + calculate_total_benefit( + CTM_DEFAULT_SITES, CTM_DEFAULT_FEATURE_SCOPES, "realistic", year=y + )["annual_value"].sum() + for y in (1, 2, 3) + ] + assert by_year[0] < by_year[1] < by_year[2] + + +def test_zero_volume_site_is_safe(): + site = SiteInput( + "Empty", "US", agents=0, supervisors=0, + voice_volume_monthly=0, email_volume_monthly=0, + chat_volume_monthly=0, sms_volume_monthly=0, + voice_aht_seconds=300, email_aht_seconds=600, + chat_aht_seconds=480, voice_acw_seconds=0, + fully_loaded_agent_cost_annual=0, + fully_loaded_supervisor_cost_annual=0, + ) + df = calculate_total_benefit( + [site], [FeatureScope("Agent Copilot", ["Empty"])], "realistic", year=1, + ) + assert df["annual_value"].sum() == 0 + + +def test_working_seconds_constant(): + assert WORKING_SECONDS_PER_YEAR == 2_080 * 3_600 diff --git a/studies/202512_GenesysCX/ctm-token-calculator/tests/test_business_case.py b/studies/202512_GenesysCX/ctm-token-calculator/tests/test_business_case.py new file mode 100644 index 0000000..76dcd49 --- /dev/null +++ b/studies/202512_GenesysCX/ctm-token-calculator/tests/test_business_case.py @@ -0,0 +1,117 @@ +"""Business case maths + exports.""" + +from __future__ import annotations + +import pytest + +from tokencalc.business_case import build_business_case, npv, payback_years +from tokencalc.defaults import ( + CTM_DEFAULT_FEATURE_SCOPES, + CTM_DEFAULT_SITES, + CTM_DEFAULT_TAKEOUTS, + DEFAULT_METERS, + DEFAULT_PRICING, +) +from tokencalc.exports import ( + export_excel, + scenario_state_from_json, + scenario_state_to_json, +) + + +def test_npv_hand_check(): + """100/yr for 3 years @ 8%: 92.593 + 85.734 + 79.383 = 257.710.""" + assert npv([100, 100, 100], 0.08) == pytest.approx(257.710, abs=0.001) + + +def test_payback_interpolation(): + # -100 in Y1, +200 in Y2 → breakeven halfway through Y2 = 1.5 years + assert payback_years([-100, 200, 0]) == pytest.approx(1.5) + assert payback_years([-100, -100, -100]) is None + assert payback_years([50, 50, 50]) == pytest.approx(0.0) + + +def _case(scenario="realistic", **kw): + return build_business_case( + CTM_DEFAULT_SITES, CTM_DEFAULT_FEATURE_SCOPES, DEFAULT_METERS, + DEFAULT_PRICING, CTM_DEFAULT_TAKEOUTS, scenario, **kw, + ) + + +def test_business_case_shape(): + case = _case() + assert set(case) == { + "cost_by_year", "benefit_by_year", "takeouts_by_year", + "net_by_year", "cumulative_net", "npv", + "payback_period_years", "roi_3yr", + } + for key in ("cost_by_year", "benefit_by_year", "net_by_year"): + assert {"Y1", "Y2", "Y3"} <= set(case[key].columns) + + +def test_net_consistency(): + """NET row must equal benefits + takeouts − costs, per year.""" + case = _case() + nb = case["net_by_year"].set_index("line") + for y in ("Y1", "Y2", "Y3"): + assert nb.loc["NET", y] == pytest.approx( + nb.loc["TOTAL BENEFITS", y] + + nb.loc["TOTAL TAKEOUTS", y] + - nb.loc["TOTAL COSTS", y] + ) + # cumulative is a running sum of NET + assert nb.loc["Cumulative net", "Y3"] == pytest.approx( + sum(nb.loc["NET", y] for y in ("Y1", "Y2", "Y3")) + ) + + +def test_npv_matches_net_rows(): + case = _case() + nb = case["net_by_year"].set_index("line") + net = [nb.loc["NET", y] for y in ("Y1", "Y2", "Y3")] + assert case["npv"] == pytest.approx(npv(net, 0.08)) + + +def test_three_scenarios_distinct(): + npvs = {s: _case(s)["npv"] for s in ("floor", "realistic", "stretch")} + assert len({round(v) for v in npvs.values()}) == 3 + assert npvs["floor"] < npvs["realistic"] < npvs["stretch"] + + +def test_implementation_amortization(): + base = _case() + with_impl = _case(implementation_cost=900_000) + nb, nb2 = ( + c["net_by_year"].set_index("line") for c in (base, with_impl) + ) + for y in ("Y1", "Y2", "Y3"): + assert nb2.loc["TOTAL COSTS", y] == pytest.approx( + nb.loc["TOTAL COSTS", y] + 300_000 + ) + + +def test_excel_export_readable(tmp_path): + case = _case() + path = export_excel( + { + "Business Case": case["net_by_year"], + "Costs": case["cost_by_year"], + "Benefits": case["benefit_by_year"], + }, + tmp_path / "ctm.xlsx", + ) + import openpyxl + + wb = openpyxl.load_workbook(path) + assert set(wb.sheetnames) == {"Business Case", "Costs", "Benefits"} + + +def test_scenario_json_roundtrip(tmp_path): + p = tmp_path / "state.json" + scenario_state_to_json( + CTM_DEFAULT_SITES, CTM_DEFAULT_TAKEOUTS, CTM_DEFAULT_FEATURE_SCOPES, p + ) + sites, takeouts, scopes = scenario_state_from_json(p) + assert [s.site_name for s in sites] == [s.site_name for s in CTM_DEFAULT_SITES] + assert takeouts[0].annual_cost == CTM_DEFAULT_TAKEOUTS[0].annual_cost + assert scopes[0].adoption_curve == CTM_DEFAULT_FEATURE_SCOPES[0].adoption_curve diff --git a/studies/202512_GenesysCX/ctm-token-calculator/tests/test_cost_model.py b/studies/202512_GenesysCX/ctm-token-calculator/tests/test_cost_model.py new file mode 100644 index 0000000..a22929d --- /dev/null +++ b/studies/202512_GenesysCX/ctm-token-calculator/tests/test_cost_model.py @@ -0,0 +1,140 @@ +"""Cost engine — including the spec's acceptance numbers.""" + +from __future__ import annotations + +import pytest + +from tokencalc.cost_model import ( + calculate_consumption_ai_cost, + calculate_per_user_ai_cost, + calculate_platform_license_cost, + calculate_total_cost, +) +from tokencalc.defaults import ( + CONTRACTED_NAMED_USERS, + CTM_DEFAULT_FEATURE_SCOPES, + CTM_DEFAULT_SITES, + DEFAULT_METERS, + DEFAULT_PRICING, +) +from tokencalc.inputs import FeatureScope, SiteInput +from tokencalc.scenarios import get_scenario + +ALL_SITES = [s.site_name for s in CTM_DEFAULT_SITES] + + +def _scope(feature, sites=None, **kw): + return FeatureScope(feature, sites or ALL_SITES, **kw) + + +def test_default_sites_match_contracted_users(): + assert sum(s.named_users for s in CTM_DEFAULT_SITES) == CONTRACTED_NAMED_USERS + + +def test_sta_acceptance_number(): + """2,088 users × 30 tokens × 12 months × $1 = $751,680.""" + df = calculate_per_user_ai_cost( + CTM_DEFAULT_SITES, _scope("Speech & Text Analytics"), + DEFAULT_METERS["Speech & Text Analytics"], DEFAULT_PRICING, + ) + assert df["annual_cost"].sum() == pytest.approx(751_680) + + +def test_agent_copilot_acceptance_number(): + """2,088 users × 40 tokens × 12 months × $1 = $1,002,240.""" + df = calculate_per_user_ai_cost( + CTM_DEFAULT_SITES, _scope("Agent Copilot"), + DEFAULT_METERS["Agent Copilot"], DEFAULT_PRICING, + ) + assert df["annual_cost"].sum() == pytest.approx(1_002_240) + + +def test_per_user_not_active_before_phase(): + df = calculate_per_user_ai_cost( + CTM_DEFAULT_SITES, _scope("AI Translate", phase=3), + DEFAULT_METERS["AI Translate"], DEFAULT_PRICING, year=2, + ) + assert df["annual_cost"].sum() == 0 + + +def test_copilot_covers_supervisor_summary(): + """Rule 1: AI Summary cost is zero at Copilot sites.""" + scenario = get_scenario("realistic") + total = calculate_total_cost( + CTM_DEFAULT_SITES, + [ + _scope("Agent Copilot"), + _scope("AI Summary & Insights"), + ], + DEFAULT_METERS, DEFAULT_PRICING, scenario, year=1, + include_platform=False, + ) + summary_row = total[total["cost_line"] == "AI Summary & Insights"].iloc[0] + assert summary_row["annual_cost"] == 0 + # Without Copilot the same line costs real money. + total2 = calculate_total_cost( + CTM_DEFAULT_SITES, + [_scope("AI Summary & Insights")], + DEFAULT_METERS, DEFAULT_PRICING, scenario, year=1, + include_platform=False, + ) + assert total2[total2["cost_line"] == "AI Summary & Insights"].iloc[0][ + "annual_cost" + ] > 0 + + +def test_consumption_tokens_rounded_up_monthly(): + """Rule 2: ceil on monthly site token totals.""" + site = SiteInput( + "Tiny", "US", agents=5, supervisors=0, + voice_volume_monthly=100, email_volume_monthly=0, + chat_volume_monthly=0, sms_volume_monthly=0, + voice_aht_seconds=300, email_aht_seconds=600, + chat_aht_seconds=480, voice_acw_seconds=60, + fully_loaded_agent_cost_annual=65_000, + fully_loaded_supervisor_cost_annual=95_000, + ) + # realistic: 100 calls × 35% × 1.5 min = 52.5 min × (1/17) = 3.088 + # tokens × 70% Y1 ramp applied to units → 36.75 min → 2.16 tokens → ceil 3 + df = calculate_consumption_ai_cost( + [site], FeatureScope("Voice Bot", ["Tiny"]), + DEFAULT_METERS["Voice Bot"], "realistic", DEFAULT_PRICING, year=1, + ) + assert df.iloc[0]["tokens_monthly"] == 3 + assert df.iloc[0]["annual_cost"] == pytest.approx(3 * 12 * 1.0) + + +def test_regional_pricing_not_hardcoded(): + pricing = dict(DEFAULT_PRICING) + from tokencalc.meters import TokenPricing + + pricing["APAC"] = TokenPricing(region="APAC", list_rate_per_token=2.0) + apac_site = next(s for s in CTM_DEFAULT_SITES if s.region_pricing == "APAC") + df = calculate_per_user_ai_cost( + [apac_site], _scope("Speech & Text Analytics", [apac_site.site_name]), + DEFAULT_METERS["Speech & Text Analytics"], pricing, + ) + expected = apac_site.named_users * 30 * 12 * 2.0 + assert df["annual_cost"].sum() == pytest.approx(expected) + + +def test_year1_consumption_ramp_default_70pct(): + sc = get_scenario("realistic") + assert sc.cost_realization(1) == pytest.approx(0.70) + assert sc.cost_realization(2) == 1.0 + + +def test_platform_license_cost(): + df = calculate_platform_license_cost(CTM_DEFAULT_SITES) + expected = CONTRACTED_NAMED_USERS * 111.28 * 12 + assert df["annual_cost"].sum() == pytest.approx(expected) + + +def test_total_cost_default_scopes_runs_all_years(): + for year in (1, 2, 3): + df = calculate_total_cost( + CTM_DEFAULT_SITES, CTM_DEFAULT_FEATURE_SCOPES, + DEFAULT_METERS, DEFAULT_PRICING, "realistic", year, + ) + assert (df["annual_cost"] >= 0).all() + assert {"cost_line", "scope", "annual_cost", "confidence"} <= set(df.columns) diff --git a/studies/202512_GenesysCX/ctm-token-calculator/tests/test_meters.py b/studies/202512_GenesysCX/ctm-token-calculator/tests/test_meters.py new file mode 100644 index 0000000..9124da3 --- /dev/null +++ b/studies/202512_GenesysCX/ctm-token-calculator/tests/test_meters.py @@ -0,0 +1,66 @@ +"""Meter catalogue integrity.""" + +from __future__ import annotations + +import pytest + +from tokencalc.defaults import DEFAULT_METERS, DEFAULT_PRICING +from tokencalc.meters import Confidence, MeterType, TokenMeter, TokenPricing + + +def test_all_spec_meters_present(): + expected = { + "Voice Bot", "Virtual Agent (legacy)", "Agentic Virtual Agent", + "AI Summary & Insights", "Direct Messaging", "Social Listening", + "Social Responses", "Speech & Text Analytics", "Agent Copilot", + "Email AI (Auto-Suggest)", "Email AI (Auto-Respond)", "AI Translate", + } + assert expected == set(DEFAULT_METERS) + + +def test_confirmed_rates(): + m = DEFAULT_METERS + assert m["Voice Bot"].units_per_token == 17 + assert m["Voice Bot"].tokens_per_unit == pytest.approx(0.0588, abs=1e-3) + assert m["Agentic Virtual Agent"].tokens_per_unit == 1.2 + assert m["AI Summary & Insights"].tokens_per_unit == 0.02 + assert m["Direct Messaging"].units_per_token == 400 + assert m["Speech & Text Analytics"].tokens_per_unit == 30 + assert m["Agent Copilot"].tokens_per_unit == 40 + + +def test_unknown_meters_flagged(): + unknown = {f for f, m in DEFAULT_METERS.items() if m.confidence is Confidence.UNKNOWN} + assert unknown == { + "Email AI (Auto-Suggest)", "Email AI (Auto-Respond)", "AI Translate" + } + assert Confidence.UNKNOWN.icon == "🔴" + assert Confidence.CONFIRMED.icon == "🟢" + + +def test_inverse_consistency_validated(): + with pytest.raises(ValueError, match="not inverses"): + TokenMeter( + feature="Bad", meter_type=MeterType.PER_MINUTE, + units_per_token=10, tokens_per_unit=0.5, + confidence=Confidence.ESTIMATED, notes="", + ) + + +def test_every_confirmed_meter_has_source_url(): + for m in DEFAULT_METERS.values(): + if m.confidence is Confidence.CONFIRMED: + assert m.source_url, f"{m.feature} missing source URL" + + +def test_pricing_effective_rate(): + p = TokenPricing(region="US", list_rate_per_token=1.0, + contracted_rate_per_token=0.85) + assert p.effective_rate(use_contracted=False) == 1.0 + assert p.effective_rate(use_contracted=True) == 0.85 + # no contracted rate → falls back to list + assert DEFAULT_PRICING["US"].effective_rate(use_contracted=True) == 1.0 + + +def test_all_regions_priced(): + assert set(DEFAULT_PRICING) == {"US", "EU", "AU", "APAC"} diff --git a/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/__init__.py b/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/__init__.py new file mode 100644 index 0000000..7afa93f --- /dev/null +++ b/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/__init__.py @@ -0,0 +1,77 @@ +""" +tokencalc — Genesys AI token cost & business case calculator core. + +Pure-Python, UI-agnostic. The JupyterLab notebook and the Streamlit +app are thin presentation layers over these functions. +""" + +from .benefit_model import calculate_total_benefit +from .business_case import build_business_case, npv, payback_years +from .cost_model import ( + calculate_consumption_ai_cost, + calculate_per_user_ai_cost, + calculate_platform_license_cost, + calculate_total_cost, +) +from .defaults import ( + CONTRACTED_NAMED_USERS, + CTM_DEFAULT_FEATURE_SCOPES, + CTM_DEFAULT_ROLLOUT, + CTM_DEFAULT_SITES, + CTM_DEFAULT_TAKEOUTS, + DEFAULT_METERS, + DEFAULT_PRICING, + PLATFORM_RATE_PER_USER_MONTHLY, +) +from .rollout import NO_ROLLOUT, RolloutPlan +from .exports import ( + export_csv, + export_excel, + meters_dataframe, + scenario_state_from_json, + scenario_state_to_json, + sites_dataframe, +) +from .inputs import CostTakeout, FeatureScope, SiteInput +from .meters import Confidence, MeterType, TokenMeter, TokenPricing +from .scenarios import BENEFIT_PARAMS, SCENARIOS, Scenario, get_scenario + +__version__ = "0.1.0" + +__all__ = [ + "BENEFIT_PARAMS", + "CONTRACTED_NAMED_USERS", + "CTM_DEFAULT_FEATURE_SCOPES", + "CTM_DEFAULT_ROLLOUT", + "CTM_DEFAULT_SITES", + "CTM_DEFAULT_TAKEOUTS", + "Confidence", + "CostTakeout", + "DEFAULT_METERS", + "DEFAULT_PRICING", + "FeatureScope", + "MeterType", + "NO_ROLLOUT", + "PLATFORM_RATE_PER_USER_MONTHLY", + "RolloutPlan", + "SCENARIOS", + "Scenario", + "SiteInput", + "TokenMeter", + "TokenPricing", + "build_business_case", + "calculate_consumption_ai_cost", + "calculate_per_user_ai_cost", + "calculate_platform_license_cost", + "calculate_total_benefit", + "calculate_total_cost", + "export_csv", + "export_excel", + "get_scenario", + "meters_dataframe", + "npv", + "payback_years", + "scenario_state_from_json", + "scenario_state_to_json", + "sites_dataframe", +] diff --git a/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/benefit_model.py b/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/benefit_model.py new file mode 100644 index 0000000..0b9a2d0 --- /dev/null +++ b/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/benefit_model.py @@ -0,0 +1,379 @@ +""" +Benefit calculation engine. + +All benefits convert saved handle-time seconds into dollars via each +site's fully-loaded labour rate per working second. Reduction +percentages come from :data:`tokencalc.scenarios.BENEFIT_PARAMS` — +``realistic`` (pressure-tested) by default; pass ``params="claim"`` +to reproduce the Genesys ROI-doc figures for side-by-side comparison. + +Every figure scales by the scenario's year realization ramp. +""" + +from __future__ import annotations + +import pandas as pd + +from .inputs import FeatureScope, SiteInput +from .meters import Confidence +from .rollout import NO_ROLLOUT, RolloutPlan +from .scenarios import BENEFIT_PARAMS, Scenario, get_scenario + +MONTHS_PER_YEAR = 12 + + +def _param(name: str, params: str) -> float: + return BENEFIT_PARAMS[name][params] + + +def _scope_for(feature_scopes: list[FeatureScope] | FeatureScope, + feature: str) -> FeatureScope | None: + if isinstance(feature_scopes, FeatureScope): + return feature_scopes if feature_scopes.feature == feature else None + return next((s for s in feature_scopes if s.feature == feature), None) + + +def _df(rows: list[dict]) -> pd.DataFrame: + return pd.DataFrame( + rows, columns=["benefit_line", "scope", "annual_value", "confidence"] + ) + + +def calculate_voice_handle_time_benefit( + sites: list[SiteInput], + feature_scope: FeatureScope, + scenario: str | Scenario, + year: int, + params: str = "realistic", + rollout: RolloutPlan | None = None, +) -> pd.DataFrame: + """AHT reduction from knowledge surfacing (Agent Copilot). + + Benefit = volume × eligibility × AHT × reduction% × labour rate. + """ + sc = get_scenario(scenario) if isinstance(scenario, str) else scenario + ro = rollout or NO_ROLLOUT + reduction = _param("voice_aht_knowledge_reduction", params) + realization = sc.realization(year) + rows = [] + for s in sites: + if not feature_scope.active(s.site_name, year): + continue + eligibility = ( + feature_scope.eligibility_pct + if feature_scope.eligibility_pct is not None + else sc.voice_knowledge_eligibility + ) + seconds_saved = ( + s.voice_volume_monthly * MONTHS_PER_YEAR + * eligibility * s.voice_aht_seconds * reduction * realization + ) + rows.append( + { + "benefit_line": "Voice AHT (knowledge surfacing)", + "scope": s.site_name, + "annual_value": seconds_saved * s.agent_cost_per_second + * ro.fraction_live(s.site_name, year), + "confidence": Confidence.ESTIMATED.value, + } + ) + return _df(rows) + + +def calculate_acw_summarization_benefit( + sites: list[SiteInput], + feature_scope: FeatureScope, + scenario: str | Scenario, + year: int, + params: str = "realistic", + rollout: RolloutPlan | None = None, +) -> pd.DataFrame: + """ACW eliminated by auto-summarization (Copilot / AI Summary).""" + sc = get_scenario(scenario) if isinstance(scenario, str) else scenario + ro = rollout or NO_ROLLOUT + reduction = _param("voice_acw_reduction", params) + realization = sc.realization(year) + rows = [] + for s in sites: + if not feature_scope.active(s.site_name, year): + continue + eligibility = ( + feature_scope.eligibility_pct + if feature_scope.eligibility_pct is not None + else sc.voice_summarization_eligibility + ) + seconds_saved = ( + s.voice_volume_monthly * MONTHS_PER_YEAR + * eligibility * s.voice_acw_seconds * reduction * realization + ) + rows.append( + { + "benefit_line": "Voice ACW (summarization)", + "scope": s.site_name, + "annual_value": seconds_saved * s.agent_cost_per_second + * ro.fraction_live(s.site_name, year), + "confidence": Confidence.ESTIMATED.value, + } + ) + return _df(rows) + + +def calculate_email_ai_benefit( + sites: list[SiteInput], + feature_scope: FeatureScope, + scenario: str | Scenario, + year: int, + params: str = "realistic", + rollout: RolloutPlan | None = None, +) -> pd.DataFrame: + """Email Auto-Respond (full displacement at the respond rate) plus + Auto-Suggest (time saving × acceptance on the remainder).""" + sc = get_scenario(scenario) if isinstance(scenario, str) else scenario + ro = rollout or NO_ROLLOUT + suggest_saving = _param("email_auto_suggest_time_saving", params) + realization = sc.realization(year) + rows = [] + for s in sites: + if not feature_scope.active(s.site_name, year): + continue + respond_rate = ( + feature_scope.deflection_target + if feature_scope.deflection_target is not None + else sc.email_auto_respond_rate + ) + annual_emails = s.email_volume_monthly * MONTHS_PER_YEAR + respond_seconds = ( + annual_emails * respond_rate * s.email_aht_seconds * realization + ) + suggest_seconds = ( + annual_emails * (1 - respond_rate) + * sc.email_auto_suggest_acceptance * s.email_aht_seconds + * suggest_saving * realization + ) + rate = s.agent_cost_per_second + rows.append( + { + "benefit_line": "Email Auto-Respond (displaced handling)", + "scope": s.site_name, + "annual_value": respond_seconds * rate + * ro.fraction_live(s.site_name, year), + "confidence": Confidence.UNKNOWN.value, # meter rate unsourced + } + ) + rows.append( + { + "benefit_line": "Email Auto-Suggest (drafting time)", + "scope": s.site_name, + "annual_value": suggest_seconds * rate + * ro.fraction_live(s.site_name, year), + "confidence": Confidence.UNKNOWN.value, + } + ) + return _df(rows) + + +def calculate_sta_benefit( + sites: list[SiteInput], + feature_scope: FeatureScope, + scenario: str | Scenario, + year: int, + params: str = "realistic", + rollout: RolloutPlan | None = None, +) -> pd.DataFrame: + """STA reduces AHT *indirectly* via coaching — small reduction with + a realistic ramp (default 1.5% vs the 4% claim).""" + sc = get_scenario(scenario) if isinstance(scenario, str) else scenario + ro = rollout or NO_ROLLOUT + reduction = _param("sta_aht_reduction", params) + realization = sc.realization(year) + rows = [] + for s in sites: + if not feature_scope.active(s.site_name, year): + continue + seconds_saved = ( + s.voice_volume_monthly * MONTHS_PER_YEAR + * s.voice_aht_seconds * reduction * realization + ) + rows.append( + { + "benefit_line": "STA coaching (AHT)", + "scope": s.site_name, + "annual_value": seconds_saved * s.agent_cost_per_second + * ro.fraction_live(s.site_name, year), + "confidence": Confidence.ESTIMATED.value, + } + ) + return _df(rows) + + +def calculate_bot_deflection_benefit( + sites: list[SiteInput], + feature_scope: FeatureScope, + scenario: str | Scenario, + year: int, + params: str = "realistic", + rollout: RolloutPlan | None = None, +) -> pd.DataFrame: + """Agent labour avoided on calls deflected to Voice Bot / Agentic VA. + + Not in the original function list but required for a complete net + case — deflected volume never reaches an agent, so the full AHT is + avoided. + """ + sc = get_scenario(scenario) if isinstance(scenario, str) else scenario + ro = rollout or NO_ROLLOUT + realization = sc.realization(year) + rows = [] + for s in sites: + if not feature_scope.active(s.site_name, year): + continue + if feature_scope.feature == "Voice Bot": + deflection = ( + feature_scope.deflection_target + if feature_scope.deflection_target is not None + else sc.voice_bot_deflection + ) + else: # Agentic Virtual Agent + deflection = ( + feature_scope.deflection_target + if feature_scope.deflection_target is not None + else sc.agentic_va_deflection + ) + seconds_saved = ( + s.voice_volume_monthly * MONTHS_PER_YEAR + * deflection * s.voice_aht_seconds * realization + ) + rows.append( + { + "benefit_line": f"{feature_scope.feature} deflection (labour avoided)", + "scope": s.site_name, + "annual_value": seconds_saved * s.agent_cost_per_second + * ro.fraction_live(s.site_name, year), + "confidence": Confidence.ESTIMATED.value, + } + ) + return _df(rows) + + +def calculate_supervisor_copilot_benefit( + sites: list[SiteInput], + feature_scope: FeatureScope, + scenario: str | Scenario, + year: int, + params: str = "realistic", + rollout: RolloutPlan | None = None, +) -> pd.DataFrame: + """Supervisor time reclaimed (summaries, QA triage). ESTIMATED.""" + sc = get_scenario(scenario) if isinstance(scenario, str) else scenario + ro = rollout or NO_ROLLOUT + saving = _param("supervisor_copilot_time_saving", params) + realization = sc.realization(year) + rows = [] + for s in sites: + if not feature_scope.active(s.site_name, year): + continue + rows.append( + { + "benefit_line": "Supervisor time (AI summaries/insights)", + "scope": s.site_name, + "annual_value": s.supervisors + * s.fully_loaded_supervisor_cost_annual + * saving * realization + * ro.fraction_live(s.site_name, year), + "confidence": Confidence.ESTIMATED.value, + } + ) + return _df(rows) + + +def calculate_predictive_routing_benefit( + sites: list[SiteInput], + feature_scope: FeatureScope, + scenario: str | Scenario, + year: int, + params: str = "realistic", + rollout: RolloutPlan | None = None, +) -> pd.DataFrame: + """Predictive routing AHT effect. ESTIMATED; off unless scoped.""" + sc = get_scenario(scenario) if isinstance(scenario, str) else scenario + ro = rollout or NO_ROLLOUT + reduction = _param("predictive_routing_aht_reduction", params) + realization = sc.realization(year) + rows = [] + for s in sites: + if not feature_scope.active(s.site_name, year): + continue + seconds_saved = ( + s.voice_volume_monthly * MONTHS_PER_YEAR + * s.voice_aht_seconds * reduction * realization + ) + rows.append( + { + "benefit_line": "Predictive routing (AHT)", + "scope": s.site_name, + "annual_value": seconds_saved * s.agent_cost_per_second + * ro.fraction_live(s.site_name, year), + "confidence": Confidence.ESTIMATED.value, + } + ) + return _df(rows) + + +#: Which calculator handles which feature scope. +_BENEFIT_DISPATCH = { + "Agent Copilot": ( + calculate_voice_handle_time_benefit, + calculate_acw_summarization_benefit, + ), + "AI Summary & Insights": (), # benefit carried by Copilot where present + "Speech & Text Analytics": (calculate_sta_benefit,), + "Voice Bot": (calculate_bot_deflection_benefit,), + "Agentic Virtual Agent": (calculate_bot_deflection_benefit,), + "Email AI (Auto-Respond)": (calculate_email_ai_benefit,), + "Predictive Routing": (calculate_predictive_routing_benefit,), +} + + +def calculate_total_benefit( + sites: list[SiteInput], + feature_scopes: list[FeatureScope], + scenario: str | Scenario, + year: int, + params: str = "realistic", + include_supervisor_benefit: bool = True, + rollout: RolloutPlan | None = None, +) -> pd.DataFrame: + """All benefit lines for one scenario-year, aggregated per line. + + Returns DataFrame: benefit_line, scope, annual_value, confidence. + """ + sc = get_scenario(scenario) if isinstance(scenario, str) else scenario + frames: list[pd.DataFrame] = [] + copilot_scope = _scope_for(feature_scopes, "Agent Copilot") + + for scope in feature_scopes: + for fn in _BENEFIT_DISPATCH.get(scope.feature, ()): # type: ignore[arg-type] + frames.append(fn(sites, scope, sc, year, params=params, rollout=rollout)) + + if include_supervisor_benefit and copilot_scope is not None: + frames.append( + calculate_supervisor_copilot_benefit( + sites, copilot_scope, sc, year, params=params, rollout=rollout + ) + ) + + frames = [f for f in frames if not f.empty] + if not frames: + return _df([]) + detail = pd.concat(frames, ignore_index=True) + + grouped = ( + detail.groupby("benefit_line", sort=False) + .agg( + scope=("scope", lambda v: ", ".join(sorted(set(v)))), + annual_value=("annual_value", "sum"), + confidence=("confidence", "first"), + ) + .reset_index() + ) + return grouped[["benefit_line", "scope", "annual_value", "confidence"]] diff --git a/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/business_case.py b/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/business_case.py new file mode 100644 index 0000000..1679316 --- /dev/null +++ b/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/business_case.py @@ -0,0 +1,188 @@ +""" +Business case — combines costs, benefits, and cost takeouts into a +3-year net view with NPV, payback, and ROI. + +Convention: all cashflows are year-end and discounted at +``discount_rate`` (default 8%); there is no undiscounted year-0 column +— implementation is amortized straight-line across the analysis years +(spec §5.6 "Implementation amort." line). +""" + +from __future__ import annotations + +import pandas as pd + +from .benefit_model import calculate_total_benefit +from .cost_model import calculate_total_cost +from .defaults import ( + DEFAULT_DISCOUNT_RATE, + DEFAULT_IMPLEMENTATION_COST, + PLATFORM_RATE_PER_USER_MONTHLY, +) +from .inputs import CostTakeout, FeatureScope, SiteInput +from .meters import Confidence, TokenMeter, TokenPricing +from .rollout import RolloutPlan +from .scenarios import Scenario, get_scenario + + +def npv(cashflows_by_year: list[float], discount_rate: float) -> float: + """Year-end-discounted NPV of year-1..N cashflows.""" + return sum( + cf / (1 + discount_rate) ** year + for year, cf in enumerate(cashflows_by_year, start=1) + ) + + +def payback_years(cashflows_by_year: list[float]) -> float | None: + """First (fractional) year cumulative net turns >= 0; None if never. + + Cashflows are assumed evenly spread within each year. + """ + cumulative = 0.0 + for year, cf in enumerate(cashflows_by_year, start=1): + if cumulative + cf >= 0 and cf != 0: + if cumulative >= 0: + return float(year - 1) + return (year - 1) + (-cumulative / cf) + cumulative += cf + return None + + +def build_business_case( + sites: list[SiteInput], + feature_scopes: list[FeatureScope], + meters: dict[str, TokenMeter], + pricing: dict[str, TokenPricing], + takeouts: list[CostTakeout], + scenario: str | Scenario, + years: int = 3, + discount_rate: float = DEFAULT_DISCOUNT_RATE, + platform_rate: float = PLATFORM_RATE_PER_USER_MONTHLY, + implementation_cost: float = DEFAULT_IMPLEMENTATION_COST, + use_contracted: bool = False, + benefit_params: str = "realistic", + rollout: RolloutPlan | None = None, +) -> dict: + """Returns the dict described in spec §4.3 (DataFrames + headline + metrics). Every number traces to a cost line, benefit line, or + takeout row in the per-year detail frames. + """ + sc = get_scenario(scenario) if isinstance(scenario, str) else scenario + year_cols = [f"Y{y}" for y in range(1, years + 1)] + + cost_frames, benefit_frames = {}, {} + for y in range(1, years + 1): + cost_frames[y] = calculate_total_cost( + sites, feature_scopes, meters, pricing, sc, y, + platform_rate=platform_rate, use_contracted=use_contracted, + rollout=rollout, + ) + benefit_frames[y] = calculate_total_benefit( + sites, feature_scopes, sc, y, params=benefit_params, + rollout=rollout, + ) + + # ── cost_by_year: one row per cost line, one column per year ──── + cost_lines = list(cost_frames[1]["cost_line"]) + cost_by_year = pd.DataFrame({"line": cost_lines}) + for y in range(1, years + 1): + cost_by_year[f"Y{y}"] = list(cost_frames[y]["annual_cost"]) + cost_by_year["confidence"] = list(cost_frames[1]["confidence"]) + if implementation_cost: + amort = implementation_cost / years + cost_by_year = pd.concat( + [ + cost_by_year, + pd.DataFrame( + [ + { + "line": "Implementation (amortized)", + **{c: amort for c in year_cols}, + "confidence": Confidence.ESTIMATED.value, + } + ] + ), + ], + ignore_index=True, + ) + + # ── benefit_by_year ────────────────────────────────────────────── + benefit_lines: list[str] = [] + for y in range(1, years + 1): + for line in benefit_frames[y]["benefit_line"]: + if line not in benefit_lines: + benefit_lines.append(line) + benefit_by_year = pd.DataFrame({"line": benefit_lines}) + for y in range(1, years + 1): + lookup = dict( + zip(benefit_frames[y]["benefit_line"], benefit_frames[y]["annual_value"]) + ) + benefit_by_year[f"Y{y}"] = [lookup.get(line, 0.0) for line in benefit_lines] + conf_lookup: dict[str, str] = {} + for y in range(1, years + 1): + conf_lookup.update( + dict(zip(benefit_frames[y]["benefit_line"], benefit_frames[y]["confidence"])) + ) + benefit_by_year["confidence"] = [ + conf_lookup.get(line, Confidence.ESTIMATED.value) for line in benefit_lines + ] + + # ── takeouts_by_year ───────────────────────────────────────────── + takeouts_by_year = pd.DataFrame( + [ + { + "line": t.name, + **{f"Y{y}": t.value_in_year(y) for y in range(1, years + 1)}, + "confidence": t.confidence.value, + } + for t in takeouts + ] + ) + + # ── net + cumulative ───────────────────────────────────────────── + total_costs = [float(cost_by_year[c].sum()) for c in year_cols] + total_benefits = [float(benefit_by_year[c].sum()) for c in year_cols] + total_takeouts = [ + float(takeouts_by_year[c].sum()) if not takeouts_by_year.empty else 0.0 + for c in year_cols + ] + net = [ + b + t - c for b, t, c in zip(total_benefits, total_takeouts, total_costs) + ] + cumulative = pd.Series(net).cumsum().tolist() + + net_by_year = pd.DataFrame( + { + "line": [ + "TOTAL COSTS", "TOTAL TAKEOUTS", "TOTAL BENEFITS", + "NET", "Cumulative net", + ], + **{ + f"Y{y}": [ + total_costs[y - 1], total_takeouts[y - 1], + total_benefits[y - 1], net[y - 1], cumulative[y - 1], + ] + for y in range(1, years + 1) + }, + } + ) + cumulative_net = pd.DataFrame( + {"year": list(range(1, years + 1)), "cumulative_net": cumulative} + ) + + total_cost_sum = sum(total_costs) + total_value_sum = sum(total_benefits) + sum(total_takeouts) + return { + "cost_by_year": cost_by_year, + "benefit_by_year": benefit_by_year, + "takeouts_by_year": takeouts_by_year, + "net_by_year": net_by_year, + "cumulative_net": cumulative_net, + "npv": npv(net, discount_rate), + "payback_period_years": payback_years(net), + "roi_3yr": ( + (total_value_sum - total_cost_sum) / total_cost_sum + if total_cost_sum + else None + ), + } diff --git a/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/cost_model.py b/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/cost_model.py new file mode 100644 index 0000000..c5d4ab5 --- /dev/null +++ b/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/cost_model.py @@ -0,0 +1,301 @@ +""" +Cost calculation engine. + +Correctness rules implemented here (see spec §4.1): + +1. **Agent Copilot covers Supervisor AI Summary.** Where Agent Copilot + is enabled at a site, AI Summary & Insights consumption at that site + is forced to zero — Copilot's per-user token rate already includes + interaction summarization. Source: Genesys Cloud AI Experience + tokens FAQ, + https://help.mypurecloud.com/articles/genesys-cloud-ai-experience-tokens-faqs/ +2. **Token rounding.** Genesys rounds consumption up at billing — + ``math.ceil`` is applied to each site's MONTHLY consumption token + total before the rate. Per-user totals (users × tokens/user/month) + are exact and not rounded. +3. **Regional pricing.** Every site resolves its rate through its + ``region_pricing`` key — never a hardcoded US rate. +4. **Adoption ramp.** Consumption features ramp (default Y1 = 70%); + per-user licences are paid in full from their phase year. +""" + +from __future__ import annotations + +import math + +import pandas as pd + +from .defaults import PLATFORM_RATE_PER_USER_MONTHLY +from .inputs import FeatureScope, SiteInput +from .meters import Confidence, MeterType, TokenMeter, TokenPricing +from .rollout import NO_ROLLOUT, RolloutPlan +from .scenarios import Scenario, get_scenario + +MONTHS_PER_YEAR = 12 + + +def _rate(site: SiteInput, pricing: dict[str, TokenPricing], + use_contracted: bool = False) -> float: + """Resolve the per-token rate for a site's pricing region.""" + region = pricing.get(site.region_pricing) + if region is None: + raise KeyError( + f"No TokenPricing for region {site.region_pricing!r} " + f"(site {site.site_name})" + ) + return region.effective_rate(use_contracted) + + +def calculate_platform_license_cost( + sites: list[SiteInput], + per_user_monthly_rate: float = PLATFORM_RATE_PER_USER_MONTHLY, + year: int = 1, + rollout: RolloutPlan | None = None, +) -> pd.DataFrame: + """Genesys Cloud CX 3 named-user platform licences. + + The commit bills in full from contract start regardless of site + go-lives; the vendor ramp credit reduces YEAR 1 only (typical + 6-month ramp → 50% Y1 discount). + Returns DataFrame: site, agents, supervisors, named_users, annual_cost. + """ + ro = rollout or NO_ROLLOUT + factor = ro.platform_factor(year) + rows = [ + { + "site": s.site_name, + "agents": s.agents, + "supervisors": s.supervisors, + "named_users": s.named_users, + "annual_cost": s.named_users + * per_user_monthly_rate + * MONTHS_PER_YEAR + * factor, + } + for s in sites + ] + return pd.DataFrame(rows) + + +def calculate_per_user_ai_cost( + sites: list[SiteInput], + feature_scope: FeatureScope, + meter: TokenMeter, + pricing: dict[str, TokenPricing], + year: int = 1, + use_contracted: bool = False, + rollout: RolloutPlan | None = None, +) -> pd.DataFrame: + """Per-user-per-month AI features (STA, Agent Copilot, AI Translate, + Email Auto-Suggest). + + No adoption ramp and no rounding (users × tokens/user/month is + exact) — but token usage only starts at site go-live, so the year + bills for the months the site is live (``rollout``). + Returns DataFrame: site, users_in_scope, tokens_monthly, annual_cost. + """ + if meter.meter_type is not MeterType.PER_USER_PER_MONTH: + raise ValueError(f"{meter.feature} is not a per-user meter") + ro = rollout or NO_ROLLOUT + rows = [] + for s in sites: + in_scope = feature_scope.active(s.site_name, year) + users = s.named_users if in_scope else 0 + live_months = ro.live_months_in_year(s.site_name, year) + tokens_monthly = users * meter.tokens_per_unit + rows.append( + { + "site": s.site_name, + "users_in_scope": users, + "tokens_monthly": tokens_monthly, + "annual_cost": tokens_monthly + * live_months + * _rate(s, pricing, use_contracted), + } + ) + return pd.DataFrame(rows) + + +def _monthly_units(site: SiteInput, feature: str, scope: FeatureScope, + scenario: Scenario) -> float: + """Monthly metered units for a consumption feature at one site. + + Explicit ``scope.deflection_target`` / ``scope.eligibility_pct`` + override the scenario defaults. + """ + if feature == "Voice Bot": + deflection = ( + scope.deflection_target + if scope.deflection_target is not None + else scenario.voice_bot_deflection + ) + return ( + site.voice_volume_monthly * deflection * scenario.voice_bot_avg_minutes + ) # minutes + if feature == "Agentic Virtual Agent": + deflection = ( + scope.deflection_target + if scope.deflection_target is not None + else scenario.agentic_va_deflection + ) + return site.voice_volume_monthly * deflection # interactions + if feature == "Virtual Agent (legacy)": + deflection = scope.deflection_target or 0.0 + return site.voice_volume_monthly * deflection + if feature == "AI Summary & Insights": + eligibility = ( + scope.eligibility_pct + if scope.eligibility_pct is not None + else scenario.voice_summarization_eligibility + ) + return site.voice_volume_monthly * eligibility # summaries + if feature == "Email AI (Auto-Respond)": + rate = ( + scope.deflection_target + if scope.deflection_target is not None + else scenario.email_auto_respond_rate + ) + return site.email_volume_monthly * rate # messages + if feature in ("Direct Messaging", "Social Listening", "Social Responses"): + eligibility = scope.eligibility_pct if scope.eligibility_pct is not None else 1.0 + return (site.chat_volume_monthly + site.sms_volume_monthly) * eligibility + raise KeyError(f"No consumption-volume mapping for feature {feature!r}") + + +def calculate_consumption_ai_cost( + sites: list[SiteInput], + feature_scope: FeatureScope, + meter: TokenMeter, + scenario: str | Scenario, + pricing: dict[str, TokenPricing], + year: int = 1, + use_contracted: bool = False, + excluded_sites: set[str] | None = None, + rollout: RolloutPlan | None = None, +) -> pd.DataFrame: + """Consumption-metered AI features (Voice Bots, Agentic VA, + Supervisor AI Summary, Email Auto-Respond, messaging meters). + + Applies eligibility/deflection from the scenario (or explicit scope + overrides), the adoption ramp, billing-style ``ceil`` rounding on + each site's monthly token total, and — with a ``rollout`` — bills + only the months the site is live (usage starts at go-live). + + ``excluded_sites`` supports the Copilot-covers-Summary rule. + Returns DataFrame: site, eligible_volume, tokens_monthly, annual_cost. + """ + if meter.meter_type is MeterType.PER_USER_PER_MONTH: + raise ValueError(f"{meter.feature} is a per-user meter, not consumption") + sc = get_scenario(scenario) if isinstance(scenario, str) else scenario + excluded = excluded_sites or set() + ro = rollout or NO_ROLLOUT + + # Ramp: an explicit adoption curve wins; otherwise the scenario's + # default consumption realization (Y1 = 70%). This models usage + # maturity; rollout live-months model calendar availability — they + # compound (live 6 months × 70% maturity). + ramp = ( + feature_scope.adoption(year) + if feature_scope.adoption_curve + else sc.cost_realization(year) + ) + + rows = [] + for s in sites: + active = ( + feature_scope.active(s.site_name, year) + and s.site_name not in excluded + ) + units = _monthly_units(s, meter.feature, feature_scope, sc) if active else 0.0 + units *= ramp + live_months = ro.live_months_in_year(s.site_name, year) + # Rule 2: round each site's monthly token total UP (billing). + tokens_monthly = math.ceil(units * meter.tokens_per_unit) if units > 0 else 0 + rows.append( + { + "site": s.site_name, + "eligible_volume": units, + "tokens_monthly": tokens_monthly, + "annual_cost": tokens_monthly + * live_months + * _rate(s, pricing, use_contracted), + } + ) + return pd.DataFrame(rows) + + +def calculate_total_cost( + sites: list[SiteInput], + feature_scopes: list[FeatureScope], + meters: dict[str, TokenMeter], + pricing: dict[str, TokenPricing], + scenario: str | Scenario, + year: int, + platform_rate: float = PLATFORM_RATE_PER_USER_MONTHLY, + use_contracted: bool = False, + include_platform: bool = True, + rollout: RolloutPlan | None = None, +) -> pd.DataFrame: + """All cost lines for one scenario-year. + + Returns DataFrame: cost_line, scope, annual_cost, confidence. + """ + sc = get_scenario(scenario) if isinstance(scenario, str) else scenario + rows: list[dict] = [] + + if include_platform: + platform = calculate_platform_license_cost( + sites, platform_rate, year=year, rollout=rollout + ) + ramped = rollout is not None and rollout.platform_factor(year) < 1.0 + rows.append( + { + "cost_line": "Genesys CX 3 platform licences" + + (" (ramp credit applied)" if ramped else ""), + "scope": "all sites", + "annual_cost": float(platform["annual_cost"].sum()), + "confidence": Confidence.CONFIRMED.value, + } + ) + + # Rule 1: Agent Copilot covers Supervisor AI Summary. Sites where + # Copilot is active this year are excluded from AI Summary billing — + # Copilot's 40 tokens/user/month already includes summarization. + # https://help.mypurecloud.com/articles/genesys-cloud-ai-experience-tokens-faqs/ + copilot_sites: set[str] = set() + for scope in feature_scopes: + if scope.feature == "Agent Copilot": + copilot_sites |= { + s.site_name for s in sites if scope.active(s.site_name, year) + } + + for scope in feature_scopes: + meter = meters.get(scope.feature) + if meter is None: + raise KeyError(f"No meter defined for feature {scope.feature!r}") + if meter.meter_type is MeterType.PER_USER_PER_MONTH: + df = calculate_per_user_ai_cost( + sites, scope, meter, pricing, year=year, + use_contracted=use_contracted, rollout=rollout, + ) + in_scope = df[df["users_in_scope"] > 0]["site"].tolist() + else: + excluded = ( + copilot_sites if scope.feature == "AI Summary & Insights" else None + ) + df = calculate_consumption_ai_cost( + sites, scope, meter, sc, pricing, year=year, + use_contracted=use_contracted, excluded_sites=excluded, + rollout=rollout, + ) + in_scope = df[df["annual_cost"] > 0]["site"].tolist() + rows.append( + { + "cost_line": scope.feature, + "scope": ", ".join(in_scope) if in_scope else "—", + "annual_cost": float(df["annual_cost"].sum()), + "confidence": meter.confidence.value, + } + ) + + return pd.DataFrame(rows) diff --git a/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/defaults.py b/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/defaults.py new file mode 100644 index 0000000..76bfdb5 --- /dev/null +++ b/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/defaults.py @@ -0,0 +1,356 @@ +""" +CTM default inputs and the Genesys meter catalogue. + +⚠️ Site volumes/AHTs/costs outside NAM are PLACEHOLDERS flagged +ESTIMATED — confirm with CTM data before client use. NAM volumes are +from the CTM discovery pack. Named users across all sites total the +contracted licence count (2,088). +""" + +from __future__ import annotations + +from .inputs import CostTakeout, FeatureScope, SiteInput +from .meters import Confidence, MeterType, TokenMeter, TokenPricing +from .rollout import RolloutPlan + +# ── Platform ───────────────────────────────────────────────────────── + +#: Genesys Cloud CX 3 named-user list rate, USD/user/month. +#: Source: Genesys Cloud public pricing (CX 3 tier), planning figure. +PLATFORM_RATE_PER_USER_MONTHLY = 111.28 + +#: CTM contracted named-user count — UI warns when site totals diverge. +CONTRACTED_NAMED_USERS = 2_088 + +#: Business-case discount rate (CTM treasury planning assumption). +DEFAULT_DISCOUNT_RATE = 0.08 + +#: One-off implementation estimate, amortized straight-line over the +#: analysis horizon in the P&L. ESTIMATED — confirm with delivery team. +DEFAULT_IMPLEMENTATION_COST = 0.0 + +_GENESYS_TOKEN_FAQ = ( + "https://help.mypurecloud.com/articles/genesys-cloud-ai-experience-tokens-faqs/" +) + +# ── Token meters ───────────────────────────────────────────────────── +# Rates per the published Genesys AI Experience token tables unless +# flagged otherwise. UNKNOWN meters carry working defaults (clearly +# labelled) so the model still produces a range. + +DEFAULT_METERS: dict[str, TokenMeter] = { + m.feature: m + for m in [ + TokenMeter( + feature="Voice Bot", + meter_type=MeterType.PER_MINUTE, + units_per_token=17.0, + tokens_per_unit=1 / 17, # 0.0588 + confidence=Confidence.CONFIRMED, + notes="IVR self-service voice bot minutes; 17 min per token.", + source_url=_GENESYS_TOKEN_FAQ, + ), + TokenMeter( + feature="Virtual Agent (legacy)", + meter_type=MeterType.PER_INTERACTION, + units_per_token=2.0, + tokens_per_unit=0.5, + confidence=Confidence.CONFIRMED, + notes="Legacy (non-agentic) virtual agent; 2 interactions per token.", + source_url=_GENESYS_TOKEN_FAQ, + ), + TokenMeter( + feature="Agentic Virtual Agent", + meter_type=MeterType.PER_INTERACTION, + units_per_token=0.833, + tokens_per_unit=1.2, + confidence=Confidence.CONFIRMED, + notes="Agentic VA; 1.2 tokens per interaction.", + source_url=_GENESYS_TOKEN_FAQ, + ), + TokenMeter( + feature="AI Summary & Insights", + meter_type=MeterType.PER_SUMMARY, + units_per_token=50.0, + tokens_per_unit=0.02, + confidence=Confidence.CONFIRMED, + notes=( + "Supervisor standalone summarization; 50 summaries per token. " + "NOT metered where Agent Copilot is assigned — see cost model." + ), + source_url=_GENESYS_TOKEN_FAQ, + ), + TokenMeter( + feature="Direct Messaging", + meter_type=MeterType.PER_MESSAGE, + units_per_token=400.0, + tokens_per_unit=0.0025, + confidence=Confidence.CONFIRMED, + notes="FB/IG/WhatsApp messages; 400 messages per token.", + source_url=_GENESYS_TOKEN_FAQ, + ), + TokenMeter( + feature="Social Listening", + meter_type=MeterType.PER_MESSAGE, + units_per_token=400.0, + tokens_per_unit=0.0025, + confidence=Confidence.CONFIRMED, + notes="400 messages per token.", + source_url=_GENESYS_TOKEN_FAQ, + ), + TokenMeter( + feature="Social Responses", + meter_type=MeterType.PER_MESSAGE, + units_per_token=400.0, + tokens_per_unit=0.0025, + confidence=Confidence.CONFIRMED, + notes="400 messages per token.", + source_url=_GENESYS_TOKEN_FAQ, + ), + TokenMeter( + feature="Speech & Text Analytics", + meter_type=MeterType.PER_USER_PER_MONTH, + units_per_token=0.0, # n/a for per-user meters + tokens_per_unit=30.0, + confidence=Confidence.CONFIRMED, + notes="STA: 30 tokens per named user per month.", + source_url=_GENESYS_TOKEN_FAQ, + ), + TokenMeter( + feature="Agent Copilot", + meter_type=MeterType.PER_USER_PER_MONTH, + units_per_token=0.0, + tokens_per_unit=40.0, + confidence=Confidence.CONFIRMED, + notes=( + "40 tokens per named user per month. Includes interaction " + "summarization (covers AI Summary & Insights)." + ), + source_url=_GENESYS_TOKEN_FAQ, + ), + TokenMeter( + feature="Email AI (Auto-Suggest)", + meter_type=MeterType.PER_USER_PER_MONTH, + units_per_token=0.0, + tokens_per_unit=30.0, # TBD — working default + confidence=Confidence.UNKNOWN, + notes="Rate not yet sourced. Working default 30 tokens/user/month.", + ), + TokenMeter( + feature="Email AI (Auto-Respond)", + meter_type=MeterType.PER_MESSAGE, + units_per_token=2.0, # TBD + tokens_per_unit=0.5, # TBD — working default + confidence=Confidence.UNKNOWN, + notes="Rate not yet sourced. Working default 0.5 tokens/message.", + ), + TokenMeter( + feature="AI Translate", + meter_type=MeterType.PER_USER_PER_MONTH, + units_per_token=0.0, + tokens_per_unit=20.0, # TBD — working default + confidence=Confidence.UNKNOWN, + notes="Rate not yet sourced. Working default 20 tokens/user/month.", + ), + ] +} + +#: Features metered per named user per month. +PER_USER_FEATURES = [ + f for f, m in DEFAULT_METERS.items() + if m.meter_type is MeterType.PER_USER_PER_MONTH +] + +# ── Token pricing ──────────────────────────────────────────────────── +# $1/token US list confirmed; other regions default to the same list +# rate until regional figures are sourced (override in UI). + +DEFAULT_PRICING: dict[str, TokenPricing] = { + "US": TokenPricing(region="US", list_rate_per_token=1.0), + "EU": TokenPricing(region="EU", list_rate_per_token=1.0), # TBD — assumed US list + "AU": TokenPricing(region="AU", list_rate_per_token=1.0), # TBD — assumed US list + "APAC": TokenPricing(region="APAC", list_rate_per_token=1.0), # TBD +} + +# ── CTM sites ──────────────────────────────────────────────────────── +# NAM figures from CTM discovery. ALL OTHER SITES + every AHT/ACW and +# labour-cost figure are ESTIMATED placeholders — confirm with CTM. +# Named users sum to CONTRACTED_NAMED_USERS (2,088). + +_COMMON = { + "voice_aht_seconds": 300, # placeholder — flag as estimate + "email_aht_seconds": 600, + "chat_aht_seconds": 480, + "voice_acw_seconds": 60, +} + +CTM_DEFAULT_SITES: list[SiteInput] = [ + SiteInput( + "NAM", "US", agents=890, supervisors=60, # split TBD + voice_volume_monthly=1_214_358, + email_volume_monthly=275_800, + chat_volume_monthly=110, + sms_volume_monthly=1_040, + fully_loaded_agent_cost_annual=65_000, # placeholder + fully_loaded_supervisor_cost_annual=95_000, + languages=["English", "French", "Spanish"], + **_COMMON, + ), + SiteInput( + "EMEA", "EU", agents=320, supervisors=25, + voice_volume_monthly=420_000, + email_volume_monthly=95_000, + chat_volume_monthly=40, + sms_volume_monthly=400, + fully_loaded_agent_cost_annual=60_000, + fully_loaded_supervisor_cost_annual=88_000, + languages=["English", "French", "German", "Italian", "Spanish"], + **_COMMON, + ), + SiteInput( + "AUZ", "AU", agents=180, supervisors=15, + voice_volume_monthly=250_000, + email_volume_monthly=56_000, + chat_volume_monthly=25, + sms_volume_monthly=250, + fully_loaded_agent_cost_annual=70_000, + fully_loaded_supervisor_cost_annual=100_000, + languages=["English"], + **_COMMON, + ), + SiteInput( + "APAC HK", "APAC", agents=120, supervisors=10, + voice_volume_monthly=160_000, + email_volume_monthly=38_000, + chat_volume_monthly=15, + sms_volume_monthly=150, + fully_loaded_agent_cost_annual=55_000, + fully_loaded_supervisor_cost_annual=80_000, + languages=["English", "Cantonese", "Mandarin"], + **_COMMON, + ), + SiteInput( + "APAC SG", "APAC", agents=110, supervisors=10, + voice_volume_monthly=150_000, + email_volume_monthly=34_000, + chat_volume_monthly=15, + sms_volume_monthly=120, + fully_loaded_agent_cost_annual=55_000, + fully_loaded_supervisor_cost_annual=80_000, + languages=["English", "Mandarin", "Malay"], + **_COMMON, + ), + SiteInput( + "APAC SH", "APAC", agents=130, supervisors=10, + voice_volume_monthly=175_000, + email_volume_monthly=40_000, + chat_volume_monthly=15, + sms_volume_monthly=130, + fully_loaded_agent_cost_annual=35_000, + fully_loaded_supervisor_cost_annual=55_000, + languages=["Mandarin"], + **_COMMON, + ), + SiteInput( + "APAC GZ", "APAC", agents=90, supervisors=8, + voice_volume_monthly=120_000, + email_volume_monthly=28_000, + chat_volume_monthly=10, + sms_volume_monthly=100, + fully_loaded_agent_cost_annual=35_000, + fully_loaded_supervisor_cost_annual=55_000, + languages=["Mandarin", "Cantonese"], + **_COMMON, + ), + SiteInput( + "APAC JP", "APAC", agents=60, supervisors=6, + voice_volume_monthly=80_000, + email_volume_monthly=19_000, + chat_volume_monthly=8, + sms_volume_monthly=80, + fully_loaded_agent_cost_annual=60_000, + fully_loaded_supervisor_cost_annual=85_000, + languages=["Japanese"], + **_COMMON, + ), + SiteInput( + "APAC TW", "APAC", agents=40, supervisors=4, + voice_volume_monthly=54_000, + email_volume_monthly=12_000, + chat_volume_monthly=5, + sms_volume_monthly=50, + fully_loaded_agent_cost_annual=40_000, + fully_loaded_supervisor_cost_annual=60_000, + languages=["Mandarin"], + **_COMMON, + ), +] + +ALL_SITE_NAMES = [s.site_name for s in CTM_DEFAULT_SITES] + +# ── Cost takeouts ──────────────────────────────────────────────────── + +CTM_DEFAULT_TAKEOUTS: list[CostTakeout] = [ + CostTakeout( + "NICE IEX (NAM)", + annual_cost=1_300_000, + start_year=1, + start_month=7, # can only switch off after NAM go-live (month 6) + confidence=Confidence.ESTIMATED, + notes="Mid-band estimate; needs CTM contract confirmation.", + ), + CostTakeout( + "Legacy CC platform", + annual_cost=0, + start_year=2, + confidence=Confidence.UNKNOWN, + notes="Placeholder — populate once retirement scope is confirmed.", + ), +] + +# ── Default rollout & ramp ─────────────────────────────────────────── +# 12-month build. Genesys bills the licence commit from contract start; +# the 6-month ramp gives a 50% first-year credit on the platform commit. +# AI token usage (and benefits) start only when each region goes live. + +CTM_DEFAULT_ROLLOUT = RolloutPlan( + contract_start=None, # set when known — "Date Genesys starts billing" + build_months=12, + ramp_months=6, + first_year_platform_discount=0.50, + go_live_month={ + "NAM": 6, + "EMEA": 9, + "AUZ": 12, + "APAC HK": 12, + "APAC SG": 12, + "APAC SH": 12, + "APAC GZ": 12, + "APAC JP": 12, + "APAC TW": 12, + }, +) + +# ── Default feature scoping / phasing ──────────────────────────────── +# Phase = model year the feature switches on. Consumption features ramp +# via adoption_curve; per-user licences are paid in full from the phase +# year. + +_RAMP = {1: 0.70, 2: 1.0, 3: 1.0} + +CTM_DEFAULT_FEATURE_SCOPES: list[FeatureScope] = [ + FeatureScope("Voice Bot", ALL_SITE_NAMES, phase=1, adoption_curve=_RAMP), + FeatureScope("Agentic Virtual Agent", ["NAM", "EMEA"], phase=2, + adoption_curve={2: 0.70, 3: 1.0}), + FeatureScope("Speech & Text Analytics", ALL_SITE_NAMES, phase=1), + FeatureScope("Agent Copilot", ALL_SITE_NAMES, phase=1), + FeatureScope("AI Summary & Insights", ALL_SITE_NAMES, phase=1, + adoption_curve=_RAMP), + FeatureScope("Direct Messaging", ALL_SITE_NAMES, phase=1, adoption_curve=_RAMP), + FeatureScope("Email AI (Auto-Suggest)", ["NAM", "EMEA"], phase=2), + FeatureScope("Email AI (Auto-Respond)", ["NAM", "EMEA"], phase=2, + adoption_curve={2: 0.70, 3: 1.0}), + FeatureScope("AI Translate", + ["APAC HK", "APAC SG", "APAC SH", "APAC GZ", "APAC JP", "APAC TW"], + phase=3), +] diff --git a/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/exports.py b/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/exports.py new file mode 100644 index 0000000..2b899b1 --- /dev/null +++ b/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/exports.py @@ -0,0 +1,131 @@ +""" +Excel / CSV / JSON export. + +Excel uses openpyxl via pandas — multi-sheet workbooks readable in +Excel 2019+. JSON round-trips the full input state (sites, takeouts, +feature scopes) so a scenario can be saved and reloaded. +""" + +from __future__ import annotations + +import dataclasses +import json +from pathlib import Path + +import pandas as pd + +from .inputs import CostTakeout, FeatureScope, SiteInput +from .meters import Confidence, TokenMeter +from .rollout import RolloutPlan + + +def meters_dataframe(meters: dict[str, TokenMeter]) -> pd.DataFrame: + """Meter catalogue as a display/export-ready DataFrame.""" + return pd.DataFrame( + [ + { + "feature": m.feature, + "meter_type": m.meter_type.value, + "units_per_token": m.units_per_token or None, + "tokens_per_unit": m.tokens_per_unit, + "confidence": f"{m.confidence.icon} {m.confidence.value}", + "notes": m.notes, + "source": m.source_url or "", + } + for m in meters.values() + ] + ) + + +def sites_dataframe(sites: list[SiteInput]) -> pd.DataFrame: + rows = [] + for s in sites: + d = dataclasses.asdict(s) + d["languages"] = ", ".join(d["languages"]) + rows.append(d) + return pd.DataFrame(rows) + + +def export_excel( + sheets: dict[str, pd.DataFrame], + path: str | Path, +) -> Path: + """Write a multi-sheet Excel workbook. Sheet names are truncated to + Excel's 31-character limit.""" + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + with pd.ExcelWriter(path, engine="openpyxl") as writer: + for name, df in sheets.items(): + df.to_excel(writer, sheet_name=name[:31], index=False) + return path + + +def export_csv(df: pd.DataFrame, path: str | Path) -> Path: + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + df.to_csv(path, index=False) + return path + + +# ── JSON scenario save / load ──────────────────────────────────────── + +def scenario_state_to_json( + sites: list[SiteInput], + takeouts: list[CostTakeout], + feature_scopes: list[FeatureScope], + path: str | Path | None = None, + rollout: RolloutPlan | None = None, +) -> str: + """Serialize the full input state; optionally write to ``path``.""" + state = { + "sites": [dataclasses.asdict(s) for s in sites], + "takeouts": [ + {**dataclasses.asdict(t), "confidence": t.confidence.value} + for t in takeouts + ], + "feature_scopes": [ + { + **dataclasses.asdict(f), + "adoption_curve": {str(k): v for k, v in f.adoption_curve.items()}, + } + for f in feature_scopes + ], + } + if rollout is not None: + state["rollout"] = dataclasses.asdict(rollout) + text = json.dumps(state, indent=2) + if path is not None: + Path(path).write_text(text) + return text + + +def scenario_state_from_json( + source: str | Path, +) -> tuple[list[SiteInput], list[CostTakeout], list[FeatureScope], RolloutPlan | None]: + """Inverse of :func:`scenario_state_to_json`. ``source`` is a JSON + string or a file path. The fourth element is None for legacy files + saved without a rollout plan.""" + raw = ( + Path(source).read_text() + if isinstance(source, Path) or (isinstance(source, str) and source.strip().endswith(".json")) + else str(source) + ) + state = json.loads(raw) + sites = [SiteInput(**s) for s in state["sites"]] + takeouts = [ + CostTakeout(**{**t, "confidence": Confidence(t["confidence"])}) + for t in state["takeouts"] + ] + scopes = [ + FeatureScope( + **{ + **f, + "adoption_curve": {int(k): v for k, v in f["adoption_curve"].items()}, + } + ) + for f in state["feature_scopes"] + ] + rollout = ( + RolloutPlan(**state["rollout"]) if "rollout" in state else None + ) + return sites, takeouts, scopes, rollout diff --git a/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/inputs.py b/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/inputs.py new file mode 100644 index 0000000..4c3d34b --- /dev/null +++ b/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/inputs.py @@ -0,0 +1,149 @@ +""" +Input bundles — validated dataclasses, no untyped dicts. + +All volumes are MONTHLY; all AHT/ACW figures are SECONDS; all labour +costs are ANNUAL fully-loaded USD. +""" + +from __future__ import annotations + +from dataclasses import dataclass, field + +from .meters import Confidence + +#: Sanity bounds for handle times (seconds). +AHT_MIN_SECONDS = 10 +AHT_MAX_SECONDS = 3600 + +#: Working hours per FTE-year used to derive per-second labour rates. +WORKING_HOURS_PER_YEAR = 2_080 +WORKING_SECONDS_PER_YEAR = WORKING_HOURS_PER_YEAR * 3600 + + +@dataclass +class SiteInput: + site_name: str # "NAM", "EMEA", "AUZ", "APAC HK", … + region_pricing: str # "US", "AU", "EU", "APAC" + agents: int # excluding supervisors + supervisors: int + voice_volume_monthly: int + email_volume_monthly: int + chat_volume_monthly: int + sms_volume_monthly: int + voice_aht_seconds: int + email_aht_seconds: int + chat_aht_seconds: int + voice_acw_seconds: int + fully_loaded_agent_cost_annual: float + fully_loaded_supervisor_cost_annual: float + languages: list[str] = field(default_factory=list) + + def __post_init__(self) -> None: + if self.agents < 0 or self.supervisors < 0: + raise ValueError(f"{self.site_name}: agent/supervisor counts must be >= 0") + for name in ( + "voice_volume_monthly", + "email_volume_monthly", + "chat_volume_monthly", + "sms_volume_monthly", + ): + if getattr(self, name) < 0: + raise ValueError(f"{self.site_name}: {name} must be >= 0") + for name in ("voice_aht_seconds", "email_aht_seconds", "chat_aht_seconds"): + v = getattr(self, name) + if v and not AHT_MIN_SECONDS <= v <= AHT_MAX_SECONDS: + raise ValueError( + f"{self.site_name}: {name}={v}s outside sensible bounds " + f"({AHT_MIN_SECONDS}-{AHT_MAX_SECONDS}s)" + ) + if self.voice_acw_seconds < 0: + raise ValueError(f"{self.site_name}: voice_acw_seconds must be >= 0") + + @property + def named_users(self) -> int: + return self.agents + self.supervisors + + @property + def agent_cost_per_second(self) -> float: + """Fully-loaded agent labour rate per working second (DBZ-safe).""" + return self.fully_loaded_agent_cost_annual / WORKING_SECONDS_PER_YEAR + + @property + def supervisor_cost_per_second(self) -> float: + return self.fully_loaded_supervisor_cost_annual / WORKING_SECONDS_PER_YEAR + + +@dataclass +class FeatureScope: + """Which feature is enabled at which sites, in which phase. + + ``phase`` is the model year (1-3) the feature switches on; + ``adoption_curve`` maps model year -> adoption fraction (0.0-1.0) + applied to consumption-metered features (per-user licenses are paid + in full from the phase year onward). + """ + + feature: str + enabled_sites: list[str] + phase: int = 1 + adoption_curve: dict[int, float] = field(default_factory=dict) + deflection_target: float | None = None + eligibility_pct: float | None = None + + def __post_init__(self) -> None: + if self.phase < 1: + raise ValueError(f"{self.feature}: phase must be >= 1") + for year, pct in self.adoption_curve.items(): + if not 0.0 <= pct <= 1.0: + raise ValueError( + f"{self.feature}: adoption_curve[{year}]={pct} outside 0-1" + ) + for name in ("deflection_target", "eligibility_pct"): + v = getattr(self, name) + if v is not None and not 0.0 <= v <= 1.0: + raise ValueError(f"{self.feature}: {name}={v} outside 0-1") + + def active(self, site_name: str, year: int) -> bool: + return site_name in self.enabled_sites and year >= self.phase + + def adoption(self, year: int) -> float: + """Adoption fraction for ``year`` (1.0 when no curve given).""" + if not self.adoption_curve: + return 1.0 + if year in self.adoption_curve: + return self.adoption_curve[year] + # Past the last defined year → hold the last value. + last = max(self.adoption_curve) + return self.adoption_curve[last] if year > last else 0.0 + + +@dataclass +class CostTakeout: + """A retired platform/licence whose cost the programme reclaims. + + ``start_month`` (1-12, within ``start_year``) prorates the first + active year — e.g. NICE IEX can only be switched off once NAM is + live, so start_year=1, start_month=7 reclaims 6/12 of Y1. + """ + + name: str # "NICE IEX (NAM)", "Legacy CC platform", … + annual_cost: float + start_year: int = 1 + confidence: Confidence = Confidence.ESTIMATED + notes: str = "" + start_month: int = 1 + + def __post_init__(self) -> None: + if self.annual_cost < 0: + raise ValueError(f"{self.name}: annual_cost must be >= 0") + if self.start_year < 1: + raise ValueError(f"{self.name}: start_year must be >= 1") + if not 1 <= self.start_month <= 12: + raise ValueError(f"{self.name}: start_month must be 1-12") + + def value_in_year(self, year: int) -> float: + if year < self.start_year: + return 0.0 + if year == self.start_year: + return self.annual_cost * (12 - (self.start_month - 1)) / 12 + return self.annual_cost diff --git a/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/meters.py b/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/meters.py new file mode 100644 index 0000000..d1a0755 --- /dev/null +++ b/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/meters.py @@ -0,0 +1,87 @@ +""" +Genesys AI Experience token meters and pricing. + +Every meter carries a :class:`Confidence` flag so the UI can distinguish +published Genesys rates from estimates and unknowns. Rates here are +*planning inputs* — this tool explicitly does not replace contractual +pricing (see README, Non-Goals). +""" + +from __future__ import annotations + +from dataclasses import dataclass +from enum import Enum + + +class MeterType(Enum): + PER_USER_PER_MONTH = "per_user_per_month" + PER_INTERACTION = "per_interaction" + PER_MINUTE = "per_minute" + PER_MESSAGE = "per_message" + PER_SUMMARY = "per_summary" + + +class Confidence(Enum): + CONFIRMED = "confirmed" # published Genesys rate + ESTIMATED = "estimated" # reasonable industry assumption + UNKNOWN = "unknown" # rate not yet sourced + + @property + def icon(self) -> str: + return {"confirmed": "🟢", "estimated": "🟡", "unknown": "🔴"}[self.value] + + +@dataclass +class TokenMeter: + """One Genesys AI feature's token meter. + + ``units_per_token`` and ``tokens_per_unit`` are inverses; both are + stored because the UI shows whichever reads more naturally (e.g. + "17 minutes per token" vs "0.0588 tokens per minute"). For + PER_USER_PER_MONTH meters ``units_per_token`` is 0.0 (n/a) and + ``tokens_per_unit`` is the flat tokens/user/month figure. + """ + + feature: str + meter_type: MeterType + units_per_token: float + tokens_per_unit: float + confidence: Confidence + notes: str + source_url: str | None = None + + def __post_init__(self) -> None: + if self.tokens_per_unit < 0: + raise ValueError(f"{self.feature}: tokens_per_unit must be >= 0") + if ( + self.meter_type is not MeterType.PER_USER_PER_MONTH + and self.units_per_token > 0 + and self.tokens_per_unit > 0 + ): + product = self.units_per_token * self.tokens_per_unit + if not 0.95 <= product <= 1.05: + raise ValueError( + f"{self.feature}: units_per_token ({self.units_per_token}) and " + f"tokens_per_unit ({self.tokens_per_unit}) are not inverses" + ) + + +@dataclass +class TokenPricing: + """Per-region token pricing. Default is US list at $1/token.""" + + region: str # "US", "AU", "EU", "APAC" + list_rate_per_token: float = 1.0 + contracted_rate_per_token: float | None = None + prepay_commit_tokens: int | None = None + overage_rate_per_token: float | None = None + + def __post_init__(self) -> None: + if self.list_rate_per_token < 0: + raise ValueError(f"{self.region}: list rate must be >= 0") + + def effective_rate(self, use_contracted: bool = False) -> float: + """Contracted rate when requested and known, else list rate.""" + if use_contracted and self.contracted_rate_per_token is not None: + return self.contracted_rate_per_token + return self.list_rate_per_token diff --git a/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/rollout.py b/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/rollout.py new file mode 100644 index 0000000..d5609d1 --- /dev/null +++ b/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/rollout.py @@ -0,0 +1,81 @@ +""" +Implementation rollout & ramp model. + +Captures the gap between **when Genesys starts billing** (contract +start) and **when each region actually goes live**: + +- The platform licence commit bills in full from contract start; the + vendor's *ramp period* compensates with a first-year credit + (typical: 6-month ramp → 50% Y1 discount on the platform commit). +- AI token usage (per-user and consumption meters) starts only when a + site goes live, and bills for the months the site is live in each + model year. +- Benefits likewise accrue only from go-live (the scenario realization + curve then models adoption maturity *within* the live period). + +A site with ``go_live_month = m`` is live for ``12*year − m`` months of +the first ``year`` years (clamped to 0..12 per year). So NAM at month 6 +is live 6 months of Y1; EMEA at month 9 → 3 months; AUZ/APAC at month +12 → 0 months in Y1 and fully live from Y2. +""" + +from __future__ import annotations + +from dataclasses import dataclass, field + +MONTHS_PER_YEAR = 12 + + +@dataclass +class RolloutPlan: + #: ISO date Genesys starts billing the licence commit (informational, + #: surfaced in UI/exports; the model works in months-from-start). + contract_start: str | None = None + + #: Total build duration, months (informational). + build_months: int = 12 + + #: Vendor ramp period, months. Documentation for the Y1 credit below. + ramp_months: int = 6 + + #: First-year credit on the platform licence commit. Typical + #: 6-month ramp = 50% discount in year 1; years 2+ bill in full. + first_year_platform_discount: float = 0.5 + + #: site_name -> go-live month (months after contract start). + #: Sites absent from the map are treated as live from day 0. + go_live_month: dict[str, int] = field(default_factory=dict) + + def __post_init__(self) -> None: + if not 0.0 <= self.first_year_platform_discount <= 1.0: + raise ValueError("first_year_platform_discount must be within 0-1") + if self.ramp_months < 0 or self.build_months < 0: + raise ValueError("ramp_months/build_months must be >= 0") + for site, m in self.go_live_month.items(): + if m < 0: + raise ValueError(f"{site}: go_live_month must be >= 0") + + # ── Availability ──────────────────────────────────────────────── + + def live_months_in_year(self, site_name: str, year: int) -> int: + """Months ``site_name`` is live during model year ``year`` (1-based).""" + go_live = self.go_live_month.get(site_name, 0) + live_by_year_end = max(0, MONTHS_PER_YEAR * year - go_live) + live_by_prev_year_end = max(0, MONTHS_PER_YEAR * (year - 1) - go_live) + return min(MONTHS_PER_YEAR, live_by_year_end - live_by_prev_year_end) + + def fraction_live(self, site_name: str, year: int) -> float: + return self.live_months_in_year(site_name, year) / MONTHS_PER_YEAR + + # ── Billing ───────────────────────────────────────────────────── + + def platform_factor(self, year: int) -> float: + """Fraction of the full platform commit billed in ``year``.""" + return 1.0 - self.first_year_platform_discount if year == 1 else 1.0 + + +#: Behaviour identical to the pre-rollout model: everything live from +#: day 0, no ramp credit. +NO_ROLLOUT = RolloutPlan( + build_months=0, ramp_months=0, first_year_platform_discount=0.0 +) diff --git a/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/scenarios.py b/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/scenarios.py new file mode 100644 index 0000000..91e5162 --- /dev/null +++ b/studies/202512_GenesysCX/ctm-token-calculator/tokencalc/scenarios.py @@ -0,0 +1,112 @@ +""" +Scenario definitions — Floor / Realistic / Stretch. + +Every scenario parameter the cost and benefit engines read lives here; +no magic numbers in the calculation modules. Ships with the spec +defaults; callers may construct custom :class:`Scenario` objects. +""" + +from __future__ import annotations + +from dataclasses import dataclass, field + + +@dataclass +class Scenario: + name: str + + # ── Cost-side drivers ─────────────────────────────────────────── + voice_bot_deflection: float # share of voice volume deflected to bot + voice_bot_avg_minutes: float # bot minutes per deflected call + agentic_va_deflection: float # share of voice volume to agentic VA + voice_summarization_eligibility: float + voice_knowledge_eligibility: float + email_auto_respond_rate: float # share of email auto-responded + email_auto_suggest_acceptance: float + + # year -> fraction of full benefit realized + benefit_realization: dict[int, float] = field(default_factory=dict) + + # year -> fraction of steady-state consumption cost incurred. + # Per-user licenses are paid in full from day 1; consumption meters + # ramp with usage (default Y1 = 70%). + consumption_cost_realization: dict[int, float] = field( + default_factory=lambda: {1: 0.70, 2: 1.0, 3: 1.0} + ) + + def realization(self, year: int) -> float: + if year in self.benefit_realization: + return self.benefit_realization[year] + last = max(self.benefit_realization, default=0) + return self.benefit_realization.get(last, 1.0) if year > last else 0.0 + + def cost_realization(self, year: int) -> float: + if year in self.consumption_cost_realization: + return self.consumption_cost_realization[year] + last = max(self.consumption_cost_realization, default=0) + return ( + self.consumption_cost_realization.get(last, 1.0) if year > last else 0.0 + ) + + +#: Benefit reduction parameters. ``claim`` = Genesys ROI-doc figure; +#: ``realistic`` = pressure-tested midpoint of the spec's Y1 range. +#: The benefit engine uses ``realistic`` by default; ``claim`` powers +#: the side-by-side comparison view. +BENEFIT_PARAMS: dict[str, dict[str, float]] = { + "voice_aht_knowledge_reduction": {"claim": 0.094, "realistic": 0.055}, # 4-7% Y1 + "voice_acw_reduction": {"claim": 1.00, "realistic": 0.40}, # 30-50% Y1 + "digital_aht_reduction": {"claim": 0.18, "realistic": 0.085}, # 5-12% Y1 + "digital_acw_reduction": {"claim": 1.00, "realistic": 0.40}, # 30-50% Y1 + "sta_aht_reduction": {"claim": 0.04, "realistic": 0.015}, # 1-2% Y1 + "email_auto_suggest_time_saving": {"claim": 0.30, "realistic": 0.30}, # × acceptance + # ESTIMATED lines (no Genesys claim published): + "supervisor_copilot_time_saving": {"claim": 0.10, "realistic": 0.05}, + "predictive_routing_aht_reduction": {"claim": 0.04, "realistic": 0.02}, +} + + +SCENARIOS: dict[str, Scenario] = { + "floor": Scenario( + name="floor", + voice_bot_deflection=0.20, + voice_bot_avg_minutes=1.0, + agentic_va_deflection=0.05, + voice_summarization_eligibility=0.50, + voice_knowledge_eligibility=0.40, + email_auto_respond_rate=0.10, + email_auto_suggest_acceptance=0.25, + benefit_realization={1: 0.30, 2: 0.60, 3: 0.80}, + ), + "realistic": Scenario( + name="realistic", + voice_bot_deflection=0.35, + voice_bot_avg_minutes=1.5, + agentic_va_deflection=0.15, + voice_summarization_eligibility=0.70, + voice_knowledge_eligibility=0.60, + email_auto_respond_rate=0.20, + email_auto_suggest_acceptance=0.40, + benefit_realization={1: 0.50, 2: 0.80, 3: 0.95}, + ), + "stretch": Scenario( + name="stretch", + voice_bot_deflection=0.50, + voice_bot_avg_minutes=2.0, + agentic_va_deflection=0.25, + voice_summarization_eligibility=0.90, + voice_knowledge_eligibility=0.80, + email_auto_respond_rate=0.50, + email_auto_suggest_acceptance=0.60, + benefit_realization={1: 0.75, 2: 0.95, 3: 1.00}, + ), +} + + +def get_scenario(name: str) -> Scenario: + try: + return SCENARIOS[name.lower()] + except KeyError as e: + raise KeyError( + f"Unknown scenario {name!r}. Valid: {sorted(SCENARIOS)}" + ) from e diff --git a/studies/202512_GenesysCX/exports/.gitkeep b/studies/202512_GenesysCX/exports/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/studies/202512_GenesysCX/notebooks/00_provision.ipynb b/studies/202512_GenesysCX/notebooks/00_provision.ipynb new file mode 100644 index 0000000..8737b8b --- /dev/null +++ b/studies/202512_GenesysCX/notebooks/00_provision.ipynb @@ -0,0 +1,929 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "41520e77", + "metadata": {}, + "source": [ + "# 00 · Provision — Genesys CX Cloud TEI in Athena\n", + "\n", + "Source study: Forrester, *The Total Economic Impact™ Of CX Cloud* (Genesys +\n", + "Salesforce, December 2025). Published headline: **NPV \\$10.78M · ROI 266%**.\n", + "\n", + "This notebook creates everything the study needs in the Athena sandbox:\n", + "\n", + "1. **Report template** *CX Cloud (Genesys + Salesforce) 2025* + **field definitions** — 4 benefits, 3 published costs, **plus the `genesys_ai_tokens` consumption line the published study omits**\n", + "2. **Client selection** from the CRM (profile pulled, no re-entry)\n", + "3. **Attachment** to a Proposal or Engagement\n", + "4. **Seed values** + server-side **calculation**\n", + "5. **Two-tier verification**: exact match vs Athena-methodology expectations, then reconciliation to the published totals (explained Year-0 discounting delta)\n", + "6. Persists study-scoped IDs (`PALLADIUM_GENESYSCX_*`) to `.env`\n", + "\n", + "Safe to re-run — every step finds existing objects before creating new ones." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "1b6f1117", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Athena connected — https://athena.ouranos.helu.ca (1 report templates visible)\n", + "📁 Study: 202512_GenesysCX\n" + ] + } + ], + "source": [ + "import sys, pathlib # path shim: works on a fresh kernel\n", + "for _p in [pathlib.Path.cwd(), *pathlib.Path.cwd().parents]:\n", + " if (_p / \"pyproject.toml\").exists():\n", + " sys.path.insert(0, str(_p)); break\n", + "\n", + "import pandas as pd\n", + "from core.bootstrap import init, update_env\n", + "\n", + "pal = init(study=\"202512_GenesysCX\")\n", + "client, seed, config = pal.client, pal.seed_data, pal.config\n", + "assert pal.connection.get(\"status\") == \"ok\", \"Fix the connection first → 00_setup.ipynb\"" + ] + }, + { + "cell_type": "markdown", + "id": "c1f8b6bd", + "metadata": {}, + "source": [ + "## 1 · Report template (find or create)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cc81e408", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Created report template UCb2hSJprSBx\n" + ] + } + ], + "source": [ + "REPORT_NAME, VENDOR = \"CX Cloud (Genesys + Salesforce) 2025\", \"Genesys\"\n", + "\n", + "report = next(\n", + " (r for r in client.list_reports()\n", + " if r.get(\"name\") == REPORT_NAME and r.get(\"vendor\") == VENDOR),\n", + " None,\n", + ")\n", + "if report is None:\n", + " report = client.create_report(\n", + " name=REPORT_NAME,\n", + " vendor=VENDOR,\n", + " version=\"1.0\",\n", + " description=(\n", + " \"Forrester TEI of CX Cloud (Genesys + Salesforce), Dec 2025. \"\n", + " \"Includes Palladium's genesys_ai_tokens consumption line, \"\n", + " \"which the published study omits.\"\n", + " ),\n", + " analysis_period_years=seed.ASSUMPTIONS[\"analysis_years\"],\n", + " discount_rate=seed.ASSUMPTIONS[\"discount_rate\"],\n", + " status=\"draft\",\n", + " )\n", + " print(f\"Created report template {report['id']}\")\n", + "else:\n", + " print(f\"Found existing report template {report['id']} (status: {report.get('status')})\")\n", + "\n", + "REPORT_ID = report[\"id\"]" + ] + }, + { + "cell_type": "markdown", + "id": "e31bbd8b", + "metadata": {}, + "source": [ + "## 2 · Field definitions\n", + "\n", + "Same Palladium conventions as the Amazon Connect study: benefit risk\n", + "adjustments live on the field; cost values get pushed pre-multiplied by\n", + "`(1 + risk_adj)`; Year-0 amounts use companion `*_initial` fields.\n", + "The `genesys_ai_tokens` line is seeded \\$0 (reproduces the published study) —\n", + "the annual cost gets entered per deal, from the Genesys quote, in\n", + "`01_business_case.ipynb`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "55e69828", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "12 fields created, 0 already existed.\n", + "Report template activated.\n" + ] + } + ], + "source": [ + "def field_defs():\n", + " defs, sort = [], 0\n", + " for b in seed.BENEFITS:\n", + " sort += 1\n", + " defs.append({\n", + " \"table\": \"benefits\",\n", + " \"field_key\": b[\"field_key\"],\n", + " \"label\": b[\"label\"],\n", + " \"description\": b[\"notes\"][:200],\n", + " \"field_type\": \"currency\",\n", + " \"category\": b[\"category\"],\n", + " \"is_annual\": True,\n", + " \"risk_adjustment\": str(b[\"risk_adjustment\"]),\n", + " \"sort_order\": sort,\n", + " \"is_required\": True,\n", + " \"source_notes\": b[\"notes\"],\n", + " })\n", + " for c in seed.COSTS:\n", + " sort += 1\n", + " defs.append({\n", + " \"table\": \"costs\",\n", + " \"field_key\": c[\"field_key\"],\n", + " \"label\": c[\"label\"],\n", + " \"description\": c[\"notes\"][:200],\n", + " \"field_type\": \"currency\",\n", + " \"category\": c[\"category\"],\n", + " \"is_annual\": True,\n", + " \"risk_adjustment\": \"0\", # cost risk adj applied client-side\n", + " \"sort_order\": sort,\n", + " \"is_required\": False,\n", + " \"source_notes\": c[\"notes\"],\n", + " })\n", + " sort += 1\n", + " defs.append({\n", + " \"table\": \"costs\",\n", + " \"field_key\": f\"{c['field_key']}_initial\",\n", + " \"label\": f\"{c['label']} — initial (Year 0)\",\n", + " \"description\": \"One-time Year-0 amount (companion field).\",\n", + " \"field_type\": \"currency\",\n", + " \"category\": c[\"category\"],\n", + " \"is_annual\": False,\n", + " \"risk_adjustment\": \"0\",\n", + " \"sort_order\": sort,\n", + " \"is_required\": False,\n", + " \"source_notes\": \"Year-0 lump sum; Athena treats non-annual values as Year 1.\",\n", + " })\n", + " return defs\n", + "\n", + "existing = {f[\"field_key\"] for f in client.list_fields(REPORT_ID)}\n", + "created = 0\n", + "for d in field_defs():\n", + " if d[\"field_key\"] not in existing:\n", + " client.create_field(REPORT_ID, d)\n", + " created += 1\n", + "print(f\"{created} fields created, {len(existing)} already existed.\")\n", + "\n", + "if report.get(\"status\") == \"draft\":\n", + " client.update_report(REPORT_ID, status=\"active\")\n", + " print(\"Report template activated.\")" + ] + }, + { + "cell_type": "markdown", + "id": "96b360d3", + "metadata": {}, + "source": [ + "## 3 · Select the client" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5a0a701f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idnameverticalclient_typeemployee_countcontact_center_agent_countsupervisor_count
02Global Guardian InsuranceNoneFor-Profit120002500None
13EudaimonixNoneFor-Profit1500300None
24Aetherium ForgeNoneFor-Profit50042None
\n", + "
" + ], + "text/plain": [ + " id name vertical client_type employee_count \\\n", + "0 2 Global Guardian Insurance None For-Profit 12000 \n", + "1 3 Eudaimonix None For-Profit 1500 \n", + "2 4 Aetherium Forge None For-Profit 500 \n", + "\n", + " contact_center_agent_count supervisor_count \n", + "0 2500 None \n", + "1 300 None \n", + "2 42 None " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "CLIENT_SEARCH = \"\" # e.g. \"Acme\" — empty lists everyone\n", + "\n", + "clients = client.list_clients(search=CLIENT_SEARCH or None)\n", + "if clients:\n", + " display(pd.DataFrame(clients)[\n", + " [c for c in (\"id\", \"name\", \"vertical\", \"client_type\", \"employee_count\",\n", + " \"contact_center_agent_count\", \"supervisor_count\")\n", + " if c in clients[0]]\n", + " ])\n", + "else:\n", + " print(\"No clients found — create one in the Athena UI (Orbit → Clients) and re-run.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "1e375b54", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Global Guardian Insurance
id2
nameGlobal Guardian Insurance
abbreviated_nameGGI
verticalNone
client_typeFor-Profit
employee_count12000
revenue4500000000.0
contact_center_agent_count2500
service_desk_agent_count300
supervisor_countNone
location_count120
\n", + "
" + ], + "text/plain": [ + " Global Guardian Insurance\n", + "id 2\n", + "name Global Guardian Insurance\n", + "abbreviated_name GGI\n", + "vertical None\n", + "client_type For-Profit\n", + "employee_count 12000\n", + "revenue 4500000000.0\n", + "contact_center_agent_count 2500\n", + "service_desk_agent_count 300\n", + "supervisor_count None\n", + "location_count 120" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CRM agent count: 2500 (composite: 600) — indicative scale 4.17×\n", + "CRM revenue: $4,500,000,000 (composite: $2,500,000,000)\n" + ] + } + ], + "source": [ + "CLIENT_ID = 2 # ← set from the `id` column above, or leave for auto-pick\n", + "\n", + "if CLIENT_ID is None and len(clients) == 1:\n", + " CLIENT_ID = clients[0][\"id\"]\n", + " print(f\"Auto-selected the only client: {clients[0]['name']} (id={CLIENT_ID})\")\n", + "assert CLIENT_ID is not None, \"Set CLIENT_ID from the table above and re-run this cell.\"\n", + "\n", + "profile = client.client_profile(CLIENT_ID)\n", + "CLIENT_NAME = profile[\"name\"]\n", + "display(pd.DataFrame([profile]).T.rename(columns={0: CLIENT_NAME}))\n", + "\n", + "# Client data → study scaling levers (no re-entry)\n", + "CLIENT_ASSUMPTIONS = dict(seed.ASSUMPTIONS)\n", + "if profile.get(\"contact_center_agent_count\"):\n", + " CLIENT_ASSUMPTIONS[\"agents_fte\"] = profile[\"contact_center_agent_count\"]\n", + " scale = CLIENT_ASSUMPTIONS[\"agents_fte\"] / seed.ASSUMPTIONS[\"agents_fte\"]\n", + " print(f\"CRM agent count: {CLIENT_ASSUMPTIONS['agents_fte']} \"\n", + " f\"(composite: {seed.ASSUMPTIONS['agents_fte']}) — \"\n", + " f\"indicative scale {scale:.2f}×\")\n", + "if profile.get(\"revenue\"):\n", + " CLIENT_ASSUMPTIONS[\"annual_revenue\"] = float(profile[\"revenue\"])\n", + " print(f\"CRM revenue: ${CLIENT_ASSUMPTIONS['annual_revenue']:,.0f} \"\n", + " f\"(composite: ${seed.ASSUMPTIONS['annual_revenue']:,.0f})\")" + ] + }, + { + "cell_type": "markdown", + "id": "2ff83486", + "metadata": {}, + "source": [ + "## 4 · Pick the attachment — Proposal or Engagement" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "584e01dd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Proposals for Global Guardian Insurance:\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idnamestatusopportunity
01Secure Cloud Infrastructure ModernizationDraftSecure Cloud Infrastructure Modernization
\n", + "
" + ], + "text/plain": [ + " id name status \\\n", + "0 1 Secure Cloud Infrastructure Modernization Draft \n", + "\n", + " opportunity \n", + "0 Secure Cloud Infrastructure Modernization " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "proposals = client.proposals_for_client(CLIENT_ID)\n", + "engagements = client.engagements_for_client(CLIENT_NAME)\n", + "\n", + "if proposals:\n", + " print(f\"Proposals for {CLIENT_NAME}:\")\n", + " display(pd.DataFrame([\n", + " {\"id\": p[\"id\"], \"name\": p.get(\"name\"), \"status\": p.get(\"status\"),\n", + " \"opportunity\": (p.get(\"opportunity\") or {}).get(\"name\")}\n", + " for p in proposals\n", + " ]))\n", + "if engagements:\n", + " print(f\"Engagements for {CLIENT_NAME}:\")\n", + " display(pd.DataFrame([\n", + " {\"id\": e[\"id\"], \"name\": e.get(\"name\"), \"status\": e.get(\"status\")}\n", + " for e in engagements\n", + " ]))\n", + "if not proposals and not engagements:\n", + " print(f\"{CLIENT_NAME} has no proposals or engagements yet — \"\n", + " \"the next cell can create a sandbox opportunity + proposal.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e04b1676", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Auto-selected proposal 1: Secure Cloud Infrastructure Modernization\n", + "Attaching via: {'proposal': 1}\n" + ] + } + ], + "source": [ + "# Set exactly ONE (ids from above). Leave both None to auto-pick — a single\n", + "# existing option wins; otherwise a sandbox opportunity + proposal is created.\n", + "PROPOSAL_ID = config.PROPOSAL_ID # or e.g. 42\n", + "ENGAGEMENT_ID = config.ENGAGEMENT_ID # or e.g. 7\n", + "\n", + "if PROPOSAL_ID is None and ENGAGEMENT_ID is None:\n", + " if len(proposals) == 1 and not engagements:\n", + " PROPOSAL_ID = proposals[0][\"id\"]\n", + " print(f\"Auto-selected proposal {PROPOSAL_ID}: {proposals[0].get('name')}\")\n", + " elif len(engagements) == 1 and not proposals:\n", + " ENGAGEMENT_ID = engagements[0][\"id\"]\n", + " print(f\"Auto-selected engagement {ENGAGEMENT_ID}: {engagements[0].get('name')}\")\n", + " elif not proposals and not engagements:\n", + " opp = client.create_opportunity(\n", + " name=f\"{CLIENT_NAME} — CX Cloud Modernization (sandbox)\",\n", + " client_id=CLIENT_ID,\n", + " description=\"Created by Palladium 00_provision for the Genesys CX Cloud TEI.\",\n", + " )\n", + " prop = client.create_proposal(\n", + " name=f\"{CLIENT_NAME} — Genesys CX Cloud TEI (sandbox)\",\n", + " opportunity_id=opp[\"id\"],\n", + " status=\"Draft\",\n", + " )\n", + " PROPOSAL_ID = prop[\"id\"]\n", + " print(f\"Created opportunity {opp['id']} and proposal {PROPOSAL_ID} for {CLIENT_NAME}.\")\n", + " else:\n", + " raise SystemExit(\"Multiple options — set PROPOSAL_ID or ENGAGEMENT_ID above and re-run.\")\n", + "\n", + "assert (PROPOSAL_ID is None) != (ENGAGEMENT_ID is None), \\\n", + " \"Set exactly one of PROPOSAL_ID / ENGAGEMENT_ID.\"\n", + "attach = {\"proposal\": PROPOSAL_ID} if PROPOSAL_ID else {\"engagement\": ENGAGEMENT_ID}\n", + "print(f\"Attaching via: {attach}\")" + ] + }, + { + "cell_type": "markdown", + "id": "2b4fcb45", + "metadata": {}, + "source": [ + "## 5 · Tool instance & seed the published values" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0655d1fc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Created tool 3rzDgVdsjhVv attached to {'proposal': 1}\n" + ] + } + ], + "source": [ + "from core.tei_client import AthenaAPIError\n", + "\n", + "def _report_id_of(t):\n", + " r = t.get(\"report\")\n", + " return r.get(\"id\") if isinstance(r, dict) else r\n", + "\n", + "def _matches_attachment(t):\n", + " if PROPOSAL_ID is not None:\n", + " opp = t.get(\"opportunity\") or {}\n", + " return t.get(\"proposal\") == PROPOSAL_ID or opp.get(\"proposal_id\") == PROPOSAL_ID\n", + " eng = t.get(\"engagement\")\n", + " eng_id = eng.get(\"id\") if isinstance(eng, dict) else eng\n", + " return eng_id == ENGAGEMENT_ID\n", + "\n", + "candidates = [t for t in client.list_tools() if _report_id_of(t) == REPORT_ID]\n", + "tool = next((t for t in candidates if _matches_attachment(t)),\n", + " candidates[0] if len(candidates) == 1 else None)\n", + "\n", + "if tool is None:\n", + " try:\n", + " tool = client.create_tool(\n", + " report_public_id=REPORT_ID,\n", + " name=f\"{CLIENT_NAME} — Genesys CX Cloud TEI\",\n", + " **attach,\n", + " )\n", + " print(f\"Created tool {tool['id']} attached to {attach}\")\n", + " except AthenaAPIError as e:\n", + " if e.status_code == 409: # DUPLICATE_INSTANCE\n", + " raise SystemExit(\n", + " \"An active tool already exists for this report + attachment. \"\n", + " \"Find it with client.list_tools() or pick a different proposal/engagement.\"\n", + " ) from e\n", + " raise\n", + "else:\n", + " print(f\"Found existing tool {tool['id']} (status: {tool.get('status')})\")\n", + "\n", + "TOOL_ID = tool[\"id\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "86443d76", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pushed values for 8 fields (genesys_ai_tokens seeded at $0 — published-study baseline).\n" + ] + } + ], + "source": [ + "payload = []\n", + "for b in seed.BENEFITS: # nominal; Athena risk-adjusts via the field definition\n", + " payload.append({\n", + " \"field_key\": b[\"field_key\"],\n", + " \"year_values\": b[\"year_values\"],\n", + " \"notes\": b[\"notes\"],\n", + " })\n", + "for c in seed.COSTS: # risk-adjusted UP client-side (Forrester methodology)\n", + " factor = 1 + c[\"risk_adjustment\"]\n", + " payload.append({\n", + " \"field_key\": c[\"field_key\"],\n", + " \"year_values\": {y: round(v * factor, 2) for y, v in c[\"year_values\"].items()},\n", + " \"initial\": round(c[\"initial\"] * factor, 2),\n", + " \"notes\": c[\"notes\"],\n", + " })\n", + "\n", + "client.update_values(TOOL_ID, payload)\n", + "print(f\"Pushed values for {len(payload)} fields \"\n", + " f\"(genesys_ai_tokens seeded at $0 — published-study baseline).\")" + ] + }, + { + "cell_type": "markdown", + "id": "509b52be", + "metadata": {}, + "source": [ + "## 6 · Calculate & verify\n", + "\n", + "**Tier 1 — pipeline correctness:** Athena must match `seed.ATHENA_EXPECTED`\n", + "(the published model re-discounted under Athena's Year-0-as-Year-1 rule)\n", + "within 0.5%.\n", + "\n", + "**Tier 2 — reconciliation:** show Athena vs the published totals. The\n", + "implementation initial (\\$1.309M, ~32% of cost PV) is discounted by Athena\n", + "but not by Forrester, so costs PV reads ~\\$119k lower and ROI ~11pp higher\n", + "than published. That delta is methodology, not data error." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "0728b42e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "════════════════════════════════════════════════════════\n", + " TEI Financial Summary\n", + "════════════════════════════════════════════════════════\n", + " Total Benefits (PV): $ 14,840,637\n", + " Total Costs (PV): $ 3,938,170\n", + "────────────────────────────────────────────────────────\n", + " Net Present Value: $ 10,902,466\n", + " ROI: 277%\n", + " Payback: 4.0 months\n", + "════════════════════════════════════════════════════════\n" + ] + } + ], + "source": [ + "summary = client.calculate(TOOL_ID)\n", + "client.print_summary(TOOL_ID)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "aba8fc21", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
metricpublished (Forrester)expected (Athena methodology)athena actualvs expected
0total_benefits_pv14,840,63814,840,64014,840,637-0.00%
1total_costs_pv4,057,1703,938,1703,938,170+0.00%
2net_present_value10,783,46810,902,47010,902,466-0.00%
3roi_percentage266277277+0.01%
\n", + "
" + ], + "text/plain": [ + " metric published (Forrester) expected (Athena methodology) \\\n", + "0 total_benefits_pv 14,840,638 14,840,640 \n", + "1 total_costs_pv 4,057,170 3,938,170 \n", + "2 net_present_value 10,783,468 10,902,470 \n", + "3 roi_percentage 266 277 \n", + "\n", + " athena actual vs expected \n", + "0 14,840,637 -0.00% \n", + "1 3,938,170 +0.00% \n", + "2 10,902,466 -0.00% \n", + "3 277 +0.01% " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Payback: 4 months (expected ≈ 4)\n", + "✅ Tier 1 passed — pipeline reproduces the study under Athena's discounting.\n", + "ℹ️ Tier 2: published ROI 266% vs Athena ~277% — explained Year-0 delta (see above).\n" + ] + } + ], + "source": [ + "rows, ok = [], True\n", + "for key in (\"total_benefits_pv\", \"total_costs_pv\", \"net_present_value\", \"roi_percentage\"):\n", + " actual = float(summary.get(key) or 0)\n", + " expected = seed.ATHENA_EXPECTED[key]\n", + " published = seed.PUBLISHED[key]\n", + " diff = (actual - expected) / expected\n", + " rows.append({\n", + " \"metric\": key,\n", + " \"published (Forrester)\": f\"{published:,.0f}\",\n", + " \"expected (Athena methodology)\": f\"{expected:,.0f}\",\n", + " \"athena actual\": f\"{actual:,.0f}\",\n", + " \"vs expected\": f\"{diff:+.2%}\",\n", + " })\n", + " ok &= abs(diff) <= 0.005\n", + "\n", + "display(pd.DataFrame(rows))\n", + "print(f\"Payback: {summary.get('payback_period_months')} months (expected ≈ 4)\")\n", + "assert ok, \"Athena diverged >0.5% from its own expected methodology — investigate.\"\n", + "print(\"✅ Tier 1 passed — pipeline reproduces the study under Athena's discounting.\")\n", + "print(\"ℹ️ Tier 2: published ROI 266% vs Athena ~277% — explained Year-0 delta (see above).\")" + ] + }, + { + "cell_type": "markdown", + "id": "181c7b55", + "metadata": {}, + "source": [ + "## 7 · Save a baseline version & persist IDs" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "d8102590", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved version 1 (baseline).\n", + "Saved to /Users/robert/git/palladium/.env:\n", + " PALLADIUM_GENESYSCX_REPORT_PUBLIC_ID=UCb2hSJprSBx\n", + " PALLADIUM_GENESYSCX_TOOL_PUBLIC_ID=3rzDgVdsjhVv\n", + " PALLADIUM_GENESYSCX_PROPOSAL_ID=1\n", + "\n", + "Next → 01_business_case.ipynb (AI token cost entry + sensitivity).\n" + ] + } + ], + "source": [ + "if not client.list_versions(TOOL_ID):\n", + " client.save_version(TOOL_ID, note=(\n", + " \"Baseline — published Forrester CX Cloud TEI figures (Dec 2025). \"\n", + " \"genesys_ai_tokens at $0 per the published study; set the annual \"\n", + " \"cost from the Genesys quote in 01_business_case before client use.\"\n", + " ))\n", + " print(\"Saved version 1 (baseline).\")\n", + "\n", + "ids = {\n", + " \"PALLADIUM_GENESYSCX_REPORT_PUBLIC_ID\": REPORT_ID,\n", + " \"PALLADIUM_GENESYSCX_TOOL_PUBLIC_ID\": TOOL_ID,\n", + "}\n", + "if PROPOSAL_ID is not None:\n", + " ids[\"PALLADIUM_GENESYSCX_PROPOSAL_ID\"] = str(PROPOSAL_ID)\n", + "if ENGAGEMENT_ID is not None:\n", + " ids[\"PALLADIUM_GENESYSCX_ENGAGEMENT_ID\"] = str(ENGAGEMENT_ID)\n", + "\n", + "env_path = update_env(**ids)\n", + "print(f\"Saved to {env_path}:\")\n", + "for k, v in ids.items():\n", + " print(f\" {k}={v}\")\n", + "print(\"\\nNext → 01_business_case.ipynb (AI token cost entry + sensitivity).\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4fc81c99-f073-486a-9f65-f207e96e59cd", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/studies/202512_GenesysCX/notebooks/01_business_case.ipynb b/studies/202512_GenesysCX/notebooks/01_business_case.ipynb new file mode 100644 index 0000000..a10f296 --- /dev/null +++ b/studies/202512_GenesysCX/notebooks/01_business_case.ipynb @@ -0,0 +1,376 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3da9de99", + "metadata": {}, + "source": [ + "# 01 · Business Case — Genesys CX Cloud TEI\n", + "\n", + "Working view of the live Athena tool, plus the **Genesys AI Experience token**\n", + "cost line the published study omits. Run `00_provision.ipynb` first.\n", + "\n", + "The published study models \\$0 AI consumption while three of its four benefits\n", + "(self-service uplift, agent efficiency, agent-assist sales) depend on AI\n", + "capabilities that Genesys bills via AI Experience tokens. Token pricing is\n", + "tiered and deal-specific, so the model keeps it simple — **one annual cost\n", + "value, entered from the Genesys quote**, exactly as Athena stores it. Quote\n", + "details (volume, unit price, tier) go in the field notes for the audit trail." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "89deae70", + "metadata": {}, + "outputs": [], + "source": [ + "import sys, pathlib # path shim: works on a fresh kernel\n", + "for _p in [pathlib.Path.cwd(), *pathlib.Path.cwd().parents]:\n", + " if (_p / \"pyproject.toml\").exists():\n", + " sys.path.insert(0, str(_p)); break\n", + "\n", + "import pandas as pd\n", + "from core.bootstrap import init\n", + "from core.notebook_helpers import charts\n", + "\n", + "pal = init(study=\"202512_GenesysCX\")\n", + "client, seed, config = pal.client, pal.seed_data, pal.config\n", + "\n", + "TOOL_ID = config.TOOL_PUBLIC_ID\n", + "assert TOOL_ID, \"No PALLADIUM_GENESYSCX_TOOL_PUBLIC_ID in .env — run 00_provision.ipynb first.\"\n", + "tool = client.get_tool(TOOL_ID)\n", + "print(f\"Tool: {tool.get('name')} ({TOOL_ID}) status={tool.get('status')}\")" + ] + }, + { + "cell_type": "markdown", + "id": "09afaf70", + "metadata": {}, + "source": [ + "## Current financial summary" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3d80c19a", + "metadata": {}, + "outputs": [], + "source": [ + "summary = client.calculate(TOOL_ID)\n", + "client.print_summary(TOOL_ID)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "392df0ba", + "metadata": {}, + "outputs": [], + "source": [ + "values = client.get_values(TOOL_ID)\n", + "benefit_rows = [v for v in values if v.get(\"table\") == \"benefits\"]\n", + "cost_rows = [v for v in values if v.get(\"table\") == \"costs\"]\n", + "\n", + "def value_table(rows, *, initial=False):\n", + " out = []\n", + " for v in rows:\n", + " yv = v.get(\"year_values\") or {}\n", + " rec = {\"field\": v.get(\"label\") or v[\"field_key\"]}\n", + " if initial:\n", + " rec[\"Initial\"] = v.get(\"initial\", 0.0)\n", + " rec.update({f\"Year {y}\": yv.get(str(y), 0.0) for y in (1, 2, 3)})\n", + " rec[\"risk_adj\"] = v.get(\"risk_adjustment\")\n", + " out.append(rec)\n", + " return pd.DataFrame(out)\n", + "\n", + "print(\"Benefits (nominal; Athena risk-adjusts at calculate time):\")\n", + "display(value_table(benefit_rows))\n", + "print(\"Costs (stored pre-multiplied by 1 + risk_adj):\")\n", + "display(value_table(cost_rows, initial=True))" + ] + }, + { + "cell_type": "markdown", + "id": "2383f761", + "metadata": {}, + "source": [ + "## Financial visualizations\n", + "\n", + "All figures are risk-adjusted and built from the live Athena values, using\n", + "the shared `core.notebook_helpers.charts` helpers (same ones the Streamlit\n", + "app uses)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ── Visual theme — plain values, edit freely (not confidential) ──\n", + "THEME = {\n", + " \"heading_font\": \"Helvetica Neue, Arial, sans-serif\", # chart titles\n", + " \"body_font\": \"Helvetica, Arial, sans-serif\", # axes, legends, labels\n", + " \"font_color\": \"#1F2937\", # hex\n", + "\n", + " # Circle-chart slice colours, applied in order a..j\n", + " \"pie_colors\": {\n", + " \"a\": \"#1565C0\",\n", + " \"b\": \"#2E7D32\",\n", + " \"c\": \"#C62828\",\n", + " \"d\": \"#F9A825\",\n", + " \"e\": \"#6A1B9A\",\n", + " \"f\": \"#00838F\",\n", + " \"g\": \"#EF6C00\",\n", + " \"h\": \"#5D4037\",\n", + " \"i\": \"#37474F\",\n", + " \"j\": \"#AD1457\",\n", + " },\n", + "\n", + " \"bar_green\": \"#2E7D32\", # benefits bars\n", + " \"bar_red\": \"#C62828\", # costs bars\n", + "}\n", + "\n", + "charts.apply_theme(**THEME)\n", + "print(\"Theme applied — re-run the chart cells below to restyle.\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "14d5942a", + "metadata": {}, + "outputs": [], + "source": [ + "# Cost breakdown — share of total three-year cost per line item\n", + "charts.cost_breakdown_pie(\n", + " cost_rows, title=\"Cost Breakdown — share of 3-year total (risk-adjusted)\"\n", + ").show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d13f342e", + "metadata": {}, + "outputs": [], + "source": [ + "# Benefits — three-year risk-adjusted total per category\n", + "charts.benefits_bar(\n", + " benefit_rows, title=\"Benefits (Three-Year, Risk-Adjusted)\"\n", + ").show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9ef6caee", + "metadata": {}, + "outputs": [], + "source": [ + "# Benefits vs costs, year by year (Initial = one-time Year-0 costs)\n", + "charts.benefits_vs_costs_by_year(benefit_rows, cost_rows).show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6f069df6", + "metadata": {}, + "outputs": [], + "source": [ + "# Cash flow with cumulative net benefits — the Forrester-style exhibit\n", + "def _yearly_breakdown(benefit_items, cost_items):\n", + " \"\"\"Risk-adjusted yearly rows + initial, computed from the live values.\"\"\"\n", + " initial = sum(float(c.get(\"initial\") or 0) for c in cost_items)\n", + " rows, cumulative = [], -initial\n", + " for y in (1, 2, 3):\n", + " b = sum(float((v.get(\"year_values\") or {}).get(str(y), 0) or 0)\n", + " * (1 - float(v.get(\"risk_adjustment\") or 0))\n", + " for v in benefit_items)\n", + " c = sum(float((v.get(\"year_values\") or {}).get(str(y), 0) or 0)\n", + " for v in cost_items)\n", + " cumulative += b - c\n", + " rows.append({\"year\": y, \"benefits\": b, \"costs\": c,\n", + " \"net\": b - c, \"cumulative_net\": cumulative})\n", + " return rows, initial\n", + "\n", + "yb, initial_cost = _yearly_breakdown(benefit_rows, cost_rows)\n", + "charts.cashflow_chart(yb, initial_cost=initial_cost).show()\n", + "pd.DataFrame(yb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b1ff0315", + "metadata": {}, + "outputs": [], + "source": [ + "# Waterfall — Benefits PV down to NPV (from the Athena summary)\n", + "charts.waterfall([\n", + " (\"Benefits PV\", float(summary[\"total_benefits_pv\"])),\n", + " (\"Costs PV\", -float(summary[\"total_costs_pv\"])),\n", + " (\"NPV\", float(summary[\"net_present_value\"])),\n", + "], title=\"Benefits PV → Costs PV → NPV\").show()" + ] + }, + { + "cell_type": "markdown", + "id": "c78f77a9", + "metadata": {}, + "source": [ + "## Genesys AI Experience tokens — annual cost\n", + "\n", + "Enter the negotiated annual token cost from the Genesys quote. For sizing\n", + "context, the study's own drivers imply roughly **1,040,000** self-service\n", + "interactions/yr and **3,120,000** agent-assisted interactions/yr would draw\n", + "tokens — bring the actual figure from the quote, not a derivation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "99b9c665", + "metadata": {}, + "outputs": [], + "source": [ + "# ── Deal inputs ──\n", + "AI_TOKEN_ANNUAL_COST = 0.0 # $/yr from the Genesys quote — 0 reproduces the published study\n", + "AI_TOKEN_QUOTE_NOTE = \"\" # e.g. \"Quote #1234: 4.2M tokens/yr @ $0.05, tier 2 commit\"\n", + "\n", + "print(f\"AI token line: ${AI_TOKEN_ANNUAL_COST:,.0f}/yr\")" + ] + }, + { + "cell_type": "markdown", + "id": "b7c6c4c7", + "metadata": {}, + "source": [ + "### Sensitivity — what the AI line does to NPV and ROI\n", + "\n", + "Computed locally from the current Athena summary: an annual cost `Δ` raises\n", + "costs PV by `Δ × 2.4869` (the 3-year, 10% annuity factor) and lowers NPV by\n", + "the same amount." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "09ceeea2", + "metadata": {}, + "outputs": [], + "source": [ + "ANNUITY = sum(1 / 1.10**n for n in (1, 2, 3)) # 2.4869\n", + "\n", + "base_benefits_pv = float(summary[\"total_benefits_pv\"])\n", + "base_costs_pv = float(summary[\"total_costs_pv\"])\n", + "\n", + "# Remove any token cost already stored, to get a clean zero-token base.\n", + "current_tokens = next(\n", + " (v for v in values if v[\"field_key\"] == \"genesys_ai_tokens\"), {})\n", + "current_annual = (current_tokens.get(\"year_values\") or {}).get(\"1\", 0.0)\n", + "base_costs_pv -= current_annual * ANNUITY\n", + "\n", + "sweep = [0, 100_000, 250_000, 500_000, 750_000, 1_000_000]\n", + "if AI_TOKEN_ANNUAL_COST and AI_TOKEN_ANNUAL_COST not in sweep:\n", + " sweep = sorted(sweep + [AI_TOKEN_ANNUAL_COST])\n", + "\n", + "rows = []\n", + "for ai_annual in sweep:\n", + " costs_pv = base_costs_pv + ai_annual * ANNUITY\n", + " npv = base_benefits_pv - costs_pv\n", + " rows.append({\n", + " \"AI cost/yr\": f\"${ai_annual:,.0f}\" + (\" ← your input\" if ai_annual == AI_TOKEN_ANNUAL_COST and ai_annual else \"\"),\n", + " \"Costs PV\": f\"${costs_pv:,.0f}\",\n", + " \"NPV\": f\"${npv:,.0f}\",\n", + " \"ROI\": f\"{npv / costs_pv * 100:,.0f}%\",\n", + " })\n", + "\n", + "display(pd.DataFrame(rows))" + ] + }, + { + "cell_type": "markdown", + "id": "6516270c", + "metadata": {}, + "source": [ + "## Push the AI token cost to Athena\n", + "\n", + "Writes the annual cost into `genesys_ai_tokens` (quote details in the notes),\n", + "recalculates server-side, and saves a version." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c6caacea", + "metadata": {}, + "outputs": [], + "source": [ + "PUSH = False # ← set True once AI_TOKEN_ANNUAL_COST is final\n", + "\n", + "if PUSH:\n", + " note = (\n", + " f\"AI Experience tokens: ${AI_TOKEN_ANNUAL_COST:,.0f}/yr. \"\n", + " + (f\"{AI_TOKEN_QUOTE_NOTE} \" if AI_TOKEN_QUOTE_NOTE else \"\")\n", + " + \"Line absent from the published Forrester study.\"\n", + " )\n", + " client.update_values(TOOL_ID, [{\n", + " \"field_key\": \"genesys_ai_tokens\",\n", + " \"year_values\": {\"1\": round(AI_TOKEN_ANNUAL_COST, 2),\n", + " \"2\": round(AI_TOKEN_ANNUAL_COST, 2),\n", + " \"3\": round(AI_TOKEN_ANNUAL_COST, 2)},\n", + " \"notes\": note,\n", + " }])\n", + " summary = client.calculate(TOOL_ID)\n", + " client.print_summary(TOOL_ID)\n", + " client.save_version(TOOL_ID, note=f\"AI token cost set: {note}\")\n", + " print(\"✅ Pushed, recalculated, and versioned. Re-run the visualization \"\n", + " \"cells above to refresh the charts.\")\n", + "else:\n", + " print(\"Dry run — set PUSH = True to write to Athena.\")" + ] + }, + { + "cell_type": "markdown", + "id": "c261ad48", + "metadata": {}, + "source": [ + "## Next steps\n", + "\n", + "- Adjust other drivers for the client (interaction volume, agent count,\n", + " self-service delta) via `client.update_values` or the Streamlit app\n", + " (`make app`), saving a version per scenario.\n", + "- Export charts for a deck: any figure object supports\n", + " `fig.write_image(\"chart.png\")` (needs `pip install kaleido`) or\n", + " `fig.write_html(\"chart.html\")`.\n", + "- Export for the report pipeline:\n", + " `python -m palladium export $PALLADIUM_GENESYSCX_TOOL_PUBLIC_ID -o exports/export.json`" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/studies/202512_GenesysCX/seed_data.py b/studies/202512_GenesysCX/seed_data.py new file mode 100644 index 0000000..47170a1 --- /dev/null +++ b/studies/202512_GenesysCX/seed_data.py @@ -0,0 +1,231 @@ +""" +Seed dataset for the Genesys CX Cloud TEI (Forrester, Dec 2025). + +"The Total Economic Impact™ Of CX Cloud — Cost Savings And Business +Benefits Enabled By Genesys And Salesforce" (commissioned by Genesys and +Salesforce). Composite: global supply company, $2.5B revenue, 10,000 +employees, 600 CX agents (400 concurrent licenses), 80,000 weekly +interactions averaging 12 minutes. + +Each row uses the friendly value shape accepted by +``core.tei_client.TEIClient.update_values``. Benefit values are *nominal* +(pre-risk-adjustment); Athena applies the field-level risk adjustment. +Cost values are nominal too — push them pre-multiplied by +``(1 + risk_adjustment)`` per the Palladium convention (Athena never +risk-adjusts costs). + +Published headline (3-yr risk-adjusted, 10% discount):: + + Benefits PV $14,840,638 + Costs PV $ 4,057,170 + NPV $10,783,468 + ROI 266% + Payback ~4 months (computed; the study does not headline it) + +Athena discounts Year-0 "Initial" amounts as Year-1 cashflows (Forrester +leaves Year 0 undiscounted). With this study's large initial cost +($1,309,000 risk-adjusted) that difference is material, so this module +also exports ``ATHENA_EXPECTED`` — the totals Athena *should* produce +under its own discounting. Verification: match ATHENA_EXPECTED tightly +(pipeline correctness), then reconcile to PUBLISHED with the explained +Year-0 delta. + +NOTE on the published PDF: the Total Costs table (p.14) prints the +implementation initial as $1,304,600, but the detail table, the cash-flow +analysis, and the math (1,190,000 × 1.10) all give $1,309,000 — the p.14 +figure is a typo in the study. +""" + +from __future__ import annotations + +#: 3-year nominal benefit cashflows. Risk adjustment stored separately. +BENEFITS: list[dict] = [ + { + "field_key": "legacy_retirement", + "table": "benefits", + "label": "Retirement of legacy systems with CX Cloud adoption", + "category": "Cost Savings", + "year_values": {"1": 680_000, "2": 930_000, "3": 930_000}, + "risk_adjustment": 0.05, + "notes": ( + "PDF A1–A4. Telephony $250k Y1 ramping to $500k (legacy " + "sunset completes mid-Y1) + WFM/recording/transcription apps " + "$100k + reduced dev effort $230k (2,400 hrs @ $94) + reduced " + "platform mgmt $100k (1,500 hrs @ $65). Risk adj 5%." + ), + }, + { + "field_key": "self_service_savings", + "table": "benefits", + "label": ( + "Cost savings from reallocated workers and avoided seasonal " + "hires with increased customer self-service" + ), + "category": "Productivity", + "year_values": {"1": 2_329_600, "2": 2_329_600, "3": 2_329_600}, + "risk_adjustment": 0.15, + "notes": ( + "PDF B1–B8. Self-service completion 15%→25% on 80k weekly " + "interactions → 8,000 deflected/week → 40 FTEs @ $58,240 " + "fully burdened. Risk adj 15%. (PDF B7 formula cites B2 where " + "the 12-min interaction length is meant; 40 FTEs is correct.)" + ), + }, + { + "field_key": "agent_efficiency", + "table": "benefits", + "label": "CX agent efficiency gains", + "category": "Productivity", + "year_values": {"1": 2_912_000, "2": 2_912_000, "3": 2_912_000}, + "risk_adjustment": 0.10, + "notes": ( + "PDF C1–C6. MTTR 12→10 min on 60k agent-handled interactions " + "per week → 104,000 hrs/yr @ $28 fully burdened. Risk adj 10%." + ), + }, + { + "field_key": "agent_assist_sales", + "table": "benefits", + "label": "Incremental sales from agent assist capabilities", + "category": "Revenue", + "year_values": {"1": 600_000, "2": 600_000, "3": 600_000}, + "risk_adjustment": 0.05, + "notes": ( + "PDF D1–D3. $500M revenue impacted (20% of $2.5B) × 1.5% lift " + "× 8% gross margin. Risk adj 5%." + ), + }, +] + + +#: Costs are nominal; push × (1 + risk_adjustment). "initial" is the +#: Year-0 component (companion non-annual field in Athena). +COSTS: list[dict] = [ + { + "field_key": "cx_cloud_licenses", + "table": "costs", + "label": "CX Cloud solution costs (licenses)", + "category": "Subscription", + "initial": 0, + "year_values": {"1": 840_000, "2": 840_000, "3": 840_000}, + "risk_adjustment": 0.05, + "notes": ( + "PDF E1–E3. Genesys Cloud CX 2 $170/user/mo + Salesforce " + "Voice $25/user/mo + connector $25/user/mo, 400 concurrent " + "users, 20% contractual discount → $650k + $95k + $95k. " + "Risk adj +5%. Seat licenses ONLY — AI consumption is a " + "separate line (genesys_ai_tokens)." + ), + }, + { + "field_key": "implementation", + "table": "costs", + "label": "Implementation and deployment cost", + "category": "Implementation", + "initial": 1_190_000, + "year_values": {"1": 0, "2": 0, "3": 0}, + "risk_adjustment": 0.10, + "notes": ( + "PDF F1–F5. 10-week implementation: 20 FTEs @ $80/hr fully " + "burdened ($640k) + $550k professional services. Risk adj " + "+10% → $1,309,000 (the p.14 Total Costs table's $1,304,600 " + "is a typo in the study)." + ), + }, + { + "field_key": "ongoing_management", + "table": "costs", + "label": "Ongoing management costs", + "category": "Operations", + "initial": 0, + "year_values": {"1": 202_800, "2": 202_800, "3": 202_800}, + "risk_adjustment": 0.10, + "notes": ( + "PDF G1–G3. 5 people @ 30% time (12 hrs/wk) @ $65/hr. " + "Risk adj +10%." + ), + }, + { + "field_key": "genesys_ai_tokens", + "table": "costs", + "label": "Genesys AI Experience token consumption", + "category": "Subscription", + "initial": 0, + "year_values": {"1": 0, "2": 0, "3": 0}, + "risk_adjustment": 0.0, + "notes": ( + "NOT in the published study — Forrester modeled $0 AI " + "consumption even though benefits B (self-service uplift), " + "C (AI coaching/assist), and D (agent assist upsell) all " + "depend on AI capabilities that Genesys bills via AI " + "Experience tokens. Seeded at $0 to reproduce the published " + "totals. For client cases, enter the negotiated annual token " + "cost from the Genesys quote and document the quote details " + "(token volume, unit price, tier) in these notes." + ), + }, +] + + +#: Composite-organization drivers — for scaling to a specific client. +ASSUMPTIONS: dict = { + "annual_revenue": 2_500_000_000, + "employees": 10_000, + "agents_fte": 600, + "concurrent_licenses": 400, + "weekly_interactions": 80_000, + "interaction_minutes": 12, + "self_service_rate_before": 0.15, + "self_service_rate_after": 0.25, + "mttr_saved_minutes": 2, + "agent_hourly_rate": 28, + "agent_annual_salary": 58_240, + "revenue_impacted": 500_000_000, + "revenue_lift": 0.015, + "gross_margin": 0.08, + "discount_rate": 0.10, + "analysis_years": 3, +} + + +# ──────────────────────────────────────────────────────────────────── +# Genesys AI Experience tokens +# +# Genesys bills AI consumption in "AI Experience tokens" — pricing is +# tiered, capability-dependent, and deal-specific. Athena stores a +# single annual cost value per line, and so do we: enter the negotiated +# annual figure from the Genesys quote into ``genesys_ai_tokens`` and +# document the quote details (volume, unit price, tier) in the field +# notes. For sizing context, the study's own drivers imply ~1,040,000 +# self-service interactions/yr (B5 × 52) and ~3,120,000 agent-assisted +# interactions/yr (C1 × 52) would draw tokens. +# ──────────────────────────────────────────────────────────────────── + + +# ──────────────────────────────────────────────────────────────────── +# Verification targets +# ──────────────────────────────────────────────────────────────────── + +#: Published Forrester totals (3-yr risk-adjusted PV @ 10%). +PUBLISHED: dict = { + "total_benefits_pv": 14_840_638, + "total_costs_pv": 4_057_170, + "net_present_value": 10_783_468, + "roi_percentage": 266, +} + +#: What Athena should produce given its own discounting (Year-0 initial +#: treated as a Year-1 cashflow: implementation PV = 1,309,000 / 1.10 = +#: 1,190,000 instead of 1,309,000). Match these tightly; the difference +#: vs PUBLISHED is methodology, not error. +ATHENA_EXPECTED: dict = { + "total_benefits_pv": 14_840_640, + "total_costs_pv": 3_938_170, + "net_present_value": 10_902_470, + "roi_percentage": 276.8, +} + + +def all_values() -> list[dict]: + """Return BENEFITS + COSTS — single-call payload for update_values.""" + return BENEFITS + COSTS diff --git a/studies/202602_AmazonConnect/notebooks/02_costs.ipynb b/studies/202602_AmazonConnect/notebooks/02_costs.ipynb index d5528a2..8d58950 100644 --- a/studies/202602_AmazonConnect/notebooks/02_costs.ipynb +++ b/studies/202602_AmazonConnect/notebooks/02_costs.ipynb @@ -15,7 +15,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "46446223", "metadata": {}, "outputs": [], @@ -35,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "4ec64198", "metadata": {}, "outputs": [], @@ -64,10 +64,99 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "9635f334", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 field_keylabelcategoryrisk_adjustmentInitialInitial (RA)Year 1Year 1 (RA)Year 2Year 2 (RA)Year 3Year 3 (RA)TotalTotal (RA)
0amazon_connect_usageAmazon Connect usage costSubscription0.050000$0$0$6,456,448$6,779,270$7,951,164$8,348,722$9,832,961$10,324,609$24,240,573$25,452,602
1implementation_migrationImplementation and migration costImplementation0.100000$1,087,500$1,196,250$188,333$207,166$188,333$207,166$0$0$1,464,166$1,610,583
2ongoing_managementOngoing managementOperations0.150000$0$0$256,200$294,630$187,200$215,280$187,200$215,280$630,600$725,190
\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "df = tables.costs_table(seed_data.COSTS)\n", "df.style.format({c: '${:,.0f}' for c in df.columns if c not in ('field_key','label','category','risk_adjustment')})" @@ -85,10 +174,76 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "3e35a794", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 CostInitial (RA)Y1 (RA)Y2 (RA)Y3 (RA)PV
0Amazon Connect usage cost$0$6,779,270$8,348,722$10,324,609$20,819,775
1Implementation and migration cost$1,196,250$207,166$207,166$0$1,555,795
2Ongoing management$0$294,630$215,280$215,280$607,506
3TOTAL$1,196,250$7,281,067$8,771,168$10,539,889$22,983,076
\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "import pandas as pd\n", "\n", @@ -115,10 +270,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "4109784e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
Computed Costs PV: $22,983,076
Forrester target: $22,983,076
Δ = $-0
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "expected_pv = 22_983_076\n", "computed_pv = df_check.iloc[-1]['PV']\n", @@ -146,10 +314,826 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "90e9b5e2", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "hole": 0.35, + "labels": [ + "Amazon Connect usage cost", + "Implementation and migration cost", + "Ongoing management" + ], + "type": "pie", + "values": [ + 25452601.650000002, + 1610582.6, + 725190 + ] + } + ], + "layout": { + "margin": { + "b": 40, + "l": 40, + "r": 20, + "t": 60 + }, + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "fillpattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermap": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermap" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "title": { + "text": "Cost Breakdown (Three-Year, Risk-Adjusted)" + } + } + }, + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "charts.cost_breakdown_pie(seed_data.COSTS).show()" ]