Enterprise Marketing Operations OS

The marketing operating system your teams actually need — installed in-house, in one afternoon.

Replace fragmented agency tools. Reclaim outsourced operations. Give your Marketing & Communications, CRM & Growth, Shopper & Trade Marketing, and Revenue Management teams a single AI-powered OS that runs the full operating model — from brief intake to QBR, from media plan to SKU P&L.

---

The problem this solves

A typical marketing operation runs on 12+ disconnected tools: agency decks for strategy, spreadsheets for media plans, separate platforms for CRM, attribution tools that contradict each other, and PowerPoint for QBRs. Each tool speaks only to itself. Knowledge doesn't transfer. Every quarter, the same analysis gets rebuilt from scratch.

Meanwhile, $700B of global marketing spend is managed with a productivity stack built in 2008.

This OS collapses the entire marketing operating model into a single Claude conversation. A brief that enters the intake router travels through scope, capacity, margin simulation, media plan, CRM journey, creative matrix, launch QA, weekly review, MMM model, CLV analysis, PPA/SKU optimization, and lands in a board-ready QBR deck — without switching tools.

---

Who installs this

Team	What they get
Marketing & Communications	Media planning, campaign QA, creative supply, measurement, MMM, weekly WBRs
CRM & Growth	Journey architecture, audience segmentation, CLV, uplift modeling, survival analysis, recommender systems
Shopper & Trade Marketing	Price-Pack Architecture (PPA), assortment diagnosis, shelf optimization, market basket analysis, trade P&L
Revenue Management (RGM)	Price elasticity, threshold detection, SKU financial models, continuous PPA optimization, shrinkflation analytics
Finance & Commercial	Margin simulation, scope audit, change orders, QBR financial appendices, Monte Carlo P&L
Agency / In-house team replacing an agency	Full commercial cycle: scope → FTE sizing → P&L → RFP → launch QA
Brand reclaiming outsourced operations	Run your own MMM, CLV, and PPA. Walk into your next agency review holding the analysis.

---

A note to Anthropic

This plugin demonstrates what Claude Skills become when designed as a connected operating system rather than isolated capabilities. 30 skills. Five operational cycles. One coherent model of how marketing organizations actually work — from brief to QBR, from price elasticity to customer lifetime value.

The Finance plugin you shipped showed the pattern. Marketing is the next vertical — a $700B industry running on tools that don't connect to each other and analytics that don't talk to decision-makers. This OS is a working proof of concept, built in production, serving real enterprise accounts in LATAM.

We'd welcome a conversation about what an official Anthropic marketing plugin could look like. GitHub Issues or LinkedIn.

---

30 skills. Five cycles. One operating model.

                    ┌──────────────────────────────────────────────────┐
                    │      data-intake-normalizer  [INFRASTRUCTURE]     │
                    │  Auto-validates every data file before any skill  │
                    │  Schema detection · Column mapping · BLOCK/OK     │
                    └─────────────────────┬────────────────────────────┘
                                          │
     ┌──────────────┬─────────────────────┼──────────────┬─────────────────────┐
     ▼              ▼                     ▼              ▼                     ▼
┌──────────┐  ┌──────────┐         ┌──────────┐   ┌──────────┐         ┌──────────┐
│🟦COMMERCIAL│ │🟩EXECUTION│         │🟨INTELLIG.│   │🟪SCIENCE │         │🟫PPA/RGM │
│          │  │          │         │          │   │  LAB     │         │  LAB     │
│ intake   │  │ audience │         │ weekly   │   │          │         │          │
│ scope    │  │ media    │──live──▶│ diagnose │   │ mmm      │         │ assortmt │
│ FTE      │  │ crm      │  data   │ memo     │   │ clv      │         │ elasticit│
│ margin   │  │ creative │         │ qbr      │   │ segment  │         │ threshold│
│ CO / rfp │  │ measure  │         │ memory   │   │ basket   │         │ fin model│
│ launch   │  │ analyze  │         │          │   │ uplift   │         │ value WTP│
└────┬─────┘  └────┬─────┘         └────┬─────┘   │ survival │         │ pack size│
     │              │                   │          │ price opt│         │ cont opt │
     └──────────────┴───────────────────┘          └──────────┘         └──────────┘
                          │                             ▲                     ▲
                          └─────────────────────────────┴─────────────────────┘
                              Invoked from any cycle when quantitative modeling needed

Orchestration contract

Each skill declares (in its SKILL.md) the upstream skills it accepts inputs from and the downstream skills it routes to. When a skill completes, it fires a sendPrompt() suggesting the next skill. There is no central orchestrator — routing is declarative and emergent from the skill graph itself.

---

MCP integrations supported

The OS connects to 11 MCP servers. All integrations are optional — every skill works standalone. MCP connectivity adds live data without leaving the conversation.

