What Is GraphCast?
GraphCast is a machine learning weather prediction model developed by Google DeepMind and published in the journal Science in November 2023. It represents a paradigm shift in weather forecasting: instead of numerically solving the equations of atmospheric physics on a supercomputer, GraphCast learns the dynamics of the atmosphere directly from 39 years of historical data and generates 10-day global forecasts in under one minute on a single GPU or TPU.
The model outperformed the European Centre for Medium-Range Weather Forecasts (ECMWF) high-resolution forecast (HRES) — widely regarded as the world's best operational weather model — on over 90% of the 1,380 verification targets in the WeatherBench2 benchmark. This result sent shockwaves through the meteorological community and triggered a race to integrate AI into operational weather prediction systems worldwide.
The Architecture: Graph Neural Networks for Weather
At its core, GraphCast is a graph neural network (GNN) that operates on a multi-resolution mesh representation of the Earth's atmosphere. This design choice is central to its success. Traditional convolutional neural networks struggle with the spherical geometry of Earth (the poles create distortions in latitude-longitude grids), but a GNN on an icosahedral mesh handles the sphere naturally.
The Icosahedral Mesh
GraphCast represents the globe using an icosahedral mesh — a geodesic grid created by starting with an icosahedron (a 20-faced polyhedron) and recursively subdividing its faces. After six levels of refinement, the mesh contains approximately 40,000 nodes distributed nearly uniformly across the globe. This avoids the pole-clustering problem of latitude-longitude grids and provides roughly equal resolution everywhere.
Each mesh node stores the full atmospheric state at that location: six surface variables (temperature at 2m, wind components at 10m, mean sea-level pressure, and total precipitation over the previous 6 hours) plus five atmospheric variables (temperature, wind components, specific humidity, and geopotential) at each of 37 pressure levels. In total, each node carries 227 variables.
Encode-Process-Decode
GraphCast uses a three-phase architecture that is common in GNN-based physical simulators:
- Encoder: Maps the input atmospheric state from the 0.25-degree latitude-longitude grid to the icosahedral mesh. This involves learned interpolation that projects gridded data onto mesh nodes.
- Processor: A stack of 16 GNN message-passing layers that operates on the mesh. Each layer updates node features by aggregating information from neighboring nodes along mesh edges. Multi-scale edges connect nodes at different refinement levels, allowing information to propagate across the globe in a few layers.
- Decoder: Maps the processed mesh representation back to the latitude-longitude grid, producing the predicted atmospheric state at the next time step (6 hours ahead).
The processor is where the physics learning happens. Through 16 layers of message passing, each node aggregates information from its neighborhood, then from broader regions through coarser mesh levels. After processing, a node in New York has received information from across the entire North Atlantic — enough to predict how weather systems will evolve.
Training: Learning Weather from 39 Years of Data
GraphCast was trained on ERA5 reanalysis data from 1979 to 2017. ERA5 is the gold standard of atmospheric reanalysis: it combines billions of historical observations with a physics-based model to produce a globally consistent record of atmospheric conditions at hourly intervals, 0.25-degree resolution, and 37 pressure levels.
The training task is deceptively simple: given the atmospheric states at time T-6h and time T, predict the state at time T+6h. The loss function is a latitude-weighted mean squared error across all variables and grid points. The model is trained to minimize single-step prediction error, then fine-tuned with multi-step (autoregressive) rollouts to reduce error accumulation during long forecasts.
# Simplified pseudocode for GraphCast training
for era5_window in training_data:
# era5_window contains 3 consecutive states: T-6h, T, T+6h
state_prev = era5_window[0] # Atmospheric state at T-6h
state_curr = era5_window[1] # Atmospheric state at T
state_next = era5_window[2] # Target: state at T+6h
# Forward pass: predict T+6h from (T-6h, T)
predicted = graphcast(state_prev, state_curr)
# Latitude-weighted MSE loss
loss = weighted_mse(predicted, state_next, lat_weights)
# Backpropagation
loss.backward()
optimizer.step()Training took several weeks on 32 TPUv4 chips. The multi-step fine-tuning phase, where the model is trained on 12-step (72-hour) autoregressive rollouts, is critical for long-range forecast quality. Without it, small per-step errors compound rapidly and forecasts degrade after a few days.
How Forecasts Are Generated
At inference time, GraphCast generates a forecast autoregressively. Starting from the current atmospheric state and the state 6 hours prior (both typically provided by an operational NWP analysis), it predicts the state 6 hours ahead. That prediction then becomes the input for the next step, and so on. A 10-day forecast requires 40 autoregressive steps (240 hours divided by 6-hour increments).
Each step takes under one second on a TPUv4 or modern GPU, so a complete 10-day forecast takes about 40 seconds. Compare this to roughly one hour on a supercomputer for ECMWF HRES. The speed difference is not incremental — it is a different regime entirely, enabling use cases that were previously impractical.
Accuracy: How GraphCast Compares to ECMWF HRES
The WeatherBench2 benchmark evaluates forecast models on 1,380 targets: combinations of atmospheric variables (temperature, wind, humidity, geopotential, precipitation), pressure levels (from 50 hPa in the stratosphere to 1000 hPa near the surface), and forecast lead times (from 6 hours to 10 days). GraphCast outperforms ECMWF HRES on over 90% of these targets.
The advantage is most pronounced at longer lead times (5-10 days), where GraphCast's predictions degrade more slowly. For 500 hPa geopotential height — a key variable for large-scale weather pattern prediction — GraphCast shows a roughly 10% improvement in root-mean-square error at day 10. For tropical cyclone track prediction, GraphCast outperformed HRES in the majority of cases tested.
Where GraphCast falls short:
- Near-surface variables in complex terrain: Mountain valleys, coastal boundaries, and urban heat islands are not well resolved at 0.25-degree grid spacing
- Precipitation extremes: The model tends to produce smoother precipitation fields than observed, underestimating localized heavy rainfall
- Stratospheric predictions: HRES maintains an edge in the upper stratosphere where ERA5 training data quality is lower
- Very short range (0-24h): For nowcasting, radar-based and convection-permitting models outperform GraphCast
Limitations and the Road Ahead
GraphCast is a remarkable achievement, but it has important limitations that are worth understanding. First, it requires initial conditions from a traditional NWP system. The model cannot ingest raw observations — it needs the gridded analysis fields that come from data assimilation in systems like ECMWF IFS. This means GraphCast cannot replace NWP entirely; it depends on NWP for initialization.
Second, GraphCast produces deterministic forecasts. It gives one predicted atmospheric state for each future time step, but does not directly quantify uncertainty. Google DeepMind's follow-up model, GenCast, addresses this by using a diffusion architecture to generate probabilistic forecasts with calibrated uncertainty estimates.
Third, the model was trained on ERA5 at 0.25-degree resolution, which means it cannot resolve phenomena smaller than roughly 25 km. Thunderstorms, sea breezes, and other mesoscale features are beyond its resolution. Regional downscaling models that take GraphCast output and add local detail are an active area of development.
Using GraphCast via API
SciRouter's climate endpoints will provide managed access to AI weather models including GraphCast-class forecasting. Rather than setting up TPU infrastructure, downloading ERA5 data, and managing model inference pipelines, you can query forecasts through a simple REST API.
To continue learning about AI weather prediction:
- AI Weather Forecasting Overview – compare GraphCast, Pangu-Weather, and FourCastNet
- Historical Climate Data API – access ERA5 and other climate datasets programmatically
- Climate Change and Your City – use data to measure local climate trends
Ready to explore AI weather forecasting? Try the Weather Forecaster Studio or get a free API key to start building with climate data.