DEV Community: Alpha Info

Building self-correcting time-series analysis for Claude Code: 50% 100% accuracy with no manual config

Alpha Info — Sun, 26 Apr 2026 08:29:18 +0000

TL;DR: I built a Claude Code skill that gives Claude structural eyes for time-series. The interesting bits: (1) it auto-tunes its own configuration via leave-one-out cross-validation (50% → 100% on real PhysioNet ECG), and (2) when the first call returns borderline, the skill self-corrects with a 4-stage cascade (alt-domain → fingerprint dim inspection → sliding-window escalation). Validated across 30 use cases on real and shape-realistic data. Free tier, MIT licensed, one-line install.

The problem nobody talks about

Most LLM agents fail silently on time-series.

Ask Claude "is this CSV column anomalous?" and it'll happily write a scipy.stats.zscore or numpy rolling-mean check. The code runs. The answer comes back. But the methodology is fragile: Z-score detects mean shifts, not regime changes. Rolling means smear short events. Both miss when the structure of a signal changes — same mean, same variance, different shape.

This is the LLM-as-data-scientist gap. The model picks the easiest tool, not the right one.

What I built

AlphaInfo for Claude is a Claude Code skill that wires the AlphaInfo Structural Intelligence API into Claude conversations. The API perceives signal structure (5-D fingerprint: local/fractal/spectral/transition/trend dimensions). The skill teaches Claude when and how to reach for it.

A typical interaction:

You: "I have CPU metrics from yesterday — anything weird?"

Claude: [calls quick_anomaly()]
         "Critical anomaly detected at 14:00, severity 75/100. The sustained
          spike pattern differs structurally from your normal diurnal cycle.
          Audit ID: 5533a276-... (replayable for compliance)."

One HTTP call. Calibrated severity. Audit trail. No statistical code generation.

The interesting part #1: smart_anomaly() is a 4-stage self-correcting cascade

Most "AI tooling" fails because the AI picks the wrong knob and doesn't know it. So I built a cascade that detects borderline results and auto-escalates:

from lib.autotune import smart_anomaly

result = smart_anomaly(client, signal, plan, sampling_rate=10.0)

Stages:

Quick check (1 quota). If severity > 65 → done.
Alternative domains (3 quota). API has 10 domain calibrations (finance, biomedical, security, etc.). If user picked wrong, try alternatives.
Fingerprint dim inspection (1 quota). If scalar score is borderline, look at the 5-D fingerprint. Sometimes ONE dimension dropped sharply (e.g., sim_transition=0.48 for added harmonics) while the scalar averaged it out.
Sliding-window escalation (5-10 quota). For localized regime changes, the global view misses them but a window-by-window comparison nails the boundary.

The cascade pays only for what's needed. A clean anomaly costs 1 quota. A subtle bearing-wear case (which I'll show below) goes through all 4 stages for 11 quota.

Validated lifts

I ran this against intentionally hard cases:

Case	Naive single call	After cascade	Method that won
k8s pod restart spike	sev 42 (attention)	sev 92 critical + window 115-145	Stage 4 (monitor)
Bearing wear (pure spectral, stationary)	sev 20 (normal)	sev 67 alert + "sharp transitions" diagnosis	Stage 3 (fingerprint)
Climate heat wave (60-day temp)	sev 50 borderline	sev 75 alert + window 15-45	Stage 3+4
Deploy regression (latency +30%, same shape)	sev 19 normal	sev 61 alert + amplitude-shift warning	Stage 3+4

The bearing wear case is my favorite: a pure spectral change (added harmonics at same total energy) that any naive scalar comparison misses. The fingerprint inspection sees sim_transition=0.48 and produces a specific diagnosis: "sharp transitions / abrupt events / regime boundary."

The skill was perceiving the change the whole time — just not in the scalar score. Stage 3 unlocks it.

The interesting part #2: autotune_classifier hits 100% CV without manual config

Classification with structural fingerprints is competitive with trained classifiers — IF you pick the right reference signal and classifier. For a long time, this was a manual tuning game.

I tested on real PhysioNet MIT-BIH ECG record 208 (Normal vs PVC arrhythmia):

Naive setup (sine reference + raw centroid distance): 50% accuracy (random)
Manual tuning (mean-beat reference + LDA on standardized fingerprints): 95%
autotune_classifier (8-combo cross-validation): 100% CV / 80% held-out, 24 quota total

The auto-tuner enumerates {reference: mean_class_0, median_class_0, sine} × {classifier: centroid_raw, centroid_norm, kNN, LDA} — that's 8 combinations. Scores each via leave-one-out CV on the training set. Picks the winner. Returns a predict() closure ready to use.

from lib.autotune import autotune_classifier

# 8 N beats + 8 V beats from PhysioNet record 208
labeled = [('N', beat) for beat in n_beats[:8]] + [('V', beat) for beat in v_beats[:8]]

result = autotune_classifier(client, labeled, plan,
                              sampling_rate=360.0, domain='biomedical')

print(result['best_config'])
# {'reference_strategy': 'mean_class_0', 'classifier': 'lda_norm', 'normalize': True}
print(result['cv_accuracy'])
# 1.0

