How DNA wires a brain: 300M bits for 100 trillion connections

TL;DR

How DNA wires a brain is fundamentally an information-budget problem: a genome holds about 10 billion bits of instructions, but a human brain needs roughly 100 trillion connections to function — a five-order-of-magnitude gap between what’s written and what gets built. Only one wiring strategy closes that gap inside the genome’s real budget: hierarchical coordinate addresses, costing around 300 million bits instead of the 10 billion available. Two more obvious schemes — listing every connection explicitly, or following chains of molecular waypoints — blow past the budget by orders of magnitude before that one works.

The argument comes from a computational-biology paper by Stan Kerstjens and Anthony Zador at Cold Spring Harbor Laboratory, and it’s written like an algorithms problem, not a biology one — which is exactly why it’s useful outside neuroscience.

The gap, stated as a budget

Start with the numbers, because the whole argument is an accounting problem before it’s a biology problem.

A human brain has on the order of 10^10 neurons. Each one forms on the order of 10^4 connections. Multiply those and you get roughly 10^14 total connections — a hundred trillion. The genome that has to specify all of this, directly or indirectly, holds on the order of 10^10 bits. As the source article puts it, “genome sizes vary only about one order of magnitude, whereas brain sizes span eight” — the instructions barely scale while the thing they build scales enormously. Something other than “list every connection” has to be doing the work.

That’s the frame worth holding onto: this isn’t a metaphor about brains being “like computers.” It’s a literal resource-constraint problem — bits of storage, and calendar time — that any wiring scheme, biological or artificial, has to solve the same way. This isn’t hypothetical, either: the first full wiring diagram of an adult brain ever mapped — a fruit fly’s, ~140,000 neurons — landed in Nature in 2024, and every added connectome makes the compression question sharper, not softer, as the mapped connection counts climb toward the human scale this piece is about.

Two schemes that don’t fit the budget

The paper walks through three candidate strategies, in order of how naturally they occur to anyone who has designed a routing table.

Strategy 1: identity lists. Every neuron carries an explicit list of which other neurons it connects to. It’s the simplest possible scheme and it’s what a naive engineer would reach for first. The cost is roughly O(mn log n) in space — and for human-scale numbers that works out to about 3×10^15 bits, along with an estimated 500 km of axon if targets were addressed this way with no shared structure. Both numbers are wildly outside what’s available. This strategy is ruled out immediately, not by biology, but by arithmetic.

Strategy 2: guideposts. Instead of a direct address, an axon follows a sequence of molecular waypoints — chemical landmarks along the route, checked one at a time. This is closer to how real axon guidance was first described experimentally, and it does cut the routing cost. But the storage cost scales with the number of waypoints per path, and for a system with millions of distinct paths, that multiplies rather than collapses the information problem. It’s an improvement, not a solution.

How DNA wires a brain: the coordinate-addressing scheme

Strategy 3 is the one the numbers actually support, and it works by giving every cell a coordinate instead of a route.

Here’s the mechanism: as a tissue develops, cells divide. Each division is a branch point, and at each branch a cell’s address gets one more bit appended — left or right, dorsal or ventral, whichever axis that division encodes. After roughly log2(n) rounds of division, every cell has a unique binary address, built entirely out of local yes/no decisions repeated at scale.

Key insight: the same address rule works everywhere. A cell doesn’t need a special-case instruction for its exact position — it just needs the generic “append one bit per division” rule applied recursively, which is why the storage cost collapses from something proportional to the number of connections down to something proportional to the depth of a tree.

The cost works out to O(tm log n) in space, and — this is the number that matters — around 3×10^8 bits for realistic parameters (roughly 10^3 cell types, 10^4 targets per type). That’s comfortably inside the ~10^10-bit genome budget, with over an order of magnitude of headroom. A growth cone finds its target by checking one bit of the target’s address at each branch point and taking the matching half of the tissue — resolving a full address in O(log n) comparisons instead of an exhaustive search.

The biological substrate for this isn’t abstract, either. Each bit in a cell’s address corresponds to a combinatorial pattern of transcription factors and signaling molecules — the same families of genes that mark out left-right, anterior-posterior, and dorsal-ventral axes during development. The address is written in gene expression, not in some separate symbolic layer.

Strategy	Space cost	Fits the genome?
Identity lists	O(mn log n) ≈ 3×10^15 bits	No — ~5 orders of magnitude over budget
Guideposts	O(kmn log n), waypoints multiply cost	No — scales with path count
Hierarchical coordinates	O(tm log n) ≈ 3×10^8 bits	Yes — comfortably under the ~10^10-bit budget

Why noise is a resource, not a bug

