How to predict equipment failures with MCP and TimesFM (16 data points)

#mcp #ai #iot #timeseries

You can forecast an equipment failure from as few as 16 time-series data points
by feeding machine telemetry to a pretrained time-series foundation model (TimesFM)
through an MCP tool — no per-machine model training required. This post shows the
shape of that pipeline using FoundryNet's Forge prediction kernel, which exposes
predict, predict_breach, and remaining_life as MCP tools.

Why 16 points is enough

Classic predictive-maintenance ML needs a labeled history per machine: thousands of
runs, failures included, retrained per asset. That's why it never scaled past the
pilot. TimesFM (a time-series foundation model) is pretrained on a huge corpus, so
it forecasts a new series zero-shot from a short context window — ~16 points is
enough to project the next horizon. You skip the per-machine training problem
entirely.

The pipeline

Normalize the telemetry. Spindle load, temperature, vibration — each OEM (Fanuc, Siemens, Haas, Mazak) names these differently. FoundryNet resolves any machine's fields to a canonical schema at query time, so the model sees one consistent series regardless of source.
Forecast. Call the predict MCP tool with the recent series and a horizon. TimesFM returns the projected values.
Threshold against a breach. predict_breach compares the forecast to a safety/wear threshold and returns when the series is projected to cross it — e.g. "spindle load crosses the wear limit in ~8 hours."
Attest the prediction. Every result is hashed and recorded via MINT Protocol (settled on Solana), so the forecast is a verifiable artifact, not a screenshot.

Calling it from an MCP client

claude mcp add --transport http forge https://forge.foundrynet.io/mcp

// tools/call → predict_breach
{
  "time_series": [/* >= 16 recent readings */],
  "threshold": 85.0,
  "horizon": 24
}
// → { "breach_in_hours": 8, "confidence": ..., "provenance": { "mint_verified": true, ... } }

The same kernel exposes remaining_life (estimated useful life) and batch
prediction across a fleet.

What this unlocks

The interesting part isn't the forecast — it's acting on it autonomously. Once a
prediction is an MCP tool an agent can call, an agent can read any machine, reason
over the forecast in plain English, and trigger an action (open a work order, slow
a feed rate, page the 3am operator only when it actually matters). The prediction
is the input; the orchestration is the product.

Try it

Forge prediction kernel (MCP): https://forge.foundrynet.io/mcp
The data servers it draws on are part of the FoundryNet Data Network.
Predictions are attested via MINT Protocol — verify any result on-chain.

DEV Community