# Use the winner to classify a new beat
prediction = result['predict'](new_beat)  # 'N' or 'V'

Zero domain expertise required from the user (or Claude). The skill found the right combo automatically.

The interesting part #3: plan-aware behavior

The skill detects the user's API plan tier (Free / Starter / Growth / Pro / Enterprise) on init and adapts every call to fit the plan's caps:

plan = detect_plan(client)
# {'name': 'Free', 'caps': {
#   'max_channels': 3, 'max_batch_size': 10,
#   'max_signal_length': 10_000, 'monthly_limit': 50, ...
# }, 'remaining': 47}

When you ask the skill to do something larger than your plan allows, it auto-truncates and surfaces a contextual upgrade hint instead of returning a surprise quota error:

multi_channel(client, channels={...8 sensors...}, plan=plan)
# On Free (3-channel cap), drops 5 channels, returns:
# {
#   'delator_channel': 'airflow',
#   'channels_dropped': 5,
#   'upgrade_hint': "Capped at 3 on Free. Starter ($49/mo) lifts to 8."
# }

This is the skill acting as a conversion funnel: every limit hit is a contextual demo of what the next tier unlocks.

What this validates

I ran 30 real or shape-realistic use cases across 12 buyer segments. Key results:

Segment	Real-data validation
🐛 DevOps / SRE	CPU spikes, memory leaks, multi-service faults — all critical sev
🤖 MLOps	Model accuracy drift, feature covariate shift — alert sev 65-73
📈 Quant / Fintech	Real yfinance: SPY regime, BTC, VIX, Treasuries
🩺 Bio / Health	Real PhysioNet ECG arrhythmia: 100% CV via autotune
🛡️ Security / Protection	Account takeover (sev 84), ransomware-pattern (sev 92), credential-stuffing (sev 96)
🚀 SaaS / Product	DAU drops, conversion funnel anomalies
🏭 Industrial IoT	Multi-sensor canal delator (which-of-N is failing)

Plus Audio, Climate, Gaming, Streaming, Logistics. Full matrix in USE_CASES.md.

How to try it

One-line install:

curl -fsSL https://raw.githubusercontent.com/info-dev-13/alphainfo-claude-skill/main/install.sh | sh

The script:

Clones the skill into ~/.claude/skills/alphainfo
Installs the alphainfo Python SDK
Detects existing ALPHAINFO_API_KEY — or opens the registration page

Free tier: 50 analyses/month, no credit card. Get a key at alphainfo.io/register.

After install, just talk to Claude in any project:

"is this CSV column anomalous?"
"compare this metric before and after deploy"
"which of my 8 sensors is misbehaving?"
"when did this stream change?"

Claude will route through the skill automatically.

Repo + links

GitHub: github.com/info-dev-13/alphainfo-claude-skill
HF Space (live demo): huggingface.co/spaces/Alphainfo/alphainfo-claude-skill
AlphaInfo API docs: alphainfo.io/v1/guide
License: MIT

I'd love feedback from anyone building agent tools. What use cases am I missing? What domain probes would you want next? Comments open here, issues on GitHub.

If you find this useful, a ⭐ on the repo would help me know it's worth iterating. 🙏

Why your time-series anomaly detection probably misses the real anomaly

Alpha Info — Sun, 26 Apr 2026 08:26:51 +0000

TL;DR: Most "anomaly detection" code in production uses z-score, rolling means, or 3σ rules. These detect mean shifts, not structural changes. I built AlphaInfo — a structural intelligence API that perceives signal shape via a 5-D fingerprint. One HTTP call returns calibrated severity, alert level, and an audit-replayable analysis ID. Free tier: 50 calls/month, no credit card.

The bug nobody catches

A few months ago I was watching a team debug a production incident. Their alerting was based on:

if recent_p99_latency > rolling_mean + 3 * rolling_std:
    page_oncall()

The actual incident: a slow memory leak. P99 stayed within bounds because the leak was gradual. By the time the rolling stats updated, the system was already degraded. The alert fired at 4 AM, after every user had felt it.

The team's fix? Tighter thresholds. Which fired false positives the next week.

This is the classic anomaly detection trap: statistical tools detect mean shifts. Real-world incidents are usually structural shifts.

What "structural" means here

Same mean. Same variance. Different shape.

# Both have the same mean (0), same std (1)
# But ONE is white noise, ONE is a sine wave
import numpy as np
white = np.random.normal(0, 1, 1000)
sine = np.sin(np.linspace(0, 100, 1000))

# z-score / 3σ on either: identical
# Are they the same signal? Obviously not.

Real-world version of this:

Latency distribution before/after a deploy with same mean but new tail behavior
Sensor vibration at same total energy but with new harmonic content
User session length with same average but bimodal instead of unimodal
Error rates that look "normal" in aggregate but are clustered into bursts

z-score sees none of these. ML classifiers can — if you train one. For every metric. Forever.

The API I built

AlphaInfo is a Structural Intelligence API. You send two signals (or one for internal-change detection), it returns:

