Graph neural networks explained for engineers

Most of what gets sold as "AI" is still just pattern-matching on grids and sequences. Pixels in a grid, words in a line. That covers a lot of ground, but it doesn't cover the ground that actually runs the world: social networks, supply chains, molecules, road systems, fraud rings, citation webs. None of that is a grid. None of it is a clean sequence. It's a tangle of entities and the relationships between them, and for a long time we didn't have a deep learning architecture that took that tangle seriously instead of flattening it into something a CNN or RNN could chew on.

That's the gap graph neural networks fill. A GNN doesn't pretend your data is a picture or a sentence. It takes the graph - the actual web of connections - as the input, and it keeps that structure intact the entire way through. By the time you're done reading this, you'll know what that actually means under the hood, where the idea came from, which architectures are worth your time, where GNNs are quietly running in production right now, and where they still fall flat on their face.

What a graph actually is, and what a GNN does to it

Strip away the hype and a graph is just a pair: G = (V, E). V is a set of nodes (call them vertices if you want to sound formal), and E is the set of edges connecting pairs of those nodes. A node could be a person, a molecule's atom, a bank account, an intersection. An edge could be a friendship, a chemical bond, a wire transfer, a road. Nothing exotic so far - this is the same structure you'd draw on a whiteboard.

What's exotic is what a GNN does with it. The model is "graph-in, graph-out": you feed it a graph, and it outputs something useful without tearing apart the connectivity that defines the graph in the first place. Depending on the task, that output lands at one of three levels:

• Node-level - classify or score individual nodes (is this account fraudulent?)
• Edge-level - predict whether a connection exists or what type it is (will these two users become friends? what kind of bond links these atoms?)
• Graph-level - classify or score the whole graph (is this molecule toxic?)

Graph Representation Learning by William L. Hamilton

The foundational text behind the GNN formalism covered in this article - covers node embeddings, message passing and graph generative models from a leading researcher in the field.

Buy now

The engine that makes this work is message passing. Every node starts with some feature vector - whatever raw information you have about it. Then, in rounds, two things happen: aggregation, where each node collects feature information from its immediate neighbors, and update, where the node combines that collected information with its own current state to produce a refined representation. Run this for a few rounds and a node's representation stops being just "what this node looks like" and starts encoding "what this node looks like, in the context of everything around it, and everything around that." The result is an embedding - a numerical vector that captures a node's role and relationships in a form that downstream machine learning can actually use.

There's a property baked into most GNN designs that's worth understanding even if the name sounds academic: permutation equivariance. It means that if you shuffle the order of the nodes you feed into the model, the output node representations get shuffled in exactly the same way - the content of each node's embedding doesn't change just because you listed it third instead of first. Graphs, unlike images or text, don't have a natural ordering. There's no "top-left node." A model that secretly depended on node order would be learning an artifact of your data format, not the actual structure, so equivariance is the property that keeps the model honest.

For graph-level tasks - where you need one answer for the entire graph, not per node - you need to go the other direction and collapse all those node embeddings into a single vector. That's done with a permutation-invariant readout function: something like a sum, mean, or max over all node embeddings, chosen specifically because it gives the same result no matter what order the nodes came in. Equivariant in the middle, invariant at the output. That combination is most of what separates a real GNN architecture from "I ran a regular neural net on some graph-shaped features and called it a day."

A short, slightly embarrassing history

GNNs are not new. The idea of running a neural network over recursive, graph-like structures shows up in research from the 1990s, and the term "graph neural network" itself was coined in a 2005 paper by Marco Gori, Gabriele Monfardini, and Franco Scarselli, followed by a more developed version of the model from Scarselli and colleagues a few years later. These early models were genuinely clever for their time - they tried to learn node representations by propagating information through neighbors, which is essentially the same idea modern GNNs use.

And then... not much happened. For about a decade, these models stayed mostly in the academic literature because they had real, practical problems: training was unstable, and information didn't propagate cleanly across multiple layers. If you've ever tried to train a recurrent network that just won't converge, you know the flavor of pain we're talking about. GNNs sat in the "interesting idea, not ready for production" bin for years.

