It's not a new model. It's one recipe every graph network already follows.
By 2017 there were at least eight separately invented neural networks for learning on graphs (data made of nodes joined by edges — here, atoms joined by bonds). Each had its own notation, and nobody could easily say how they related. This paper's move is not to add a ninth. It is to show they are all special cases of one pattern, which the authors name Message Passing Neural Networks (MPNN).
The pattern has just three pluggable parts, run for a few rounds. (1) A
message function M lets every node send a vector to
its neighbours along the edges. (2) An update function
U folds the messages a node received into its own new state.
(3) After a few rounds, a readout function R
collapses all the node states into one graph-level answer — the
molecule's predicted property. Pick different M, U, R and you recover
each prior model; that turned "invent an architecture" into "search over
three functions."
Once you see message → update → readout, every graph neural network looks like the same machine with different parts swapped in.
The setup
What goes in, what comes out, and why a graph is the right shape.
Step 1 · The black box & the prize
A box that reads a molecule and predicts its physics.
Here is the whole story in one picture. A molecule goes in, a number comes out — a quantum-mechanical property such as its energy. The box is an MPNN. The slow, accurate way to get that number is DFT (Density Functional Theory, a physics simulation): for one nine-atom molecule it takes about an hour. The trained MPNN spits out the same number in about a hundredth of a second. This tiny molecule will follow us through all nine steps.
The benchmark is QM9: about 130,000 small organic molecules (made of H, C, N, O, F, up to 9 heavy atoms), each labelled with 13 quantum properties computed by DFT. The goal is to learn a model that reproduces those DFT numbers. The bar to clear is called chemical accuracy — an error tolerance the chemistry community treats as "good enough to be useful." The MPNN hits it on 11 of the 13 targets, and runs roughly 300,000× faster than the DFT it imitates.
From the abstract: “we reformulate existing models into a single common framework we call Message Passing Neural Networks (MPNNs) … Using MPNNs we demonstrate state of the art results on an important molecular property prediction benchmark.”
Step 2 · The problem before the paper
Hand-built fingerprints, and a zoo of mismatched models.
You've seen the box and its prize. Before we open it, look at the mess it was cleaning up — two messes, really.
Mess one: hand-crafted features. Classic chemistry models could not read a molecule directly. A human first turned it into a molecular fingerprint (a fixed list of engineered descriptors — counts of substructures, distances, and so on), and a model learned on that. Good fingerprints took years of expert tuning, and the model was only ever as good as the features someone thought to include.
Mess two: a zoo of graph models. Meanwhile, at least eight separate neural networks had been proposed to operate on molecular graphs directly — convolutional fingerprints, gated graph nets, interaction networks, graph convolutions, deep tensor nets, and more. Each was described in its own notation. There was no shared vocabulary, so you couldn't tell whether two papers were doing genuinely different things or the same thing twice.
The contribution here is partly a vocabulary. By naming the shared pattern, the paper let chemists drop hand-built fingerprints and let researchers compare graph models on equal footing. Keep this framing; Step 3 shows what the network actually reads.
Step 3 · A molecule is already a graph
Atoms are nodes, bonds are edges — and that's the whole input.
Step 2 promised one recipe over molecular graphs. So first: what is a molecular graph, exactly? It is the most natural picture a chemist already draws.
Every atom becomes a node; every chemical bond
becomes an edge. Each node carries a feature vector
xv describing the atom (its element, how many
hydrogens hang off it, whether it is aromatic, and so on), and each
edge carries a vector evw describing the bond
(single / double / triple / aromatic, and the distance between the two
atoms). That graph is the input — no human-designed fingerprint.
xv describe each atom; edge features evw describe each bond. This four-atom graph is what we'll run message passing on by hand.One small but important wrinkle: the network must give the same answer no matter what order we happen to number the atoms. Chemistry doesn't care whether you call the oxygen "atom 1" or "atom 3." The MPNN is built to be invariant to that ordering (formally, to graph isomorphism) — a property we'll see fall out of the readout in Step 6.
By feeding the network the molecule's actual connectivity, the chemistry lives in the structure, not in a hand-tuned descriptor. The symmetry of atoms suggests a model that operates on the graph and is blind to atom ordering is exactly the right shape for the problem.
Node features (Table 1 of the paper): atom type (H, C, N, O, F), atomic number, acceptor / donor flags, aromaticity, hybridization, and hydrogen count. Edge features: bond type and interatomic distance.
The mechanism
Three functions · one round computed by hand · then the formulas
Step 4 · The whole recipe in three functions
Message, update, readout — that's the entire machine.
Step 3 handed us a graph of atoms. Now we open the MPNN box. Inside is
a loop that runs for a few rounds (the paper calls each round a
timestep t), and at every round it does just two things,
then reads out once at the end.
Give every node a hidden state hv (a small
vector, started from the atom's features). One round of message
passing is:
① Message · M
Each node hears its neighbours
Along every edge, function M turns the neighbour's state (and the bond) into a message. A node sums all the messages reaching it.
mᵥ = Σ M(hᵥ, h_w, e_vw)
② Update · U
Each node rewrites itself
Function U folds that summed message into the node's own state, producing its new state for the next round. (In this paper, U is a GRU.)
hᵥ ← U(hᵥ, mᵥ)
③ Readout · R
The graph gives one answer
After the last round, function R pools all the node states into a single graph-level vector and predicts the property ŷ.
ŷ = R({hᵥ})
That's the whole abstraction. M and U repeat for
T rounds (the paper sweeps 3 ≤ T ≤ 8);
R runs once at the end. The genius of the framing is that the
eight earlier models from Step 2 differ only in their choice of
M, U and R — same loop, different parts.
After one round, a node knows only its immediate neighbours.
After two, it knows neighbours-of-neighbours. Each extra round
lets information travel one more bond across the molecule — so
T rounds means every atom "sees" everything within
T bonds of it. We'll watch this happen in Step 5.
Step 5 · One round, by hand
Watch a number flow along a bond and a node add it up.
Step 4 gave the recipe in words. Here you run it. Before any real M, U or R, we'll use the simplest possible versions so the arithmetic is all integers you can check in your head.
Give each atom in our molecule a one-number state, started from a stand-in for its features: O = 3, N = 2, H = 1, and the central C = 4. Our toy rule: the message a node sends is just its current value, a node sums the messages it receives, and its update is "old value + that sum." That's message, aggregate, update — the real machine, stripped to arithmetic.
Take the central carbon C in round 1. It has three neighbours, so it receives three messages — their round-0 values — sums them, and adds the sum to its own value:
mC= 3 + 2 + 1 =6 → hC= 4 + 6 =10
message from O (3) + from N (2) + from H (1) = 6 · then C's new state = its old 4 plus the message 6
Step through the rounds — watch each atom's reach grow one bond at a time
Reach: 0 bonds — each atom knows only itself.
Press “Next round.” Each click runs one message-passing round: every atom sends its value to its bonded neighbours, sums what it receives, and adds it on. Watch the numbers grow — and watch how, after two rounds, O / N / H have indirectly heard each other through C.
A real MPNN replaces "value" with a vector, "+1" with a learned message network, and "old + sum" with a GRU — but the skeleton is exactly this: send along edges, sum at the node, fold it in, repeat. Swap in those learned pieces and you have the model that beats DFT.
The numbers are a toy stand-in chosen to be hand-computable. Real states are ~200-dimensional vectors; the real message function (Step 6) is a small neural network on the edge. The flow — message, aggregate, update — is identical.
Step 6 · The real parts they plugged in
An edge network, a GRU, and an order-blind readout.
In Step 5 the three functions were trivial arithmetic. The paper's best model — they call it enn-s2s — swaps in learned versions of each. Same loop; better parts.
Message (M) — the edge network. Instead of just copying the
neighbour, the bond decides how the neighbour's state is read.
A small network A turns the edge vector
evw into a matrix, which multiplies the
neighbour's state: M = A(evw) · hw.
A double bond and a single bond now transform the same neighbour
differently — the chemistry of the bond is in the message.
Update (U) — a GRU. A node folds its summed message into its old state with a GRU (Gated Recurrent Unit — a small gating network that decides how much of the new message to keep versus how much old state to retain). Crucially the same GRU weights are reused at every round, so adding rounds adds no parameters.
Readout (R) — set2set. After the last round, R must crush a set of node states into one vector — and a set has no order. The paper uses set2set (a readout designed to consume a set and emit an order-independent summary), so renumbering the atoms can't change the answer.
A molecule's energy doesn't depend on how you number its atoms. Because the message step sums (order doesn't matter) and the readout consumes a set, the whole MPNN gives the same prediction under any relabelling — it respects the molecule's symmetry by construction, with no physics hand-coded in.
The paper also tries useful tricks: a master node wired to every atom (a global scratchpad) and virtual edges between distant atoms, both giving information shortcuts across large molecules.
Step 7 · The formulas, as a receipt
Three lines — and you've already run all three.
You've done message-aggregate-update by hand (Step 5) and met the real M, U, R (Step 6). So the paper's three equations now read as a receipt for what you already understand, not new notation.
Let hvt be node v's
state at round t, N(v) its neighbours, and
evw the bond between v and
w. The forward pass is:
mvt+1=Σw∈N(v)Mt(hvt, hwt, evw)
① MESSAGE — sum a learned message over every neighbour. This is the “3 + 2 + 1” you summed at C.
hvt+1=Ut(hvt,mvt+1)
② UPDATE — fold the message into the node's state (here, the GRU). This is “old + sum.”
ŷ=R({ hvT | v ∈ G })
③ READOUT — after T rounds, pool all node states into one graph-level prediction (here, set2set).
“Every node collects a learned message from each neighbour and sums
them (M); it updates its own state with that sum (U);
repeat T times; then squash all the states into one answer
(R).” That sentence is the three equations — and it's the
machine you ran in Step 5.
Equations (1)–(3) of the paper. Mt, Ut and R are all learned differentiable functions; the whole thing trains end-to-end by gradient descent.
The payoff
Did it work — and can you now explain it?
Step 8 · Results on QM9
Chemical accuracy on 11 of 13 targets — and an honest ceiling.
You've built the machine: graph in (Step 3), the three functions (Steps 4–7). Final question — how close does it get to the physics it imitates?
Scores are reported as an error ratio: the model's error divided by the chemical-accuracy tolerance for that target. Below 1.0 means the prediction is within chemical accuracy — good enough to be useful. The bars below are the ensemble model (enn-s2s-ens5); the dashed line marks the 1.0 threshold.
Report card · QM9 error ratio (model error ÷ chemical accuracy) · lower is better
μ · dipole moment
⟨R²⟩ · electronic spatial extent
U₀ · atomization energy
α · polarizability
HOMO · orbital energy
ZPVE · zero-point vib. energy
gap · HOMO–LUMO gap
0error ratio · 1.0 = chemical accuracy · lower is better2.0
The authors then do something rare: they call their own ceiling. Because the model now matches DFT on almost every target, they argue the QM9 benchmark is close to saturated, and that the field should move on to larger molecules or more accurate ground-truth labels rather than ever-fancier models — an honest read on diminishing returns.
Every bar that ends left of the “1.0” point is a target solved to chemical accuracy. The smallest — μ at 0.20, ⟨R²⟩ at 0.14 — are five-to-seven times better than required. Only gap and ZPVE poke past the line.
Error ratios from Table 2 (enn-s2s-ens5 ensemble). “Chemical accuracy” is a per-target tolerance set by the chemistry community; the model is measured against the available DFT labels.
Step 9 · Recap — can you explain it?
Five questions. Answer each aloud before you open it.
You have the whole arc: one recipe (core idea), molecule-as-graph (Step 3), message-aggregate-update by hand (Step 5), the real M / U / R (Step 6), the three equations (Step 7), and the QM9 scores (Step 8). If these five come easily, you've genuinely got this paper.
What are the three functions of an MPNN?
Message (M) — each node sums a learned message from every neighbour along the edges. Update (U) — each node folds that sum into its own state (here, a GRU). Readout (R) — after T rounds, pool all node states into one graph-level prediction (here, set2set). M and U loop; R runs once.
Why is this paper called a unification?
At least eight previously separate graph networks turn out to be the same loop with different choices of M, U and R. Naming the pattern gave the field a shared vocabulary, so "invent an architecture" became "search over three functions."
Walk through one round on the toy molecule.
Start O=3, N=2, H=1, C=4. The carbon sums its neighbours' values (3 + 2 + 1 = 6) and adds its own: C = 4 + 6 = 10. Each outer atom hears only C: O = 3 + 4 = 7, N = 2 + 4 = 6, H = 1 + 4 = 5. One round = one bond of reach.
Why must the readout be order-invariant?
A molecule's property doesn't depend on how you number its atoms. Because the message step sums (order-free) and the readout consumes a set, the MPNN gives the same answer under any relabelling — it respects the molecule's symmetry by construction.
How good is it, and what's the honest caveat?
It reaches chemical accuracy on 11 of 13 QM9 targets (average error ratio 0.52) at ~300,000× the speed of DFT, using no hand-built fingerprints. The caveat the authors raise themselves: QM9 is nearly saturated, so progress needs bigger molecules or better labels.
What happened next — "message passing" became the default way the field talks about learning on graphs. The framework you just learned underlies modern graph neural networks, molecular property and drug-discovery models, and even physics simulators — anywhere data comes shaped as nodes and edges.
“We reformulate existing models into a single common framework we call Message Passing Neural Networks (MPNNs) … future work should focus on datasets with larger molecules or more accurate ground truth labels.” — the abstract, Gilmer et al., 2017
"Message passing" became the language of graph learning.
The lasting contribution wasn't a single model — it was a vocabulary. By naming the shared pattern, this paper gave the whole field a common API, and message passing became the default way people reason about learning on graphs.
Modern graph neural networks
GraphSAGE, GAT, GIN and countless others are all message-passing networks — they differ only in how they pick M, U and R, exactly as this paper framed it.
Molecules & simulators
Property prediction, drug discovery, and learned physics simulators all build on message passing over atoms / particles — fast surrogates for expensive simulations like the DFT it beat here.
A common framework
Graph-learning libraries adopted "message passing layers" as their core abstraction, so building a new GNN means implementing three functions — not reinventing an architecture.
Send along edges, sum at the node, read out the graph — one recipe that organized an entire field.