MCP Server	Skills that use it	What it adds
Supermetrics	weekly-control-tower, analyzing-marketing-campaign, mmm-modeling	Live pull: Google Ads, Meta, LinkedIn, TikTok, GA4 spend + performance data
Plinth by Polanyi	weekly-control-tower, mmm-modeling, margin-simulation	Agency P&L, media waste detection, cross-client benchmarks
Adspirer (175+ tools)	mmm-modeling, media-routing-planner, rfp-submission	Campaign-level spend data across all major ad platforms
Google Drive	rfp-submission, client-memory-synthesizer, qbr-generator	Pull templates, historical decks, client credentials
Gmail	agency-request-intake-router, client-memory-synthesizer	Classify inbound client requests; log decisions to thread
Google Calendar	campaign-launch-qa, weekly-control-tower	Deadline tracking, launch gates, QBR scheduling
Adobe AJO / AEM	crm-journey-architect, creative-supply-planner	Journey activation in Adobe Journey Optimizer; asset management
Salesforce	crm-journey-architect, audience-segmentation-brief	CRM data for segmentation; journey trigger events
Figma	creative-supply-planner, rfp-submission	Pull design assets; validate format specs vs channel requirements
Stripe	margin-simulation, change-order-generator	Invoice status, payment term tracking, fee validation
TomTom	ppa-assortment-diagnosis, ppa-continuous-optimization, price-elasticity-modeling, price-threshold-detection	Geographic PPA mapping: POI density by channel, zone-level elasticity, threshold variation by city zone
S&P Global	rfp-submission, executive-growth-memo	Client financials for public companies; category market size

---

Detailed Skill Reference

⚙️ Infrastructure

data-intake-normalizer

Auto-triggers before any data-driven skill.

Triggers: any CSV / XLSX / TSV / JSON upload, or "valida este archivo", "dame el template para…"

What it does: Schema detection (infers target skill from column structure) → column mapping to OS canonical schema → type coercion (dates, currencies, units) → null handling → BLOCK / WARN / OK verdict. Generates XLSX input templates on demand.

Scripts: schema_detector.py, column_mapper.py, type_coercer.py, null_handler.py, validation_report.py, template_generator.py | Ref: schemas.md

Outputs: Normalized DataFrame + validation report + XLSX templates | Routes to → detected target skill; blocks if critical columns missing.

---

🟦 COMMERCIAL CYCLE (7 skills)

Request → Scope → Capacity → Margin → Pricing → Pitch → Launch

1. agency-request-intake-router

Triggers: any client email, brief, vague ask, or scope change request.

What it does: Classifies across 12 canonical types (RFP, scope change, QBR, campaign, CRM, media, creative, reporting, urgent, compliance, financial, data). Outputs routing recommendation with confidence score and SLA flag.

Scripts: intake_classifier.py | Ref: routing_playbook.md | MCP: Gmail (live email classification)

Outputs: Classification card (type, confidence %, SLA hours) + sendPrompt() routing | Routes to → scope-audit, rfp-submission, change-order-generator, weekly-control-tower

---

2. scope-audit

Triggers: "review this SOW", "is this priced right?", "audit the brief", any RFP/SOW upload.

What it does: Ambiguous-language detection + implicit-scope inference + risk scoring per clause. Identifies hidden deliverables, vague SLAs, missing assumptions, dependency gaps.

Scripts: scope_audit_engine.py | Refs: scope_checklist.md, risk_register_template.md

Outputs: Risk register (critical/major/minor per clause) + implicit scope list + GREEN/YELLOW/RED verdict | Routes to → fte-capacity-sizing (clear), change-order-generator (gaps found)

---

3. fte-capacity-sizing

Triggers: "how many people do we need?", "can we staff this?", after scope-audit.

What it does: 70/30 AI-to-human model applied to every task — 70% AI agents, 30% irreducible human (strategy, creative concept, relationship, compliance). Sizes pod by role, seniority, FTE, billable hours, utilization.

Scripts: capacity_calculator.py | Refs: role_catalog.md, hour_benchmarks.md | MCP: Plinth (FTE benchmarks)

Outputs: Pod table (role, FTE, AI%, human%) + utilization analysis + capacity gap/surplus + anchor JSON → margin-simulation | Routes to → margin-simulation

---

4. margin-simulation

Triggers: "is this profitable?", "what should we charge?", after fte-capacity-sizing.

What it does: 10,000-run Monte Carlo P&L simulation + leakage detection (out-of-scope work, vendor markups, FTE over-allocation, payment-term drag). Outputs three pricing tiers.

Scripts: margin_engine.py | Ref: leakage_and_pricing.md | MCP: Plinth (leakage benchmarks), Stripe (invoice/payment data)

Outputs: P10/P50/P90 EBITDA + leakage diagnostic (ranked by $ impact) + min/target/premium pricing + go/no-go | Routes to → change-order-generator (leakage), media-procurement-benchmark (vendor markup)

---

5. change-order-generator

Triggers: "this isn't in scope", "how do we bill this?", routed from scope-audit or margin-simulation.

What it does: Economy/standard/premium pricing engine with margin floor enforcement. Drafts client-ready CO language in EN or ES.

Scripts: co_pricing_engine.py | Ref: co_language_templates.md | MCP: Stripe (fee validation), Gmail (send draft)

Outputs: Three-tier pricing + CO document (.docx) + negotiation guidance | Routes to → Client; then campaign-launch-qa if CO includes new deliverable

---

6. rfp-submission

Triggers: "we got an RFP", "prepare the pitch", routed from intake-router.