The turning point arrived with Graph Convolutional Networks (GCNs), introduced by Thomas Kipf and Max Welling. Their trick was to take the heavy, complex spectral graph convolution math that earlier researchers had been wrestling with and simplify it into something that was both theoretically grounded and, crucially, fast enough to actually run. That single simplification is arguably the reason GNNs went from a curiosity to a field.

What followed was fast, even by deep learning standards. GraphSage, from Hamilton, Ying, and Leskovec, introduced inductive aggregation - meaning the model could generate embeddings for nodes it had never seen during training, which matters enormously for graphs that change over time (and almost all real graphs change over time). Around the same period, Peter Battaglia and colleagues developed GraphNet, a more general framework that could represent node, edge, and global information together, with early success modeling physical systems. And Petar Veličković (now at DeepMind) brought attention mechanisms into the message-passing framework, producing Graph Attention Networks (GATs) - letting a node learn which of its neighbors actually deserve its attention, instead of treating them all equally.

The downstream effect of all this was an explosion in academic interest. A bibliometric analysis of the field found an average annual increase in GNN-related publications of roughly 447% between 2017 and 2019 - the kind of growth curve that usually means either a genuine breakthrough or a bubble. In this case, it was mostly the former, because the production deployments started showing up not long after, and they're still showing up now.

The architectures worth knowing

You don't need to memorize a zoo of acronyms, but four architectures cover most of what you'll encounter in the wild, and each one solves a different problem:

• Graph Convolutional Networks (GCNs) - the foundational workhorse. A GCN updates each node's representation by aggregating and transforming the features of its immediate neighbors, conceptually borrowed from how CNNs slide filters over image patches but adapted for irregular graph structure. The effect is a smoothing operation: nodes that are close together in the graph end up with similar representations. Simple, fast, and a reasonable first thing to try.
• Graph Attention Networks (GATs) - GCNs treat every neighbor equally, which is sometimes wrong. GATs fix that by learning attention weights, letting each node decide how much "weight" to give each neighbor's features during aggregation. This adaptive weighting helps on graphs where connectivity is uneven - some nodes have five neighbors, some have five thousand, and treating them identically wastes information.
• GraphSage - built for graphs that grow and change. Instead of learning a fixed embedding for every node by name, GraphSage learns a function that aggregates information from a node's local neighborhood, so it can generate a sensible embedding for a node it has literally never encountered before. That inductive capability is why it shows up so often in large-scale, constantly-updating production systems.
• GraphNet - the generalist. GraphNet-style models can represent node-level, edge-level, and global-level information simultaneously, which makes them a good fit for domains like physics simulation, where the interaction between objects (gravity, collisions) is as important as the objects themselves.

If you're picking a starting point for a real project: start with a GCN to get a working baseline, switch to GraphSage if your graph is large and constantly adding new nodes, and reach for a GAT when you suspect not all relationships in your data carry equal weight - which, in practice, is most of the time.

What graph neural networks are actually doing in production

This is the part that matters, because a lot of architectures sound clever on paper and then never leave the lab. GNNs didn't have that problem. They are quietly load-bearing in systems you've probably used this week, built around three core tasks: node classification (label an individual node), link prediction (will this edge exist, or what type is it), and graph classification (categorize the whole graph).

Social network analysis is the most intuitive starting point - it's literally a graph. GNNs are used to detect communities, spot emerging trends before they're obvious, and power recommendation engines that combine who you know with what you and people like you interact with, which is a stronger signal than either one alone.