{
  "structural_score": 0.23,
  "confidence_band": "unstable",
  "change_detected": true,
  "metrics": {
    "sim_local": 0.41,
    "sim_fractal": 0.78,
    "sim_spectral": 0.18,
    "sim_transition": 0.52,
    "sim_trend": 0.85
  },
  "semantic": {
    "alert_level": "critical",
    "severity_score": 87,
    "recommended_action": "immediate_human_review",
    "summary": "⚠️ Spectral content shifted significantly..."
  },
  "analysis_id": "5533a276-b4e2-461b-8b64-03bc30d565cc"
}

The 5-D fingerprint (sim_local, sim_fractal, sim_spectral, sim_transition, sim_trend) decomposes the structural change. When sim_spectral drops to 0.18 while others stay high, you know the change is in frequency content — useful for diagnostics.

The analysis_id is replayable forever via audit_replay(). Reproduce any past analysis bit-exact. Critical for finance, biomed, and regulated domains.

Six things you can do with one API

from alphainfo import AlphaInfo
client = AlphaInfo(api_key="ai_...")

# 1. Anomaly without baseline
r = client.detect_internal_change(signal=cpu_metrics, sampling_rate=1/60)
# r.semantic.alert_level → "critical"

# 2. Compare two states
r = client.compare(signal=after_deploy, baseline=before_deploy, sampling_rate=1.0)
# r.structural_score → 0.34 (unstable)

# 3. Locate WHEN something changed in a long stream
r = client.analyze_windowed(signal=long_stream, window_size=200, step=50, sampling_rate=10.0)
# r.worst_window → (start, end, score)

# 4. Multi-sensor fault isolation (1 quota, up to 64 channels)
r = client.analyze_vector(channels={"temp": ..., "press": ..., "vib": ...},
                          baselines={"temp": ..., "press": ..., "vib": ...},
                          sampling_rate=10.0)
# r.channels["vib"].structural_score → 0.21 (the failing one)

# 5. Auto-infer the right calibration
r = client.analyze_auto(signal=mystery, baseline=ref, sampling_rate=10.0)
# r.domain_inference → {inferred: "biomedical", confidence: 0.92, reasoning: ...}

# 6. Parameter fitting (gradient-free)
r = client.fit_parameter_grid(target_signal=observed,
                              candidates={"omega_0.1": gen(0.1), ...},
                              sampling_rate=10.0)
# r.best_param → "omega_0.34"

Ten domain calibrations + 21 recipes

The API ships with calibrations for finance, biomedical, sensors, ai_ml, security, power_grid, seismic, traffic, plus generic and auto. Each tunes sensitivity for that vertical's typical signal characteristics (heavy tails, fast oscillations, sparse events, etc.).

There's also a recipes layer with 21 production-ready recipes including 8 domain-specific probe libraries:

probes_finance — vol_regime, crash_event, momentum_break, mean_reversion_break, ...
probes_biomedical — tachycardia, bradycardia, PVC, lead_disconnect, atrial_fib, ...
probes_industrial — bearing_wear, imbalance, shock, cavitation, resonance, ...
probes_mlops — prediction_collapse, imbalance_shift, outlier_increase, ...
probes_security — traffic_spike, brute_force, scan_burst, dns_tunnel, ...
probes_logistics, probes_energy_grid, probes_climate

~80 pre-built probes. Plug-and-play for the most common patterns in each domain.

What's been validated

Real PhysioNet ECG (record 208, N vs PVC): 100% cross-validation accuracy without training a model
Real S&P 500 / BTC / VIX / Treasury daily data via yfinance: regime change detection with localized boundaries
Multi-sensor HVAC fault: correctly identifies the failing channel ("canal delator") in a single API call across 64 channels
Server CPU anomaly: 30-min sustained spike caught with severity 75 and localized timing
Account takeover, ransomware-pattern, insider threat detection: critical severity 67-96 on realistic data shapes

Full validation matrix at alphainfo.io.

Free tier — try it

Sign up (no credit card) for 50 analyses/month. 4 paid tiers above that, from $49/mo to Enterprise. All 10 domain calibrations and all 21 recipes available on every tier — capacity is the differentiator, not features.

pip install alphainfo

from alphainfo import AlphaInfo
client = AlphaInfo(api_key="ai_...")
r = client.detect_internal_change(signal=your_csv_column, sampling_rate=1.0)
print(r.semantic.summary)

When NOT to use this

You need gradient-based anomaly detection (use isolation forest)
Sub-100ms HTTP latency required (API floor is ~250ms; sub-100ms per-comparison via the vector endpoint OK)
Billion-scale similarity search (use FAISS, then AlphaInfo for re-ranking)
The "anomaly" is purely about magnitude with no shape change (use simple statistics — AlphaInfo measures structure, not magnitude)

Links

API docs: alphainfo.io/v1/guide
Recipe library: alphainfo.io/v1/recipes
Free tier signup: alphainfo.io/register
Pricing: alphainfo.io/pricing

Next post: I'll show how to wire this API into Claude Code as a self-correcting skill — the AI agent calls the right method automatically, even retrying with alternative configs when the first answer is borderline. The combination is genuinely powerful.

Feedback / use cases I'm missing — comments open. 🙏