The half of a system that decides where things go — routing, policy, intent. The decider, not the doer.
The switches below are dumb on purpose: they forward each packet according to a rule somebody else installed, as fast as the silicon allows, and they have no idea why. The thinking happens on the plane above — the controller that knows the topology, computes the path, and pushes rules down the dashed control channel. Cut a link and you see the division of labour exactly: the data plane keeps slinging packets along whatever it was last told, so for a moment they pour into the break; then the controller notices, takes its unhurried time to converge, and installs a detour, and delivery resumes. Switch the controller offline and cut a link — now nothing reroutes, and the packets drop and drop, because the plane that decides is gone and the plane that does cannot think. Keep the data plane up even when the brains are down: that is the whole discipline, and the reason the split has a name.
Telephone networks long ago separated the signalling that set up a call — who is dialling whom, route the circuit — from the voice that then flowed across it. The decision path and the carrying path were different paths on purpose. The control plane was born in the exchange, decades before it had the name.
An IP router runs two machines in one box. The control plane speaks BGP and OSPF, building a picture of the network and deciding where things should go. The data plane — often a dedicated chip — does nothing but forward packets along those decisions, millions per second. Smart and slow on top; dumb and fast underneath.
OpenFlow and SDN make the separation explicit and physical: pull the control plane into a central controller and leave the switches as cheap, fast, obedient data planes. Decision-making becomes software you can program; forwarding becomes a commodity. The two halves, always distinct, are now distinctly addressable.
Kubernetes ships a control plane — API server, scheduler, controllers — whose whole job is to decide the desired state of the cluster, while the nodes and kubelets are the data plane that actually runs your containers. A generation of engineers learned the term here, mostly while it was broken.
Istio, Linkerd, and their kin split traffic management cleanly: a control plane distributes policy and config, and a fleet of sidecar proxies — the data plane — moves every request according to it. You change intent in one place; the doers, everywhere, adjust. Toggle a route and the packets follow.
The pattern is a design principle now, far beyond networking: keep the decision path separate from the hot path. The control plane can be rich, consistent, and a little slow; the data plane must be fast and simple. Most outages are the moment someone forgets which plane they are standing on.
This entry is the museum's bonus track: control plane is modern infrastructure jargon, not an old word dug up from disuse. It earns a place because the idea it names is genuinely ancient — the separation of deciding from doing — and because almost everyone now depends on it while almost no one outside infra can name it.