What it does: 8-chapter structured response: exec summary, brief understanding, audience & data, creative, media & channel, measurement & incrementality, operating model (70/30), commercial structure. Web research + benchmark integration.

Scripts: rfp_analyzer.py | Ref: rfp_chapter_guides.md | MCPs: Google Drive (templates), Supermetrics (historical data), S&P Global (client financials), Adobe (platform capabilities)

Outputs: Pitch deck (.pptx) + narrative (.docx) + commercial appendix (.xlsx) + win-theme matrix | Routes to → fte-capacity-sizing, media-routing-planner, measurement-incrementality

---

7. campaign-launch-qa

Triggers: "are we ready to launch?", "go/no-go", after creative-supply-planner completes.

What it does: QA scoring across 9 dimensions: media, creative, CRM, landing pages, tracking, approvals, reporting, tech stack, operations.

Scripts: qa_scorer.py | Ref: tech_stack_enablers.md | MCP: Google Calendar (deadline check), Adobe AJO (journey live status)

Outputs: QA scorecard (pass/warning/fail per dimension) + blocker list + Go/No-Go/Conditional Go + PDF sign-off | Routes to → weekly-control-tower once live

---

🟩 EXECUTION CYCLE (7 skills)

Audience → Media → CRM → Creative → Measurement → Analysis → Launch

8. audience-segmentation-brief

Triggers: "who should we target?", "build segments", "create lookalike seeds", after RFP defines audience.

What it does: RFM segmentation + CLV estimation (BG/NBD + Gamma-Gamma, PyMC-Marketing) + K-Means behavioral clustering + Consumer Identity Graph resolution (1st/2nd/3rd party data unification).

Scripts: segmentation_engine.py, addressability_checker.py, segment_overlap_checker.py | Refs: segmentation_methodology.md, consent_and_addressability.md, suppression_guidelines.md | MCPs: Salesforce (CRM data), Supermetrics (behavioral data)

Outputs: Segment table (size, RFM, CLV, cluster, persona name) + addressability by channel + suppression list + activation brief | Routes to → media-routing-planner, crm-journey-architect, creative-supply-planner

---

9. media-routing-planner

Triggers: "build a media plan", "where should we spend?", "reallocate budget".

What it does: Cross-channel allocation via Hill-function saturation curves + frequency rules + funnel-stage logic. Detects oversaturation. Pulls current benchmarks via web search before recommending CPMs/CPAs.

Scripts: media_optimizer.py, saturation_checker.py | Refs: channel_benchmarks.md, saturation_frequency_rules.md, reallocation_triggers.md | MCP: Supermetrics (live pacing), Adspirer (platform rates)

Outputs: Media plan table (channel, audience, $, impressions, reach, frequency, conversions) + saturation diagnostic + reallocation recs + inline HTML dashboard | Routes to → media-procurement-benchmark, creative-supply-planner, mmm-modeling (if budget >$1M + 12mo history)

---

10. media-procurement-benchmark

Triggers: "is this a good rate?", "evaluate this IO", routed from media-routing-planner.

What it does: Procurement scoring across 7 dimensions: rate competitiveness, inventory quality, volume rebates, make-goods, payment terms, working capital impact, exit clauses.

Scripts: procurement_scorer.py, working_capital_calculator.py | Refs: procurement_terms.md, make_good_terms.md, working_capital_media.md

Outputs: Scorecard (offer vs benchmark vs target) + working capital % impact + negotiation playbook + counter-offer language | Routes to → procurement team; back to margin-simulation if leakage confirmed

---

11. crm-journey-architect

Triggers: "design a journey", "abandoned cart", "winback", "lead nurture", after audience-segmentation-brief.

What it does: Full journey design — triggers, decision splits, wait nodes, message variants, frequency caps, exit criteria, control groups. Platform-specific implementation (SFMC, Adobe AJO, Braze).

Scripts: journey_builder.py | Ref: platform_implementation.md | MCPs: Adobe AJO (activation), Salesforce (CRM events), Gmail (email channel)

Outputs: Journey diagram (Mermaid + HTML) + message matrix + data dependency list + platform implementation guide + measurement plan | Routes to → creative-supply-planner, survival-analysis-marketing, measurement-incrementality

---

12. creative-supply-planner

Triggers: "what assets do we need?", "how many versions?", after media-routing-planner and crm-journey-architect.

What it does: Asset matrix (audiences × formats × channels × stages) + fatigue refresh cycles + GenAI vs human split (70/30 model applied to creative production).

Scripts: asset_matrix_builder.py, fatigue_refresh_calculator.py | Refs: channel_format_requirements.md, genai_production_guidelines.md | MCP: Figma (asset specs), Adobe AEM (asset library)

Outputs: Asset matrix (.xlsx) + fatigue refresh schedule + GenAI/human split with cost estimate + production timeline | Routes to → campaign-launch-qa

---

13. measurement-incrementality

Triggers: "prove marketing works", "what's the real ROAS?", "the CFO is questioning spend".

What it does: Separates delivery metrics → attribution → correlation → true incrementality. Validates platform-reported ROAS. Designs lift tests, geo experiments, holdout groups.

