playbooks

home / skills / a5c-ai / babysitter / supply-chain-simulation-engine

supply-chain-simulation-engine skill

/plugins/babysitter/skills/babysit/process/specializations/domains/business/supply-chain/skills/supply-chain-simulation-engine

This skill simulates end-to-end supply chains, enables what-if analysis and policy optimization using discrete-event modeling to inform decisions.

npx playbooks add skill a5c-ai/babysitter --skill supply-chain-simulation-engine

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
3.9 KB
---
name: supply-chain-simulation-engine
description: Supply chain discrete-event simulation for scenario testing and optimization
allowed-tools:
  - Read
  - Write
  - Glob
  - Grep
  - Bash
metadata:
  specialization: supply-chain
  domain: business
  category: cross-functional
  priority: future
---

# Supply Chain Simulation Engine

## Overview

The Supply Chain Simulation Engine provides discrete-event simulation capabilities for testing supply chain scenarios, policies, and disruptions. It enables what-if analysis, Monte Carlo integration, and performance optimization through simulation-based experimentation.

## Capabilities

- **End-to-End Supply Chain Simulation**: Full network modeling
- **What-If Scenario Testing**: Policy and configuration testing
- **Disruption Impact Modeling**: Shock and recovery simulation
- **Policy Optimization Testing**: Inventory, sourcing policy experiments
- **Monte Carlo Integration**: Stochastic variability modeling
- **Sensitivity Analysis**: Parameter impact assessment
- **Animation and Visualization**: Visual simulation playback
- **Performance Metric Tracking**: KPI measurement through simulation

## Input Schema

```yaml
simulation_request:
  network_model:
    nodes: array
      - node_id: string
        type: string              # supplier, plant, DC, customer
        capacity: float
        processing_time: object
        inventory_policy: object
    arcs: array
      - from_node: string
        to_node: string
        lead_time: object
        cost: float
  demand_model:
    patterns: array
    variability: object
    events: array                 # promotions, seasonality
  supply_model:
    reliability: object
    variability: object
  simulation_parameters:
    run_length: integer
    warm_up_period: integer
    replications: integer
    random_seed: integer
  scenarios: array
    - scenario_name: string
      parameters: object
```

## Output Schema

```yaml
simulation_output:
  results_summary:
    scenarios: array
      - scenario_name: string
        kpis:
          fill_rate: object
          inventory_turns: object
          lead_time: object
          cost: object
        confidence_intervals: object
  detailed_results:
    time_series: array
    event_log: array
    bottleneck_analysis: object
  scenario_comparison:
    comparison_matrix: object
    statistical_tests: object
    best_scenario: string
  sensitivity_results:
    parameters_tested: array
    impact_analysis: object
    critical_parameters: array
  optimization_insights:
    recommendations: array
    trade_offs: object
  visualization_data:
    animation_data: object
    charts: array
```

## Usage

### Inventory Policy Simulation

```
Input: Network model, demand patterns, inventory policies
Process: Simulate multiple policy scenarios
Output: Policy comparison with fill rate and cost
```

### Disruption Impact Analysis

```
Input: Current network, disruption scenario
Process: Simulate disruption and recovery
Output: Impact quantification and recovery timeline
```

### Network Configuration Testing

```
Input: Alternative network configurations
Process: Simulate each configuration
Output: Configuration comparison and recommendation
```

## Integration Points

- **Simulation Platforms**: AnyLogic, Simul8, SimPy
- **Data Sources**: ERP, planning system data
- **Optimization Tools**: Combine with optimization
- **Visualization Tools**: Animation and dashboards
- **Tools/Libraries**: AnyLogic, Simul8, SimPy, discrete-event simulation

## Process Dependencies

- Supply Chain Network Design
- Business Continuity and Contingency Planning
- Capacity Planning and Constraint Management

## Best Practices

1. Validate model against historical data
2. Use adequate replications for statistical validity
3. Include warm-up period for steady-state analysis
4. Document model assumptions
5. Involve operations in model validation
6. Use sensitivity analysis to identify key drivers

Overview

This skill provides a discrete-event supply chain simulation engine for testing scenarios, policies, and disruptions. It supports Monte Carlo experimentation, sensitivity analysis, and visualization to quantify performance trade-offs and identify robust strategies. Use it to compare policies, model shocks, and generate actionable optimization insights.

How this skill works

You define a network model of nodes and arcs, supply and demand behavior, and simulation parameters (run length, replications, warm-up). The engine runs repeated stochastic replications, logs events and time series, and computes KPIs (fill rate, lead time, inventory turns, cost) with confidence intervals. Outputs include scenario comparisons, sensitivity analysis, bottleneck detection, optimization recommendations, and visualization-ready animation data.

When to use it

  • Evaluating inventory or sourcing policy alternatives before operational rollout
  • Quantifying impact and recovery timelines for supply disruptions
  • Comparing network configurations (locations, capacities, routing)
  • Validating planning assumptions against historical performance
  • Prioritizing investments by sensitivity and trade-off analysis

Best practices

  • Validate the simulation model against historical data and known events
  • Use sufficient replications and include a warm-up period for steady-state metrics
  • Document assumptions, stochastic drivers, and model boundaries clearly
  • Engage operations and planning teams for realistic policy definitions
  • Run sensitivity analysis to surface critical parameters and reduce model complexity

Example use cases

  • Inventory policy experiment: simulate reorder points, safety stock, and service targets to find cost-fill rate trade-offs
  • Disruption scenario: inject supplier or transport failures to measure fill-rate decay and recovery time
  • Network redesign: test adding or removing distribution centers to evaluate lead time and cost impacts
  • What-if Monte Carlo: quantify KPI distributions under demand and supply variability
  • Bottleneck analysis: identify capacity or process constraints and validate mitigation plans

FAQ

What inputs are required to run a scenario?

A network model (nodes, arcs, capacities), demand and supply models (patterns and variability), simulation parameters (run length, replications), and scenario parameter overrides.

How are results presented and validated?

Results include KPI summaries with confidence intervals, time-series and event logs, scenario comparison matrices, sensitivity outputs, and visualization data for animation and charts; validate by comparing simulated outputs to historical metrics.