One counterintuitive piece: some of the wiring rules the paper describes are probabilistic, not deterministic — “connect to each candidate target with probability 10/n,” for instance, rather than a fixed exact rule. That sounds like a weaker mechanism, but it’s cheaper. A probabilistic rule doesn’t need to encode which specific instance to pick; the randomness itself does work that would otherwise cost bits to specify. The tradeoff is that pure noise isn’t robust on its own — real systems pair it with discretization, thresholds, and redundancy (“banks” of similar connections) that claw back some of the reliability at a modest additional information cost. Noise is a free resource, but not an unlimited one.

Where plasticity fits — and where it doesn’t

It’s tempting to read all of this as “genes determine wiring, full stop,” but the paper is explicit that the coordinate system only gets an axon to roughly the right neighborhood. Activity-dependent plasticity — retinal waves before an eye ever opens, synaptic competition during early development — refines connections further, and critically, this kind of internally generated activity doesn’t import any new information beyond what the genome already specified; it’s still executing the genome’s instructions, just through activity patterns instead of static addresses. Real experience-dependent plasticity, once senses come online, is different: that’s where information genuinely enters from the environment, on top of the genetically encoded coordinate map.

Why this matters if you build AI systems, not brains

Here’s the sentence in the source material that should catch an AI engineer’s attention: “modern machine learning does not yet know how to generate large functional networks from compact descriptions.” Today’s models are the opposite of what a genome does — behavior lives in a weight matrix that’s orders of magnitude larger than any rule that produced it, or in training sets that dwarf the model’s own parameter count. Hypernetworks, neural architecture search, and weight-generation research are all reaching for exactly the compression ratio biology already achieves: a short, reusable rule that expands into a functional, enormous structure. The brain isn’t a metaphor for this problem. It’s an existence proof that a ~3×10^8-bit generator producing a ~10^14-scale functional network is achievable — we just don’t have the algorithm for the artificial version yet.

Common mistakes reading this kind of result

• Treating “genetically encoded” as “hardwired and precise.” The coordinate system sets a coarse map; plasticity does the fine-grained work. Neither one alone explains the wiring.
• Assuming more genome would just solve harder wiring problems. The point of the paper is the opposite — genome size barely moves across species while brain size moves by eight orders of magnitude, so whatever scales, it isn’t raw storage.
• Missing that this is a falsifiable model, not a settled fact. The address-map prediction is checkable — it should be visible in adult gene-expression patterns — and it hasn’t been fully confirmed at scale.

FAQ

How many bits does it take to encode a human brain’s wiring? A brute-force list of every connection would need roughly 3×10^15 bits — far more than the ~10^10 bits in the entire human genome. A hierarchical coordinate-addressing scheme collapses that to around 3×10^8 bits, well inside the genome’s budget, by reusing the same short address rule at every branch point instead of storing each connection individually.

Why can’t the genome just list every neuron’s connections? A human brain has about 10^10 neurons averaging 10^4 connections each, roughly 10^14 connections total. Storing each one as an explicit identity, even compressed, costs on the order of 3×10^15 bits under the identity strategy — about five orders of magnitude more than the genome holds.

What is the coordinate-addressing strategy for brain wiring? Every cell gets a binary address built up over roughly log2(n) rounds of cell division, with each division appending one bit. A growth cone reads its target’s address one bit at a time at each branch point, so a full address resolves in O(log n) comparisons instead of a global lookup.

Does this mean brain wiring is fully genetically determined? No. The address system gets connections to roughly the right neighborhood, then activity-dependent plasticity refines the specifics. The genome sets the coarse map; experience imports information the genome never had to encode.

Why does this matter for AI engineering, not just neuroscience? It’s a working example of generating a large functional network from a tiny compact description — the opposite of how we train neural networks today. Hypernetworks and architecture search are chasing the same compression the brain already achieves.

Is the coordinate-addressing model proven, or just a hypothesis? It’s a theoretical framework with a falsifiable prediction: an address map encoded in gene-expression patterns should be visible across the adult brain, and a small shared rule set applied to it should predict real connectivity. That’s still an open experimental question.

If you found the compression angle interesting, the same “compact rule, huge output” tension shows up in how a 30B model gets small enough to run locally, in the VRAM and KV-cache math behind serving large models, in what actually survives when an agent’s context gets compacted, and in cutting memory in half with pointer compression — four very different systems solving the same problem the genome solves: doing more with a budget that refuses to grow as fast as the thing it produces.

Sources

• Stan Kerstjens & Anthony M. Zador, “Could a computer scientist build a brain?” — Cold Spring Harbor Laboratory. The primary source for every strategy, cost formula, and number in this post.
• Dorkenwald et al., “Neuronal wiring diagram of an adult brain”, Nature (2024) — the first complete connectome of an adult brain (fruit fly), cited here as evidence that connectome-scale mapping is now real and growing.