Scripts: baseline_gap_calculator.py, incrementality_claim_checker.py, test_control_validator.py | Refs: experiment_design_guide.md, executive_claims_policy.md

Outputs: Measurement framework table + test design (sample size, power, MDE) + claim validator + executive translation ("Platform says X, true incremental is closer to Y") | Routes to → mmm-modeling, response-uplift-modeling, executive-growth-memo

---

14. analyzing-marketing-campaign

Triggers: "analyze this week's performance", "what's working?", "compare channels".

What it does: Funnel metrics (CTR, CVR), efficiency KPIs (ROAS, CPA, Net Profit), rule-based reallocation logic vs industry benchmarks per channel.

Scripts: campaign_analyzer.py | Ref: budget_reallocation_rules.md | MCP: Supermetrics (live channel data), Adspirer (platform metrics)

Outputs: Performance table (WoW deltas vs benchmarks) + reallocation recommendations with rule justification + inline dashboard | Routes to → weekly-control-tower, performance-diagnosis

---

🟨 INTELLIGENCE CYCLE (5 skills)

Monitor → Diagnose → Report → Communicate → Remember

15. weekly-control-tower

Triggers: "weekly review", "WBR", "status update", scheduled cadence.

What it does: Aggregates delivery, performance, CRM, pacing, blockers, SLA risk, FTE load, margin drift from MCP feeds or uploaded reports. Auto-detects anomalies. Produces multi-account WBR.

Scripts: wbr_builder.py | Ref: control_tower_framework.md | MCPs: Supermetrics, Plinth, Adobe, Google Drive (data sources)

Outputs: Inline HTML dashboard per account + anomaly flags (ranked by severity) + decisions queue + WBR summary (.docx) | Routes to → performance-diagnosis (anomaly), executive-growth-memo (leadership), client-memory-synthesizer (log)

---

16. performance-diagnosis

Triggers: "why is ROAS down?", "CPA is rising", routed from weekly-control-tower.

What it does: Five-step framework — confirm gap → decompose funnel → rank root causes → generate corrective options ranked by ROI → recovery plan with timeline, owner, cost.

Scripts: funnel_gap_analyzer.py, root_cause_ranker.py, corrective_action_prioritizer.py | Refs: diagnostic_framework.md, corrective_action_playbook.md

Outputs: Funnel waterfall (broken stage highlighted) + root cause ranking (confidence scores) + recovery plan | Routes to → fix skill (e.g., creative-supply-planner for fatigue) → executive-growth-memo

---

17. executive-growth-memo

Triggers: "what do I tell the CFO?", "board memo", "leadership update", after any major analysis.

What it does: KPI cascade framework — translates operational detail into C-level language. Audience-specific framing: CEO (growth + risk), CFO (margin + working capital), CRO (revenue + pipeline), CMO (brand + customer).

Scripts: scenario_calculator.py | Ref: executive_communication.md | MCP: Gmail (send memo)

Outputs: One-page memo (.docx) + Slack/email inline version + verbal talking points | Logs to → client-memory-synthesizer

---

18. qbr-generator

Triggers: "prepare the QBR", "Q[N] results", quarterly cadence.

What it does: End-to-end QBR — data pull → narrative arc → slide deck → spreadsheet appendix → decision document. Invokes mmm-modeling and customer-lifetime-value for refreshed analysis.

Scripts: qbr_builder.py | Refs: qbr_framework.md, quarterly_planning.md | MCPs: Google Drive (templates), Supermetrics (data), Figma (slide design)

Outputs: Executive deck (.pptx, 24-32 slides) + data appendix (.xlsx, 6-8 tabs) + decision document (.docx) | Logs to → client-memory-synthesizer

---

19. client-memory-synthesizer

Triggers: "prepare handover", "onboard new team", "summarize the year", after every QBR.

What it does: Synthesizes durable memory across 9 dimensions: history, decisions, preferences, risks, scope changes, operational patterns, commercial context, performance learnings, relationship dynamics.

Scripts: memory_synthesizer.py | Refs: memory_framework.md, tenant_context_template.md | MCP: Google Drive (archive)

Outputs: Tenant context (.md, drop-in for Claude Project Instructions) + decision log + risk register + onboarding brief | Read by → every skill at start of any client-specific task

---

🟪 MARKETING SCIENCE LAB (8 skills)

Real models. Real Python. PyMC-Marketing, lifetimes, scikit-learn, mlxtend, scipy, statsmodels.

20. mmm-modeling

Triggers: "run MMM", "channel ROI", "budget optimization", "marginal ROAS".

What it does: Bayesian MMM (PyMC-Marketing). Acid-test validation: Holt-Winters, Granger causality, VIF. Industry-calibrated priors. Trade marketing decomposition. Meridian-style scenario planning. Marginal ROI optimization.

Scripts: acid_test.py, data_validator.py, context_resolver.py, custom PyMC model | Refs: 14 methodology files including acid_test_validation.md, budget_optimization.md, custom_model.md | MCPs: Adspirer (digital spend), Supermetrics (channel data), Plinth (waste benchmarks)

Outputs: Channel contribution decomposition + response curves (90% CI) + adstock/saturation params + budget reallocation with projected lift + sensitivity analysis + inline dashboard

---

