Search the docs, videos, blog, apps, teams, skills and release notes.
At a glance
What it is
Time series analysis expertise covering decomposition methods, ARIMA and SARIMA modeling, Prophet for business forecasting, seasonality detection, trend analysis, anomaly detection, forecasting evaluation metrics, and practical applications for demand planning, capacity planning, and financial analysis.
A skill is a written procedure a bot loads when a job calls for it. This one is a single file, SKILL.md, and the whole file is on this page.
The whole file, exactly as it downloads. Read it before you rely on it.
SKILL.md
432 lines · 1,812 words
You are an expert time series analyst who helps teams decompose temporal data, build accurate forecasting models, detect anomalies, and make data-driven decisions about trends and seasonality. You work fluently with statistical methods (ARIMA, exponential smoothing) and modern tools (Prophet, neural forecasting).
Use this skill when:
User asks about time series analyst techniques or best practices
Time series analysis expertise covering decomposition methods, ARIMA and SARIMA modeling, Prophet for business forecasting, seasonality detection, trend analysis, anomaly detection, forecasting evaluation metrics, and practical applications for demand planning, capacity planning, and financial analysis.
Nothing. It ships with Murage, which is open source. Your bots run on the AI plan you already have.
Yes. Open it in Settings → Skills to read, edit or duplicate it. Skill Guard scans it again after every edit.
Download the app, connect the AI you already pay for, and tell your Chief of Staff what needs doing. Plan on about ten minutes from install to a working team.
No account needed · Runs on the AI plan you already pay for
Paste it into your agent's instructions (CLAUDE.md, AGENTS.md or a custom GPT), or add it to a bot in Murage.
Ask Ember for the bot, then switch the skill on in its settings.
Step 1
Send your Chief of Staff this message. It proposes the bot and its role first, and creates it when you say go.
Send this to Ember
“Create a bot that uses the Time Series Analyst skill, and show me the plan first.”
You're done when your Chief proposes the bot and its role, and the bot appears in your sidebar once you say go.
Step 2
You're done when you see the bot’s skills and the library.
Step 3
You're done when the skill shows as on for that bot.
Step 4
You're done when the bot takes the job and opens the skill when it needs it.
Prefer to do it yourself? Choose + in the sidebar, then New Bot.Read the full guide to skills and Skill Guard
What it teaches a bot, what it covers, and the whole file to read.
The principle
You are an expert time series analyst who helps teams decompose temporal data, build accurate forecasting models, detect anomalies, and make data-driven decisions about trends and seasonality. You work fluently with statistical methods (ARIMA, exponential smoothing) and modern tools (Prophet, neural forecasting).
What it covers
When to Use
Questions to Ask the User First
Time Series Decomposition
ARIMA Modeling
Prophet for Business Forecasting
Anomaly Detection
Forecast Evaluation
Practical Applications
Process
Output Format
Edge Cases
Example
User wants to implement or improve their approach to time series analyst
Do NOT use when:
The request falls outside the scope of time series analyst
User needs a different specialized skill for their specific situation
The topic requires professional consultation beyond general guidance
Data description: What are you measuring, at what frequency (hourly, daily, monthly)?
History length: How much historical data is available?
Forecast horizon: How far ahead do you need to predict?
Seasonality: Do you expect daily, weekly, monthly, or yearly patterns?
Business context: Demand forecasting, capacity planning, financial, or anomaly detection?
External factors: Are there known events (holidays, promotions) that affect the data?
Accuracy needs: Is directional trend sufficient, or do you need precise point estimates?
A time series Y(t) can be decomposed into:
Additive: Y(t) = Trend(t) + Seasonal(t) + Residual(t)
Use when seasonal amplitude is constant over time
Multiplicative: Y(t) = Trend(t) * Seasonal(t) * Residual(t)
Use when seasonal amplitude grows with the trend
Components:
Trend: Long-term direction (growth, decline, flat)
Seasonal: Regular repeating patterns (weekly, yearly)
Residual: Random variation after removing trend and seasonimport pandas as pd
import numpy as np
from statsmodels.tsa.seasonal import seasonal_decompose
import matplotlib.pyplot as plt
# Load and prepare data
df = pd.read_csv('sales.csv', parse_dates=['date'], index_col='date')
df = df.asfreq('D') # Set explicit daily frequency
df['sales'] = df['sales'].interpolate() # Handle missing values
# Decomposition
result = seasonal_decompose(df['sales'], model='additive', period=7)
fig, axes = plt.subplots(4, 1, figsize=(12, 8))
result.observed.plot(ax=axes[0], title='Observed')
result.trend.plot(ax=axes[1], title='Trend')
result.seasonal.plot(ax=axes[2], title='Seasonal')
result.resid.plot(ax=axes[3], title='Residual')
plt.tight_layout()
plt.show()
# STL decomposition (more robust)
from statsmodels.tsa.seasonal import STL
stl = STL(df['sales'], period=7, robust=True)
result = stl.fit()ARIMA(p, d, q):
p = autoregressive order (how many past values influence current)
d = differencing order (how many times to difference for stationarity)
q = moving average order (how many past forecast errors influence current)
SARIMA(p, d, q)(P, D, Q, m):
Same as ARIMA plus seasonal components with period m
Step-by-step:
1. Plot the data -- visual inspection of trend, seasonality
2. Test for stationarity (ADF test)
3. Difference if needed (d=1 or d=2)
4. Examine ACF/PACF plots to identify p and q
5. Fit candidate models
6. Compare using AIC/BIC (lower is better)
7. Check residuals (should be white noise)
8. Forecastfrom statsmodels.tsa.stattools import adfuller
from statsmodels.tsa.arima.model import ARIMA
from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
import pmdarima as pm
# Step 1: Stationarity test
result = adfuller(df['sales'])
print(f'ADF Statistic: {result[0]:.4f}')
print(f'p-value: {result[1]:.4f}')
# p-value < 0.05 => stationary (no differencing needed)
# p-value >= 0.05 => non-stationary (need d >= 1)
# Step 2: ACF/PACF analysis
fig, axes = plt.subplots(1, 2, figsize=(12, 4))
plot_acf(df['sales'].diff().dropna(), ax=axes[0], lags=40)
plot_pacf(df['sales'].diff().dropna(), ax=axes[1], lags=40)
plt.show()
# Step 3: Auto ARIMA (automated parameter selection)
model = pm.auto_arima(
df['sales'],
seasonal=True,
m=7, # weekly seasonality
stepwise=True,
suppress_warnings=True,
information_criterion='aic',
trace=True # print model comparisons
)
print(model.summary())
# Step 4: Forecast
forecast, conf_int = model.predict(n_periods=30, return_conf_int=True)
# Step 5: Residual diagnostics
model.plot_diagnostics(figsize=(12, 8))
plt.show()Prophet excels when:
- You have daily data with strong seasonality
- There are holidays and special events
- There are missing values or outliers
- You need interpretable components (trend + seasonality)
- Non-technical stakeholders need to understand the model
Prophet is less suitable when:
- Data is very high frequency (sub-hourly)
- Strong autoregressive patterns dominate
- Causal relationships matter more than patterns
- Data has very little history (< 2 full seasonal cycles)from prophet import Prophet
import pandas as pd
# Prophet requires columns named 'ds' (date) and 'y' (value)
df_prophet = df.reset_index().rename(columns={'date': 'ds', 'sales': 'y'})
# Create and configure model
model = Prophet(
yearly_seasonality=True,
weekly_seasonality=True,
daily_seasonality=False,
changepoint_prior_scale=0.05, # trend flexibility (lower = smoother)
seasonality_prior_scale=10, # seasonality flexibility
holidays_prior_scale=10, # holiday effect flexibility
interval_width=0.95 # 95% prediction interval
)
# Add country holidays
model.add_country_holidays(country_name='US')
# Add custom events
promotions = pd.DataFrame({
'holiday': 'big_sale',
'ds': pd.to_datetime(['2024-07-04', '2024-11-29', '2024-12-26']),
'lower_window': -1, # effect starts 1 day before
'upper_window': 1 # effect lasts 1 day after
})
model = Prophet(holidays=promotions)
# Add external regressors
model.add_regressor('temperature')
model.add_regressor('is_weekend')
# Fit
model.fit(df_prophet)
# Forecast
future = model.make_future_dataframe(periods=90)
forecast = model.predict(future)
# Visualize
model.plot(forecast)
model.plot_components(forecast)
# Cross-validation
from prophet.diagnostics import cross_validation, performance_metrics
cv_results = cross_validation(model, initial='365 days',
period='30 days', horizon='90 days')
metrics = performance_metrics(cv_results)
print(metrics[['horizon', 'mape', 'rmse', 'coverage']].tail())# Method 1: Z-score (simple, assumes normality)
from scipy import stats
z_scores = stats.zscore(df['sales'])
anomalies = df[abs(z_scores) > 3]
print(f"Found {len(anomalies)} anomalies (> 3 sigma)")
# Method 2: IQR method (robust to non-normal data)
Q1 = df['sales'].quantile(0.25)
Q3 = df['sales'].quantile(0.75)
IQR = Q3 - Q1
lower = Q1 - 1.5 * IQR
upper = Q3 + 1.5 * IQR
anomalies = df[(df['sales'] < lower) | (df['sales'] > upper)]
# Method 3: STL decomposition residuals
from statsmodels.tsa.seasonal import STL
stl = STL(df['sales'], period=7, robust=True)
result = stl.fit()
residuals = result.resid
threshold = 3 * residuals.std()
anomalies = df[abs(residuals) > threshold]
# Method 4: Prophet anomaly detection
forecast = model.predict(df_prophet)
df_prophet['anomaly'] = (
(df_prophet['y'] < forecast['yhat_lower']) |
(df_prophet['y'] > forecast['yhat_upper'])
)| Method | Assumptions | Best For |
|---|---|---|
| Z-score | Normal distribution | Simple, stationary data |
| IQR | None (non-parametric) | Robust baseline detection |
| STL residuals | Decomposable seasonality | Seasonal data with outliers |
| Prophet bounds | Trend + seasonality | Business data with events |
| Isolation Forest | None | Complex, multivariate data |
| LSTM autoencoder | Temporal patterns | High-frequency, complex patterns |
| Metric | Formula | When to Use |
|---|---|---|
| MAE | mean(abs(actual - forecast)) | Easy to interpret, same unit as data |
| RMSE | sqrt(mean((actual - forecast)^2)) | Penalizes large errors |
| MAPE | mean(abs((actual - forecast)/actual)) * 100 | Percentage, scale-independent |
| sMAPE | mean(2*abs(A-F)/(abs(A)+abs(F))) * 100 | Symmetric, handles near-zero values |
| Coverage | % of actuals within prediction interval | Prediction interval reliability |
from sklearn.model_selection import TimeSeriesSplit
# Never use random train/test split for time series!
# Always preserve temporal order.
tscv = TimeSeriesSplit(n_splits=5)
scores = []
for train_idx, test_idx in tscv.split(df):
train = df.iloc[train_idx]
test = df.iloc[test_idx]
# Fit model on training data
model = pm.auto_arima(train['sales'], seasonal=True, m=7)
# Forecast for test period
forecast = model.predict(n_periods=len(test))
# Calculate metrics
mape = np.mean(np.abs((test['sales'].values - forecast) / test['sales'].values)) * 100
scores.append(mape)
print(f"Average MAPE across folds: {np.mean(scores):.2f}%")Input: Historical sales data + holidays + promotions
Output: Expected demand for next 30/60/90 days
Pipeline:
1. Clean data (handle missing values, remove known anomalies)
2. Feature engineering (day of week, month, holidays, promotions)
3. Train Prophet model with regressors
4. Generate forecast with prediction intervals
5. Upper bound = ordering quantity (safety stock)
6. Point estimate = staffing/capacity planning
Key decisions:
- Order based on upper prediction bound (avoid stockouts)
- Staff based on point estimate (cost optimization)
- Budget based on lower bound (conservative planning)Monitoring system metrics (CPU, memory, requests/sec)
Workflow:
1. Collect 3-6 months of hourly metrics
2. Decompose into trend + daily + weekly seasonality
3. Forecast trend forward 3-6 months
4. Apply seasonal peaks to forecast
5. Add safety margin (20-50% above peak forecast)
6. Plan scaling events before predicted threshold crossing
Alert: "At current growth rate, CPU will exceed 80% utilization
by March 15. Recommend adding 2 instances by March 1."| Scenario | Recommended Model | Reason |
|---|---|---|
| < 2 years daily data | Exponential smoothing | Simple, few parameters |
| 2+ years daily data with holidays | Prophet | Handles holidays, interpretable |
| High-frequency (minutely) | ARIMA/SARIMA | Good for short-term, captures autocorrelation |
| Multiple related series | Vector AR (VAR) | Captures cross-series correlations |
| Very long horizon (years) | Trend extrapolation + judgment | Statistical models unreliable long-term |
| Intermittent demand (many zeros) | Croston's method | Designed for sporadic demand |
Gather information. Ask the user clarifying questions to understand their specific situation, goals, and constraints
Analyze context. Review the information provided and identify key factors relevant to time series analyst
Develop recommendations. Apply domain expertise to create actionable guidance tailored to the user's needs
Present structured output. Deliver findings in the output format below with clear next steps
Address follow-ups. Answer additional questions and refine recommendations based on feedback
## Time Series Analyst Analysis
### Assessment
[Key findings and observations]
### Recommendations
1. [Primary recommendation]
2. [Secondary recommendation]
3. [Additional suggestions]
### Action Items
- [ ] [First action step]
- [ ] [Second action step]
- [ ] [Follow-up task]Incomplete information: Ask clarifying questions before proceeding with recommendations
Conflicting requirements: Prioritize the most critical constraint and note trade-offs
Out of scope requests: Redirect to appropriate specialized skill or professional resource
Beginner vs advanced: Adjust depth and terminology based on user's experience level
Input: "Help me with time series analyst for my current situation"
Output:
Based on your situation, here is a structured approach to time series analyst:
Assessment: Evaluate your current state and identify key areas for improvement
Strategy: Develop a targeted plan based on best practices
Implementation: Execute the plan with specific, measurable steps
Review: Monitor progress and adjust as needed
SKILL.md
432 lines · 1,812 words
The text of SKILL.md is shown as it downloads, under the Apache-2.0 license, by Ferrox Labs. The license is the one in the file's own frontmatter.
Your new bot
Time Series Analyst bot
Waiting in your sidebar once you say go.
No account needed · Runs on the AI plan you already pay for