monte-carlo-performance-diagnosis
Lets your agent diagnose performance issues in data pipelines. It investigates slowness and costs using Monte Carlo to find the cause.
What it does
This tool helps find and understand why your data pipelines are slow or expensive. It investigates issues across different systems to pinpoint the root cause.
When to use it
- ✓When a data pipeline is taking longer than usual.
- ✓To find out which queries are consuming the most resources.
- ✓If the performance of your data processes has recently worsened.
Example of what to ask your AI
“Why is my data pipeline so slow today?”
Want more? Open the sections below.
How to use
The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.
Skill link
Ready-to-paste message
How it works
The tool first looks for general problems across your data systems. Then, it links these issues to the affected tables and finally investigates deeply to find the exact cause.
Installation
Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.
In the terminal (Claude Code, Codex, Cursor), in your project folder:
npx skills add sickn33/agentic-awesome-skills --skill monte-carlo-performance-diagnosisOr download just the file:
curl -L https://raw.githubusercontent.com/sickn33/agentic-awesome-skills/main/plugins/agentic-awesome-skills-claude/skills/monte-carlo-performance-diagnosis/SKILL.md -o SKILL.mdTechnical content (original SKILL.md)
Original text by the author, straight from GitHub.
Bundled upstream support
Supporting files are included at skill-relative paths. See UPSTREAM-NOTICE.md for their pinned sources, licenses, hashes, and import changes.
Monte Carlo Performance Diagnosis Skill
This skill helps diagnose data pipeline performance issues using Monte Carlo's cross-platform observability data. It works across Airflow, dbt, Databricks, and warehouse query engines to find bottlenecks, detect regressions, and identify root causes.
Monte Carlo tool routing (required): Always call Monte Carlo MCP tools through this plugin's bundled server, whose fully-qualified tool names are
mcp__plugin_mc-agent-toolkit_monte-carlo-mcp__<tool>(e.g.mcp__plugin_mc-agent-toolkit_monte-carlo-mcp__get_alerts). Bare tool names used in this skill (get_alerts,search,get_table, …) refer to that bundled server. If the session also has a separately-configuredmonte-carlo-mcpserver, do not route to it — it may point at a different endpoint or credentials.
Reference files live next to this skill file. Use the Read tool (not MCP resources) to access them:
- Tiered investigation approach:
references/investigation-tiers.md(relative to this file) - Query analysis patterns:
references/query-analysis.md(relative to this file)
When to activate this skill
Activate when the user:
- Asks about slow pipelines, jobs, or queries
- Wants to find expensive or costly queries
- Mentions performance regressions or degradation
- Asks "why is this pipeline slow?" or "what's using the most compute?"
- Wants to compare performance over time or find bottleneck tasks
- Asks about failed or futile query patterns
When NOT to activate this skill
Do not activate when the user is:
- Investigating data quality issues (use the prevent skill)
- Looking at storage costs (use the storage-cost-analysis skill)
- Creating monitors (use the monitoring-advisor skill)
- Just querying data or exploring table contents
Prerequisites
The following MCP tools must be available (connect to Monte Carlo's MCP server):
Discovery tools (Tier 1):
get_jobs_performance-- find slow/failing jobs across Airflow, dbt, Databricksget_top_slow_queries-- find slowest query groups by total runtime
Bridge tool:
get_tables_for_job-- convert job MCONs to table MCONs
Diagnosis tools (Tier 2):
get_tasks_performance-- drill into a job's individual tasksget_change_timeline-- unified timeline of query changes, volume shifts, Airflow/dbt failuresget_query_rca-- root cause analysis for failed/futile queriesget_query_latency_distribution-- latency trend over timeget_asset_lineage-- trace upstream/downstream impact
Supporting tools:
get_warehouses-- list available warehouses
Workflow
Step 1: Identify the scope
Determine what the user wants to investigate:
- Specific job/pipeline: User mentions a job name or pipeline
- Specific table: User mentions a table that's slow to update
- General discovery: User wants to find what's slow
Call get_warehouses to list available warehouses. Match the user's context to a warehouse.
Step 2: Tier 1 -- Discovery
If you don't have specific MCONs to investigate, start with discovery:
Find slow jobs: Call
get_jobs_performancewith optionalintegration_typefilter (AIRFLOW, DATABRICKS, DBT) if the user specifies a platform.- Results include: job name, average duration, trend (7-day), run count, failure rate
- Look for: high
avgDuration, negativerunDurationTrend7d, high failure rates
Find expensive queries: Call
get_top_slow_querieswith optionalwarehouse_idandquery_type("read" for SELECTs, "write" for INSERT/CREATE/MERGE).- Results include: query hash, total runtime, average runtime, run count
- Look for: queries with high total runtime or high individual execution time
Present the top findings to the user before drilling deeper. A typical investigation needs only 3-7 tool calls.
If both discovery tools return no results: Tell the user no performance issues were found in the current time window. Suggest broadening the scope (different warehouse, longer time range, or a different platform filter).
Step 3: Bridge -- Job to Tables
After Tier 1 identifies problematic jobs, convert to table MCONs:
…
FAQ
What systems does this tool analyze?
It works with systems like Airflow, dbt, Databricks, and your data warehouse query engines.
What are 'data pipelines'?
They are sequences of automated tasks that process and move data. Think of them as assembly lines for information.
What are 'queries'?
They are commands you send to a database to retrieve or manipulate information. It's like asking a question to your database.
Details
Original description by the author
Diagnoses pipeline performance issues -- slow jobs, expensive queries, latency trends -- using Monte Carlo's cross-platform observability. Uses a tiered investigation approach: discover problems, bridge to affected tables, then drill into root causes.
Popularity
- GitHub stars
- 48k
- Ranking position
- #3630
- License
- MIT
- Updated
- 10/15/2026
Comments
- …
More skills from this repository
00-andruia-consultant
Helps your agent start or improve AI projects. It analyzes code, suggests tools, and creates action plans in Spanish.
sickn33/agentic-awesome-skills
007
Lets your agent perform security audits and threat modeling. It's useful for protecting projects against attacks and vulnerabilities.
sickn33/agentic-awesome-skills
10-andruia-skill-smith
Helps your agent create or improve AI tools. It defines how tools work, writes documentation, and validates the structure.
sickn33/agentic-awesome-skills
20-andruia-niche-intelligence
Lets your agent create a summary about a specific industry. It's useful for understanding the context, rules, usage patterns, and risks of a project, using reliable sources.
sickn33/agentic-awesome-skills
Similar skills
data-throughput-accelerator
Makes your agent speed up the movement of large data volumes. It finds bottlenecks and ensures data is transferred quickly and correctly.
affaan-m/ECC
inventory-demand-planning
Helps your agent predict product demand in stores. It optimizes stock and plans when to run promotions to sell more.
affaan-m/ECC
market-research
Helps your agent conduct market research and competitive analysis. Provides summaries with source attribution.
affaan-m/ECC