21. customer-lifetime-value

Triggers: "calculate LTV", "how much can we spend to acquire?", "LTV by segment".

What it does: Four models — descriptive historical, Markov chain (Pfeifer & Carraway), survival regression, Monte Carlo. CAC ceiling derivation. Customer equity calculation.

Scripts: ltv_descriptive.py, ltv_markov_chain.py, ltv_survival.py, monte_carlo_ltv.py, customer_equity.py, export_ltv_dashboard_json.py | Refs: model_selection_ltv.md, katsov_ltv_excerpts.md | Template: ltv_dashboard_template.html

Outputs: LTV distribution (P10/P50/P90) by segment + customer equity + max CAC + retention impact simulation + inline dashboard

---

22. customer-segmentation-clustering

Triggers: "customer segments", "personas", "RFM", "behavioral clustering", "loyalty tiers".

What it does: K-Means + Gaussian Mixture Models + RFM scoring + LLM-generated persona narratives. Cluster stability validation (silhouette + Davies-Bouldin).

Scripts: behavioral_clustering.py, rfm_segmentation.py, persona_interpret.py, export_seg_dashboard_json.py | Ref: katsov_seg_excerpts.md | Template: seg_dashboard_template.html

Outputs: Segment table + persona narratives + stability score + Next Best Action per segment + inline dashboard

---

23. market-basket-analysis

Triggers: "cross-sell", "product affinity", "frequently bought together", "shelf optimization".

What it does: Apriori + FP-Growth for association rules. QAP (Quadratic Assignment Problem) for physical/digital shelf layout optimization. Journey sequence analysis.

Scripts: association_rules.py, fp_growth.py, store_layout_qap.py, export_mba_dashboard_json.py | Refs: industry_benchmarks_mba.md, katsov_mba_excerpts.md | Template: mba_dashboard_template.html

Outputs: Association rules (support, confidence, lift) + cross-sell ranking + optimized shelf layout + basket-size uplift simulation + inline dashboard

---

24. price-demand-optimization

Triggers: "optimal price", "markdown schedule", "two-part tariff", "EMSR fare class".

What it does: Unit price optimization (elasticity-based) + price segmentation + two-part tariffs + markdown linear programming + EMSR-b capacity allocation (Talluri & van Ryzin).

Scripts: price_unit_optimizer.py, price_segmentation.py, markdown_linear_program.py, emsrb.py, export_price_dashboard_json.py | Refs: model_selection_price.md, industry_benchmarks_price.md | Template: price_dashboard_template.html

Outputs: Optimal price with revenue/margin impact + elasticity curve + markdown schedule + fare-class booking limits + inline dashboard

---

25. recommender-systems

Triggers: "recommendation engine", "collaborative filtering", "SVD", "cold-start problem", "NDCG".

What it does: Content-based + user/item collaborative filtering + SVD/SVD++/NMF (Koren & Bell) + hybrid blending + non-personalized cold-start (association rules).

Scripts: svd_basic.py, hybrid_blending.py, non_personalized_association.py, evaluate_top_k.py, export_rec_dashboard_json.py | Refs: algorithm_selection.md, industry_benchmarks.md, katsov_rec_excerpts.md | Template: rec_dashboard_template.html

Outputs: Top-K recommendations per user + RMSE / NDCG@K / Precision@K / Recall@K + cold-start fallback + inline dashboard

---

26. response-uplift-modeling

Triggers: "propensity model", "persuadables", "treatment vs control", "incremental lift", "savability score".

What it does: Two-model (Radcliffe & Surry), single-model, and multinomial uplift. Four-quadrant identification: persuadables, sure things, lost causes, do-not-disturb.

Scripts: 8 scripts including two_model_uplift.py, single_model_uplift.py, four_quadrant_classifier.py | Refs: uplift_methodology.md, industry_benchmarks.md | Template: HTML dashboard

Outputs: Uplift score per customer + four-quadrant assignment + decile lift chart + ROI threshold + cost-capping budget recommendation

---

27. survival-analysis-marketing

Triggers: "time to event", "Kaplan-Meier", "churn timing", "replenishment trigger", "time to next purchase".

What it does: Kaplan-Meier (1958) + Cox PH (1972) + parametric survival for next purchase, churn, subscription renewal, promo redemption. Handles censored observations correctly.

Scripts: 6 scripts including kaplan_meier.py, cox_ph.py, replenishment_trigger.py | Refs: survival_methodology.md, industry_benchmarks.md | Template: HTML dashboard

Outputs: Survival curves by segment + hazard ratios for covariates + median time-to-event with CI + replenishment trigger recommendations + inline dashboard

---

🟫 PRICING & PACK ARCHITECTURE (PPA) LAB — Revenue Growth Management (7 skills)

The right product. The right price. The right pack. The right channel.

The PPA Lab is the Revenue Growth Management engine of the OS. It runs as a parallel operating layer — invoked at any OPM stage when a pricing, SKU portfolio, or revenue architecture decision is needed. Built on the EY PPA Framework, Polestar 7-Step Methodology, and peer-reviewed methods (Hansen 2000, Lancaster-McFadden MNL, CUSUM).