Drug discovery and bioinformatics is where GNNs feel less like a tool and more like a different way of seeing chemistry. Molecules are graphs - atoms as nodes, bonds as edges - so predicting drug-target interactions, molecular properties, or designing entirely new molecules maps naturally onto graph-level and node-level GNN tasks. The headline example here is AlphaFold 2, which solved a problem (predicting a protein's 3D shape from its amino acid sequence) that had resisted decades of effort. Its structure module is built on a graph-based, attention-driven architecture - effectively a graph transformer - that represents each amino acid as a node and iteratively refines the protein's geometry, conceptually descended from the same message-passing family of ideas covered here, even if the production implementation goes well beyond a textbook GCN.

Fraud detection is one of the clearest commercial wins. Financial institutions analyze transaction networks as graphs, looking for the kind of structural patterns - rings of accounts, unusual clusters of shared devices or addresses - that are nearly invisible row-by-row but obvious once you draw the connections. Amazon Web Services publishes reference architectures that build heterogeneous transaction graphs and train GNNs on SageMaker to flag malicious accounts and transactions. And the performance numbers are real: NVIDIA's GPU-optimized GNN frameworks, built on the Deep Graph Library and PyTorch Geometric, report up to 39x faster preprocessing and 5.63x faster training compared to CPU baselines on industry-scale fraud datasets - the kind of speedup that turns "retrain the model monthly" into "retrain it overnight."

Recommender systems are everywhere GNNs go next, because "what should we show this user" is fundamentally a link prediction problem on a graph of users and items. Uber Eats runs its meal recommendations on a GraphSage-based architecture across a graph spanning hundreds of thousands of restaurants in hundreds of cities worldwide - a scale where GraphSage's fixed-parameter, inductive approach is close to a requirement rather than a nice-to-have. Pinterest's PinSage, built on the same family of ideas, does similar work for visual recommendations.

Computer vision benefits too, mostly through scene graphs - representations that capture not just what objects are in an image, but how they relate spatially and semantically ("the cup is on the table," "the person is holding the umbrella"). GNNs process the relationships between regions or objects in a way that pure CNNs, which see pixels but not relationships, don't naturally do.

Natural language processing gets a similar boost. Text has structure beyond word order - dependency trees, coreference chains, entity relationships - and GNNs that model words, phrases, or sentences as graph nodes can support tasks like semantic parsing and relation extraction where how things connect matters as much as what they say.

Traffic prediction is one of the best-documented GNN success stories outside the lab. DeepMind partnered with the Google Maps team to apply GNNs to estimated time of arrival (ETA) prediction, modeling both spatial dependencies (how road segments connect) and temporal dependencies (how conditions evolve through the day). The reported result: real-time ETA accuracy improved by up to 50% in cities including Berlin, Jakarta, São Paulo, Sydney, Tokyo, and Washington D.C. If you've ever been pleasantly surprised that Google Maps was right about your arrival time, there's a decent chance a GNN had something to do with it.

Combinatorial optimization problems - the notoriously hard, NP-hard kind that traditional algorithms either solve slowly or approximate badly - are an active area where GNNs offer efficient approximate solutions. Routing, scheduling, and resource allocation problems often have a natural graph structure that GNNs can exploit.

Chip design might be the single most counterintuitive application on this list. Google published a method in Nature that frames chip floorplanning - deciding where every component goes on a silicon die - as a reinforcement learning problem, with an edge-based graph convolutional network generating embeddings of the chip's netlist to guide placement decisions. The result: floorplans generated in under six hours that matched or beat layouts that previously took human expert teams weeks to produce. Google later extended this approach under the AlphaChip name and used it to help design parts of its own TPU chips - which means some of the silicon behind today's AI boom was, in a roundabout way, laid out by a graph neural network.

Hands-On Graph Neural Networks Using Python by Maxime Labonne

A hands-on companion for moving from theory to code - implements GCNs, GATs, and GraphSage in Python with PyTorch Geometric for tasks like traffic forecasting and fraud detection.

Buy now

GNNs meet LLMs: the real shift happening right now

If you've been half-paying-attention to AI news, you've noticed that 2025 and 2026 have been dominated by large language models. What's less obvious from the outside is that GNNs didn't get steamrolled by that wave - they're being folded into it.

The core problem LLMs have with structured data is that they're fundamentally sequence models trying to reason about things that aren't sequences. Ask an LLM to do multi-hop reasoning over a large knowledge graph - "find the connection between these two entities three steps removed" - and it either hallucinates a path or burns an enormous amount of context trying to traverse the graph in plain text. That's expensive, slow, and unreliable.

The emerging fix is to let a lightweight GNN do the structural heavy lifting - finding the relevant subgraph, the multi-hop path, the cluster of related entities - and then hand that compact result to an LLM to turn into a human-readable explanation. Approaches in this space, often grouped under names like GraphRAG and GNN-RAG, use GNNs to replace expensive LLM-driven graph traversal with something faster and more reliable, while the LLM handles what it's actually good at: language.

This division of labor shows up in a few concrete patterns:

• Context-aware AI agents that use a GNN as a kind of structural "GPS" - navigating dependencies, rules, and historical relationships in enterprise data to make decisions that are grounded in actual structure, not just word patterns
• Explainable fraud and risk systems, where a GNN identifies a suspicious pattern of connections and an LLM translates that pattern into a plain-language explanation a human analyst can actually act on
• Knowledge-graph-grounded reasoning, where retrieval pulls from a graph rather than (or in addition to) a vector database, giving the LLM relational context it can't get from text chunks alone

None of this is replacing GNNs with LLMs, or the reverse. It's combining a model that's good at structure with a model that's good at language, and 2026 is shaping up to be the year that combination moves from research papers into enterprise infrastructure.

Where the field is headed next

A few other threads are worth watching if you're trying to figure out where to invest your learning time.

Dynamic and streaming GNNs are designed for graphs whose topology and node attributes change continuously - think social networks, live traffic, or transaction streams - rather than the static, snapshot-style graphs most classic GNN papers assume. These models matter for real-time use cases: fraud detection that needs to react in seconds, not after a nightly batch job, or recommendation systems that need to incorporate what a user did five minutes ago.

Scalable, high-order feature fusion is the field's answer to a problem covered in detail below (oversmoothing): instead of stacking more layers and watching node representations collapse into mush, newer architectures adaptively combine information from multiple "hops" away in a way that captures long-range dependencies without the degradation. For large biological networks - protein interaction graphs, for instance - that's the difference between a model that sees a neighborhood and one that sees the whole picture.

Materials science and chemistry continue to be one of the strongest fits for GNNs, and the bar keeps rising. Research published in Nature has demonstrated GNNs predicting properties of crystals and molecules with near-experimental accuracy - the kind of result that genuinely speeds up the search for things like new battery materials, where exploring the chemical space computationally instead of through years of lab synthesis is a massive practical win.

Robustness and certified defenses are getting serious attention as GNNs move into critical infrastructure - energy grids, financial systems - where an adversarial attack isn't a theoretical concern, it's a liability. Frameworks with names like AGNNCert and PGNNCert aim to provide mathematically provable guarantees that a GNN's output won't flip under small, adversarial perturbations to the graph. If GNNs are going to run fraud detection at a bank or load balancing on a grid, "probably robust" isn't going to cut it, and the field knows it.

Where graph neural networks fall apart

None of this works as cleanly as the highlight reel suggests. If you're evaluating GNNs for a real project, here's where you'll actually run into trouble.

Lack of expressivity is the theoretical elephant in the room. Some popular architectures, basic GCNs included, fundamentally cannot distinguish between certain graph structures that are different but locally indistinguishable to a message-passing algorithm. In practice, this can show up as underfitting, especially when input node features are uniform and the model has to rely almost entirely on structure to tell graphs apart. Researchers have been chipping away at this with techniques like higher-order neighborhood aggregation, but it's a real limit, not a footnote.

Meaningless initial embeddings bite hardest in chemistry. Traditional molecular descriptors come pre-loaded with decades of domain knowledge - they already "know" things about chemistry before a model ever sees them. A GNN, by contrast, often starts from largely uninformed initial node features and has to learn chemical relationships from scratch. On large datasets, that's fine. On small ones - which describes a lot of real drug discovery datasets - the model simply doesn't have enough examples to independently rediscover what a chemist already knew.

Information loss during graph pooling is the price of graph-level tasks. To get a single output for an entire graph, you eventually have to collapse all those rich node embeddings into one vector via a pooling step, and that compression is an information bottleneck by definition. Fine-grained structural details that mattered at the node level can simply vanish in the pooled representation.

Locality of receptive field is a direct consequence of how message passing works: a node's representation after k rounds of aggregation only reflects information from nodes within k hops. That's by design, but it means information flow between distant nodes is inherently restricted, which can hurt tasks that depend on long-range structure in very large graphs.

That locality problem gets worse, not better, if your instinct is "just add more layers." That's oversmoothing - as you stack GNN layers, node representations from successively wider neighborhoods get aggregated together until, eventually, every node's representation looks roughly the same. The model stops being able to tell nodes apart, which is the opposite of useful. This is the main reason most production GNNs are shallow - two to four layers - rather than the dozens of layers you'd see in a deep CNN.

Closely related but distinct is oversquashing, where the bottleneck isn't too many layers but the graph's own topology - information from a large number of distant nodes gets compressed through a small number of edges or hub nodes, and detail gets lost in the squeeze. Picture trying to pour the contents of a swimming pool through a garden hose: the water all eventually gets there, but you've lost a lot of resolution about what was originally in it.

Noise vulnerability is something a lot of teams underestimate until it bites them. GNNs can be surprisingly fragile to small perturbations - tweak one node's features slightly, or add or remove a single edge, and the output can swing in ways that feel disproportionate to the size of the change. If your graph is built from messy, real-world data (and it always is), preprocessing and robustness testing aren't optional extras.

Scalability - the curse of large graphs is the practical wall most teams hit first. Training on graphs with millions or billions of nodes and edges runs straight into GPU memory limits. The standard fix is sampling - training on subgraphs rather than the whole thing - but sampling introduces variance and inconsistency into training that can show up as instability or inconsistent results across runs. Building GNNs that scale cleanly without these tradeoffs is still very much an open problem.

Interpretability and bias are the "black box" problems every deep learning model has, with an extra twist. It's already hard to explain why a model made a particular prediction; with GNNs, that prediction depends on a node's entire local neighborhood, which makes the explanation even harder to untangle. And because GNNs learn from the structure of historical data, they can pick up and amplify whatever biases are baked into that structure - if certain communities were historically underserved or over-scrutinized, a GNN trained on that history can quietly perpetuate it.

Ethical concerns and data privacy round out the list, and they're not abstract. Personal data inside a graph is messy to govern under regulations like GDPR or CCPA, because "this person's data" might really mean "this person's data plus the shape of their relationships to everyone around them." Even graphs that look anonymized can sometimes be de-anonymized through graph-based attacks that exploit structural patterns rather than any single identifying field - which means privacy reviews for graph-based systems need to think about structure, not just content.

The verdict

Here's the practical bottom line, the part you can actually act on.

If your data is naturally tabular, naturally a grid, or naturally a sequence, don't force it into a graph just because GNNs are interesting. You'll add complexity and lose the simplicity that made your original approach work fine. But if the relationships in your data are the signal - fraud rings, molecule structures, road networks, citation webs, social graphs, recommendation graphs - a GNN isn't a novelty, it's the architecture that's actually shaped like your problem.

The question isn't "can a GNN do this." With enough compute, a GNN can do almost anything. The question is whether the relationships in your data are the signal - or just noise you're dragging along for the ride.

If you're starting from zero, PyTorch Geometric and the Deep Graph Library (DGL) are the two frameworks that matter; both have production-grade GPU support and cover every architecture mentioned here. Start with a GCN baseline - it's the simplest thing that can possibly work, and it'll tell you fast whether structure is even helping. If your graph grows over time or you need to handle nodes you've never seen during training, move to GraphSage. If you suspect some relationships matter more than others - and in almost every real dataset, they do - layer in attention with a GAT. And keep your model shallow. Two to four message-passing layers will get you further than you'd expect, and going deeper is far more likely to introduce oversmoothing than to add capability.

The relationships were always there. GNNs are just the first architecture that takes them as seriously as the entities they connect.