The PPA loop is continuous:

  ppa-assortment-diagnosis ──▶ price-elasticity-modeling ──▶ price-threshold-detection
           ▲                                                           │
           │                                                           ▼
  ppa-continuous-optimization ◀── ppa-pack-size-leverage ◀── ppa-financial-model
           │                                │
           │                                ▼
           └──── (structural shift) ──── ppa-value-perception

---

28. ppa-assortment-diagnosis

Triggers: "analyze SKU portfolio", "competitive landscape by price-pack", "white spaces", "PPA gaps by channel", "surtido", "espacios en blanco".

What it does: Maps current assortment vs competitive set across price tiers, pack sizes, channels. Calculates Price-per-Unit (price/kg, price/ml), Relative Price Index (RPI), and white space opportunity scores.

• RPI = brand_price_per_unit / category_avg_price_per_unit
• ws_score = (competitor_coverage − own_coverage) × demand_weight (ws_score > 0.5 = actionable)

Scripts: analysis_scripts.py, assortment_gap_report.py, competitive_landscape.py, consumer_behavior.py, price_pack_trends.py, white_space_finder.py | Ref: ppa_methodology.md | MCP: TomTom (geographic POI mapping by channel)

Outputs: Competitive landscape map (price tier × pack size matrix) + white space ranking + RPI by SKU + channel × pack gap matrix + TomTom zone map + Marketer NBA | Routes to → ppa-financial-model, price-elasticity-modeling, ppa-value-perception

---

29. price-elasticity-modeling

Triggers: "elasticidad precio", "impacto de precio en volumen", "shrinkflation", "demand forecast", "log-log regression", "si bajo 10% el precio, ¿cuánto sube el volumen?".

What it does: Four methods: (1) log-log OLS (constant elasticity), (2) piecewise threshold regression (Chow/Davies breakpoint test), (3) pack-size interaction model (differential elasticity by size), (4) gradient boosting demand forecast with promotional variables.

• ln(Q) = α + β·ln(P) + γ·controls → β = constant elasticity
• FMCG typical range: β ∈ [-0.5, -3.0]

Scripts: linear_elasticity.py, threshold_elasticity.py, elasticity_by_packsize.py, ai_demand_forecast.py, price_sensitivity_heatmap.py | Ref: elasticity_benchmarks.md | MCP: TomTom (geographic elasticity heatmap by zone)

Outputs: Elasticity coefficient + CI + demand curve + breakpoint detection + pack-size elasticity comparison + 12-week forecast + geographic heatmap + NBA | Routes to → price-threshold-detection, ppa-financial-model, ppa-pack-size-leverage

---

30. price-threshold-detection

Triggers: "umbral de precio", "precio psicológico", "CUSUM", "Markov switching", "Hansen threshold", "just-below pricing", "dónde cae el volumen".

What it does: Four methods: (1) demand discontinuity analysis (OLS residual spikes), (2) CUSUM change-point detection (Page 1954), (3) common threshold audit (.99, .95, round numbers), (4) Hansen (2000) two-regime threshold regression (threshold γ estimated by grid search, p-value via bootstrap).

• CUSUM: S_t = max(0, S_{t-1} + (x_t − μ₀ − k)) — alert when S_t > h
• Hansen (2000): Q = α₁ + β₁P if P ≤ γ / Q = α₂ + β₂P if P > γ (γ by grid search)
• Crossing a round-number threshold: -20% to -40% demand loss (FMCG documented)

Scripts: demand_discontinuity.py, regime_switch_model.py, common_thresholds.py, threshold_risk_assessor.py | Ref: threshold_methodology.md | MCP: TomTom (threshold variation by city zone)

Outputs: Threshold map (price points with discontinuity magnitude) + regime comparison + proximity risk gauge + NBA (raise price vs reduce pack) + zone variation | Routes to → ppa-pack-size-leverage, ppa-financial-model, ppa-continuous-optimization

---

31. ppa-value-perception

Triggers: "percepción de valor", "WTP", "disposición a pagar", "jerarquía de decisión", "conjoint analysis", "MaxDiff", "precio por kg más caro en pack grande".

What it does: Measures consumer willingness-to-pay via Lancaster-McFadden logit. Models decision hierarchy (which attribute evaluated first: brand, price, size, format). Detects perception failures (larger pack costs MORE per kg/ml than smaller — damages brand equity).

• Utility: U = β_price × price + β_size × size + β_brand × brand + ε
• WTP_X = −β_X / β_price (Lancaster-McFadden)
• Perception failure alert: price_per_kg_large > price_per_kg_small

Scripts: wtp_estimate.py, decision_hierarchy.py, value_drivers.py, perception_failure_detector.py, value_communication_tester.py, value_perception_report.py | Ref: wtp_methodology.md

Outputs: WTP curves by segment + decision hierarchy map + value driver ranking + perception failure alerts by SKU + value comms A/B test design + NBA + inline dashboard | Routes to → ppa-pack-size-leverage, ppa-financial-model

---

32. ppa-financial-model

Triggers: "modelo financiero PPA", "P&L por SKU", "canibalización", "análisis de sensibilidad", "ROI de cambio de precio".

What it does: SKU-level P&L with elasticity-adjusted volumes. MNL (Multinomial Logit) cannibalization matrix — how a new/modified SKU substitutes within own portfolio vs capturing from competitors. Monte Carlo sensitivity (10,000 runs on price, volume, COGS). Game-theoretic competitor response scenarios.

• Cash Margin = Volume × (Price − COGS_per_unit)
• MNL: P(i) = exp(V_i) / Σ_j exp(V_j) → diversion ratio = own portfolio substitution %
• Incremental volume = new SKU volume × (1 − own diversion rate)

Scripts: sku_pl_model.py, cannibalization_matrix.py, sensitivity_analysis.py, competitor_response.py, financial_summary_report.py | Ref: financial_modeling_methodology.md

Outputs: SKU P&L (revenue, COGS, gross profit, operating profit) + cannibalization matrix + sensitivity tornado + scenario comparison (conservative/base/optimistic) + exec financial summary + P&L waterfall inline dashboard | Routes to → ppa-pack-size-leverage, ppa-continuous-optimization, executive-growth-memo

---

33. ppa-pack-size-leverage

Triggers: "shrinkflation", "upsizing", "margen en efectivo", "cash margin", "cambio de gramaje", "optimizar margen sin subir precio".

What it does: Evaluates shrinkflation, upsizing, downscaling. Maximizes cash margin (volume × unit margin) — not just unit margin. EY PPA decision tree. 6-scenario cash margin simulation.

• cash_margin = volume × (price − cost_per_g × pack_size_g)
• Implicit price increase: (size_old − size_new) / size_new × 100%
• Consumer detection threshold: >15% size reduction typically triggers backlash

Scripts: shrinkflation_calculator.py, upsizing_evaluator.py, pack_size_decision_tree.py, scenario_simulator.py, cash_margin_optimizer.py | Ref: pack_size_methodology.md

Outputs: Decision tree recommendation (shrink/upsize/raise price/hold) + 6-scenario simulator + optimal pack size + risk assessment (consumer perception, regulatory, competitor) + NBA + inline dashboard | Routes to → ppa-financial-model, price-threshold-detection, ppa-continuous-optimization

---

34. ppa-continuous-optimization

Triggers: "monitoreo PPA", "optimización continua", "alerta temprana", "semáforo de SKUs", "CUSUM PPA", "detect market share drop", "monitor PPA post-launch".

What it does: Closes the PPA loop. Monitors KPIs (market share, RPI, velocity, distribution) by SKU × channel × zone × segment. CUSUM early-warning alerts on drift. Auto-pricing business rules for tactical adjustments. Triggers full ppa-assortment-diagnosis redesign on structural shifts. PPA decays in 8-16 weeks — continuous monitoring converts PPA from a project into a permanent operating capability.

DESIGN → MONITOR → AUTO-ADJUST (minor drift)
                 → REDESIGN  (structural shift: new competitor, inflation reset, channel restructuring)
                 → ZONE MAP  (TomTom: geographic deviation → zone-specific intervention)

Scripts: channel_kpis.py, early_warning_system.py, auto_pricing_rules.py, optimization_dashboard.py, alert_logger.py | Ref: continuous_optimization_methodology.md | MCP: TomTom (always active — zone-level KPI map)

Outputs: SKU traffic-light scorecard (green/yellow/red per KPI) + CUSUM alert log + auto-pricing recs by channel/zone + TomTom zone map + 4-week optimization cycle report + inline dashboard | Routes to → ppa-assortment-diagnosis (structural shift), executive-growth-memo, weekly-control-tower

---

Output catalog

📊 Inline HTML dashboards (primary output — all analytical skills)

Skill	Dashboard contents
mmm-modeling	Channel contribution, response curves, posterior distributions, scenario simulator
customer-lifetime-value	LTV distribution, cohort curves, retention impact slider
customer-segmentation-clustering	Scatter plots, RFM heatmap, persona cards
market-basket-analysis	Association network, lift matrix, shelf layout optimizer
price-demand-optimization	Elasticity curve, optimal price, revenue impact
recommender-systems	Model comparison, Top-K, evaluation metrics
response-uplift-modeling	Decile lift, four-quadrant scatter, ROI threshold
survival-analysis-marketing	Survival curves, hazard ratios, time-to-event
media-routing-planner	Channel allocation, saturation curves, projected outcomes
weekly-control-tower	Multi-account WBR cards, anomaly flags, decisions queue
ppa-assortment-diagnosis	Price-pack competitive map, white space heatmap, TomTom zone map
price-elasticity-modeling	Demand curve, breakpoints, geographic elasticity heatmap
price-threshold-detection	Threshold map, regime comparison, proximity risk gauge
ppa-value-perception	WTP curves, decision hierarchy, perception failure alerts
ppa-financial-model	P&L waterfall, cannibalization matrix, sensitivity tornado
ppa-pack-size-leverage	Decision tree, 6-scenario simulator, cash margin optimizer
ppa-continuous-optimization	SKU traffic lights, CUSUM log, TomTom zone KPI map

📄 File deliverables

Type	Skill	Format
RFP pitch response	rfp-submission	.pptx + .docx + .xlsx
QBR package	qbr-generator	.pptx (24-32 slides) + .xlsx (6-8 tabs) + .docx
Executive memos	executive-growth-memo	.docx (one-page)
Change orders	change-order-generator	.docx (client-ready)
Pre-launch QA report	campaign-launch-qa	.pdf (sign-off ready)
Pod structure	fte-capacity-sizing	.xlsx (capacity model)
P&L simulation	margin-simulation	.xlsx (Monte Carlo)
Asset matrix	creative-supply-planner	.xlsx (production tracker)
PPA financial model	ppa-financial-model	.xlsx (SKU P&L + cannibalization)
Tenant context	client-memory-synthesizer	.md (drop-in for Claude Projects)
Input templates	data-intake-normalizer	.xlsx (per-skill templates)

📋 JSON anchor outputs (skill chaining)

Every analytical skill emits a structured JSON consumed directly by the next skill:

{
  "skill": "price-elasticity-modeling",
  "sku": "Pack 500g",
  "elasticity": -1.84,
  "threshold_detected": true,
  "threshold_price": 49.90,
  "confidence": 0.91,
  "anchor_for": ["ppa-financial-model", "ppa-pack-size-leverage", "price-threshold-detection"]
}

---

Real-world usage

Production deployment at a major holding-network agency in LATAM, serving global enterprise accounts:

• Pitch responses — RFP to deck in one conversation. Multi-scenario commercial models included.
• Weekly control towers — WBR generation across multiple accounts, replacing 2 FTEs × 6 hours/week.
• MMM scenario planning — Bayesian reallocation (PyMC), Holt-Winters/Granger/VIF validation, shipped as client deliverables.
• Margin recovery — Monte Carlo P&L surfacing six-figure scope leakage per account.
• QBRs — data → narrative → PPTX → XLSX appendix in a single conversation.

For 5 detailed end-to-end workflow examples, see docs/SHOWCASE.md.

---

Installation

# Option 1 — Claude Code (recommended)
/plugin marketplace add polanyi-tech/enterprise-marketing-os
/plugin install enterprise-marketing-os@polanyi-tech

# Option 2 — Claude.ai web / desktop
# 1. git clone https://github.com/polanyi-tech/enterprise-marketing-os.git
# 2. Settings → Capabilities → Skills → Upload each skills/ subfolder

# Option 3 — Claude API
# Reference each SKILL.md path directly via the Agent Skills API

---

Tech stack

Layer	Libraries
Bayesian modeling	PyMC-Marketing, PyMC, ArviZ
Classical ML & stats	scikit-learn, lifetimes, mlxtend, lifelines, scipy, statsmodels
Output generation	python-pptx, python-docx, openpyxl, ReportLab
Visualization	Inline HTML/SVG dashboards, matplotlib, Plotly
MCP integrations	Supermetrics, Plinth, Adspirer, Google Drive/Gmail/Calendar, Adobe AJO/AEM, Salesforce, Figma, Stripe, TomTom, S&P Global

---

Methodology

• MMM: PyMC-Marketing, Meridian (Google), WARC Multiplier Effect
• CLV: Fader & Hardie BG/NBD + Gamma-Gamma; Pfeifer & Carraway Markov chain
• Uplift: Radcliffe & Surry (2004) two-model; four-quadrant persuadables framework
• PPA / RGM: EY Price-Pack Architecture Framework; Polestar 7-Step PPA Methodology
• Price thresholds: Hansen (2000) threshold regression; Page (1954) CUSUM
• WTP: Lancaster (1966) attribute utility; McFadden (1974) conditional logit
• Pricing: Phillips (2005) revenue management; Talluri & van Ryzin (2004) EMSR
• Recommenders: Koren & Bell (2011) matrix factorization; Cremonesi et al. (2010) evaluation
• Market basket: Agrawal & Srikant (1994) Apriori; Han et al. (2000) FP-Growth
• Survival: Kaplan & Meier (1958); Cox (1972) proportional hazards
• Reference text: Katsov (2017) "Introduction to Algorithmic Marketing"

---

What this is NOT

• Not a replacement for human judgment. The 70/30 model is explicit. Strategy, creative concept, relationships — human. The other 70% — this OS.
• Not a black box. Every model is inspectable, every script runs in Claude's sandbox, every assumption is logged.
• Not vendor lock-in. Open-source. Your data never leaves your Claude environment. All MCP integrations are optional.

---

Roadmap

• v1.2 — competitive-intelligence skill (SimilarWeb/SEMrush MCP)
• v1.3 — creative-effectiveness-scoring (LLM-as-judge, Cannes/Effie rubrics)
• v1.4 — retail-media-network planning (Amazon Ads, Walmart Connect)
• v2.0 — Multi-tenant client memory (vector store + structured client briefs)

---

Contributing

See CONTRIBUTING.md. Requirements: methodological rigor (citations required), five-cycle compatibility, no vendor lock-in in core path.

---

About

Built by Andrés Felipe Gutiérrez Henao (Axiom Nexar) — agency executive and founder of Polanyi, an AI-native marketing infrastructure company. Plinth, Polanyi's flagship product, is an MCP-based marketing operating system.

LinkedIn · polanyi.tech · GitHub Issues

---

MIT License · Free to fork, deploy in-house, extend. Attribution appreciated.