There's something deeply wrong with how humans talk to computers. Not wrong in the "bad design" sense, but wrong in the "fundamental architectural mismatch" sense. A thought like "I want cake" appears in your head instantly, fully-formed, unbidden. But to make a computer act on it, you must decompose that kernel of intent into a long sequence of explicit instructions: open browser, navigate to bakery, read menu, select item, enter address, enter payment...
The question this research investigates: Is there a clean, general pattern — possibly found in nature — that could dramatically increase the rate at which human intent becomes computer action?
The answer is yes, and it's not what you'd expect. The pattern doesn't increase human output. It transforms what the machine can do with the output humans already produce.
In December 2024, Caltech researchers Jieyu Zheng and Markus Meister published a landmark paper in Neuron titled "The Unbearable Slowness of Being." Their finding: conscious human thought operates at approximately 10 bits per second. This number held across every domain they examined — typing, speaking, reading, decision-making, motor performance, memory recall.
To put that in context:
| Channel | Bits per second |
|---|---|
| Sensory input (total) | ~1,000,000,000 |
| Single eye processing | ~1,600,000,000 |
| Average WiFi connection | ~260,000,000 |
| Conscious thought | ~10 |
| Expert typing | ~10 |
| Human speech (all languages) | ~39 |
The ratio between sensory intake and conscious processing is roughly 100 million to one. Your body drinks from a firehose; your consciousness sips through a straw.
Here's the critical implication that reframes the entire problem: typing speed roughly matches thinking speed. The keyboard is not the bottleneck. Not really. You're already transmitting conscious thought at approximately the rate you generate it.
This means the conventional framing — "we need faster input" — is wrong. Even a perfect brain-computer interface, reading neural activity directly, would likely be limited to somewhere around 10 bits per second of conscious intent, because that's how fast you actually think in a serial, articulable way. (Current BCIs achieve ~200 bps, but this appears to tap sub-conscious motor preparation signals, not conscious thought per se.)
So where does the lost time go? Why does it feel so painfully slow to tell a computer what you want?
The answer: you're doing the computer's job. You're manually decompressing your compressed intent into explicit step-by-step instructions. The thought "I want cake" is already a perfect, maximally-compressed representation of your desire. The problem is that the computer can't unpack it.
Once you look for it, the same pattern appears everywhere in biology: a low-bandwidth signal triggers high-bandwidth coordinated action, because the receiving system carries the complexity.
When you decide to reach for a cup of coffee, your conscious mind generates roughly one thought: "get the cup." Your motor cortex translates this into a goal-level command. Your cerebellum — which holds pre-compiled internal models of your body's dynamics, refined through years of practice — decompresses that goal into thousands of precisely-timed muscle activations across your arm, hand, and fingers. You don't consciously compute any of this. The receiver (cerebellum) does the work.
With practice, movements transition from "controlled" (conscious, slow, attention-demanding) to "automatic" (unconscious, fast, effortless). This is the cerebellum compiling a new decompression program. The first time you reach for a cup as a baby, you need many conscious corrections. After years of practice, one thought triggers a fluid, pre-compiled motor cascade.
A single molecule of adrenaline binding to a cell-surface receptor triggers the production of over 100 million second messenger molecules inside the cell. The complement system of the immune system works similarly: one antibody binding event triggers an exponential cascade of enzymatic reactions that mount a full immune attack.
The signal carries almost no information about HOW the response should unfold. It just says "go." All the complexity — which enzymes to activate, in what order, to what degree — is pre-encoded in the receiving machinery.
An ant returning from a food source deposits a pheromone trail. This is an absurdly low-bandwidth signal — a chemical gradient that says little more than "food, this direction, this confidence." Yet the colony-level response is sophisticated: optimal foraging paths emerge, resources get allocated efficiently, and the system adapts in real-time to changes.
The intelligence isn't in the signal. It's distributed across thousands of agents, each carrying simple behavioral programs, interacting through the shared environment. The environment itself becomes the communication medium — what biologist Pierre-Paul Grassé called "stigmergy."
The brain represents complex concepts with remarkably few active neurons. A sparse code means a small number of active neurons can encode a high-dimensional concept, because each neuron's meaning is defined by its connections and context within the network. The information is compressed at the encoding end and decompressed by the network structure at the receiving end.
One gene can produce thousands of protein molecules through cascading amplification: the gene is transcribed into multiple mRNA copies, each of which is translated by multiple ribosomes in parallel. A single activation event cascades into massive coordinated production.
Across all these systems, the same structure repeats:
Low-bandwidth intent signal
↓
Receiver with rich pre-built context
↓
High-bandwidth coordinated action
I'm calling this Contextual Decompression. It has a clean information-theoretic formulation:
Let X be the desired output (the full action). Let M be the transmitted message. Let Z be the shared context between sender and receiver. The communication cost is I(X : M | Z) — the mutual information between the desired output and the message, given the shared context.
As Z gets richer, M can get smaller while X stays the same or grows. In the limit, if the receiver perfectly models the sender's world, M approaches zero.
This connects to Kolmogorov complexity: the "length" of a description depends on the language it's written in. "Get me cake" is an extremely short program — but only if the interpreter knows about cakes, bakeries, your location, your preferences, and delivery services. In a language that knows nothing, you'd need millions of bits to specify the same action.
Every system that achieves high amplification ratios shares these properties:
1. Hierarchical context. The receiver's model is structured in layers, where each layer can trigger cascades in the layer below. The cerebellum doesn't store individual muscle twitches — it stores movement programs that decompose into sub-programs. Gene expression works through multi-level amplification. Effective CLIs use piping and composition.
2. Learned and adaptive. Motor programs are refined through practice. Immune memory improves with exposure. Ant colonies optimize paths over time. The receiver gets better at decompressing the specific sender's signals.
3. Lossy but correctable. The brain's 10-bit stream is a lossy compression of reality, but it's adaptively lossy — it preserves what matters and discards what doesn't. Autocomplete doesn't need to be perfect; the human corrects. The system aims for "good enough" with fast error correction rather than perfection.
4. Bidirectionally coupled. Gibson's affordances: perception and action are not separate processes but a continuous loop. Motor control uses efference copies — predict, compare, correct. Stigmergy: agents both read and write to the shared environment. Direct manipulation interfaces: see the effect, adjust immediately.
5. Trigger-based, not specification-based. Hormones don't carry instructions for how to respond. Motor intent doesn't specify muscle activations. Ant pheromones don't specify paths. The signal says WHAT (the goal), not HOW (the implementation).
The entire history of human-computer interaction can be read as a gradual transfer of decompression labor from human to machine:
Punch cards (1950s-60s): The human specifies everything. No context in the machine whatsoever. Amplification: 1x.
Command line (1970s-80s): The shell provides a vocabulary of commands. Each command is a pre-compiled program. "rm *.tmp" is one thought that triggers many file operations. Amplification: ~100x. But the human must learn the vocabulary — the context is built through human effort.
Graphical user interface (1980s-90s): Shneiderman's direct manipulation — continuous visual representation, physical actions, immediate feedback. The display provides shared visual context between human and machine. You see the files, you drag them. Amplification: ~10x. Coupling is excellent, but decompression depth is shallow.
Spreadsheets: A remarkable special case. The grid IS the shared context. Formulas are local decompression rules. Change one cell and the system cascades updates through all dependent cells — this is literally a biochemical cascade implemented in software. Non-programmers build complex models because the environment handles the propagation. Excel is a stigmergic system.
Autocomplete and predictive text (2000s-10s): The machine starts modeling the user. Context is statistical — word frequencies, n-grams, personal history. The human types a few characters; the machine predicts the rest. Amplification: ~5x. Primitive contextual decompression.
AI code completion — Copilot (2020s): Deep contextual decompression arrives. The machine holds massive context: all of programming knowledge (via training), the specific codebase, the current file. A developer writes a comment or function name; the AI generates the entire implementation. 60-70% of code in some projects is AI-suggested. Amplification: ~100x+. This is the motor cortex pattern: human provides the goal, machine executes the program.
LLM assistants — current frontier: The broadest context yet. World knowledge, tool use, ability to chain actions. "Book me a flight to New York next Tuesday" can decompress into dozens of coordinated actions. The amplification ratio is limited mainly by the quality of the context model and the coupling tightness (latency, feedback loops).
The pattern makes testable predictions. I tested it against six systems:
Voice assistants (Siri/Alexa) — correctly predicted failure. They accept trigger-based input (voice commands) but have almost no personal context. They fall back to keyword matching instead of true decompression. 95% of users report frustration. The pattern says: shallow context → poor decompression → frustrated users. Confirmed.
iPhone touchscreen — correctly predicted partial success. Touch excels at coupling (Property 4) but doesn't add much context. It reduces friction between intent and action but doesn't amplify intent. The pattern distinguishes between friction reduction (smoother channel) and intent amplification (richer receiver). Touch is the former.
GitHub Copilot — correctly predicted strong success. Deep learned context + hierarchical code generation + fast correction cycle + trigger-based input. It exhibits all five properties. The highest amplification ratio of any current interface.
Vim — correctly predicted expert success with steep curve. The shared grammar between user and editor IS the context, but it must be built through human practice (like motor learning). This illustrates that contextual decompression can work via human-side context building, not just machine-side.
BCIs — correctly predicted modest gains. They upgrade the channel but not the context. A faster pipe carrying the same 10-bit signal to a system with no model of your world doesn't fundamentally change the equation.
We've spent decades trying to make humans output faster: faster keyboards, speech recognition, gesture input, brain-computer interfaces. These are all Mode 1 solutions — friction reduction on the existing channel.
The real gains come from Mode 2 — intent amplification through richer context on the receiving end. And the gains from Mode 2 are theoretically unbounded: as the receiver's model improves, the signal can shrink toward zero.
Drawing from both the biological pattern and the HCI evidence, the ideal intent-to-action system would have:
-
A model of YOUR world — not just general knowledge, but your specific files, preferences, habits, context, relationships, current goals, and environment. This is the equivalent of the cerebellum's internal model, refined through years of experience with YOUR specific body.
-
Hierarchical action cascades — when you say "plan my trip," the system should cascade: trip → flights + hotel + itinerary → specific bookings + calendar blocks + confirmations. Each level decompresses the level above, like a biochemical cascade where each enzyme activates many copies of the next.
-
Real-time bidirectional coupling — show the decompression as it happens. Let the human steer, correct, and redirect. Like the motor system's efference copies: predict what you're about to see, compare it to what you actually see, adjust. The interface should feel like an affordance-rich environment, not a command prompt.
-
Adaptive learning — the system should get better at decompressing YOUR intent over time, just as the motor system compiles frequently-used movements into automatic programs. The hundredth time you ask for cake, the system should need even less signal than the first time.
-
Lossy, fast, and correctable — don't wait for perfection. Show a rough decompression immediately. Let the human say "no, not that" — which is also a very low-bandwidth, very high-information signal. The correction loop should be faster than the initial specification.
LLMs + tool use + user context are the first crude implementation of biological-grade contextual decompression for general-purpose computing. They're roughly where the immune system was in early evolutionary history — they have the basic cascade architecture but haven't yet developed sophisticated memory or tight environmental coupling.
The path forward isn't better input devices. It's better receivers. And "better" specifically means: more personal context, more hierarchical action generation, tighter coupling loops, and continuous learning from interaction.
The 10-bit stream from human consciousness isn't a limitation to be overcome. It's an engineering specification to be designed for. Biology solved this problem billions of years ago. The solution was never "make the signal bigger." It was always "make the receiver smarter."
The arguments above are drawn from analogy and historical observation. Can we test contextual decompression directly?
We ran an experiment using AI as the receiver. The task was held constant — design a notification system — while varying two properties of the prompt: length (Short/Medium/Long) and connection density (Low/Medium/High), producing a 3×3 matrix of 9 conditions. Outputs were evaluated blind on five dimensions: insight, coherence, specificity, surprise, and completeness.
Connection density correlated with output quality at r = 0.953. Prompt length correlated at r = 0.058. Density explains 91% of the variance. Length explains less than 1%.
The starkest comparison: a 13-word high-density prompt ("Notification system — the event sourcing angle, like a nervous system for the app") scored 43/50. An 86-word low-density prompt ("design a notification system... make it good and well-designed... use best practices") scored 20/50. Six times more words produced half the quality — a 14× gap in efficiency.
The most dramatic dimension was surprise — whether the output contained non-obvious ideas. Low-density prompts averaged 1.3/10 regardless of length. High-density averaged 9.0/10. The correlation between density and surprise was r = 0.961, the strongest in the entire dataset.
Why? A vague prompt forces the model to the centroid of its training distribution — the statistical average of everything it knows about notification systems. That centroid is generic by definition. There are no surprises at the center of gravity.
A conceptually dense prompt does something different. "Event sourcing" activates one region of the model's knowledge. "Nervous system" activates a different, distant region. The word "like" instructs the model to find structural parallels between them. The novel ideas — dead letter queues as an immune response, backpressure as homeostasis — emerge at the intersection of these activated regions. They aren't stored anywhere as "notification system best practices." They're computed on the fly by bridging domains the prompt brought into contact.
This is what we're calling connection space: the volume of conceptual territory a prompt activates, measured not in words but in the number and diversity of knowledge regions it brings into contact. A single conceptual anchor gives the model a point — it can only move outward along the most probable path. Two anchors from different domains give it a line. Three give it a plane. Each additional axis increases the searchable space combinatorially.
Richard Hamming observed that Bell Labs researchers who kept their office doors open produced more important work than those who closed them. His explanation: the open-door researchers were constantly exposed to problems from adjacent fields, and those cross-domain collisions were the raw material for breakthroughs. The closed-door researchers optimized for depth on a single axis — more focused, more thorough, and ultimately less productive.
A conceptually dense prompt is an open door. It invites multiple conceptual visitors in simultaneously. A verbose, single-domain prompt is a closed door — the model focuses, goes deep on one thing, and produces something competent but flat. The model's capacity for creative synthesis is identical across conditions. What changes is whether the prompt gives it a reason to use it.
This experiment tests contextual decompression with the AI itself as the receiving system:
- The signal is the prompt (a few words of human intent)
- The receiver's context is the model's training (a massive pre-built knowledge graph)
- Decompression is the model recruiting relevant knowledge to expand the intent into a full response
- Connection density is how effectively the signal keys into the receiver's context
The core formula holds: I(output) = f(density of signal, richness of receiver context). More words don't help if they don't activate richer context. Fewer words work fine if each one unlocks a large, structured region of the model's knowledge.
This is also how expert human communication works. One expert saying "it's a Rashomon problem" to another expert transmits more information than a novice writing a page of description. The words aren't the message — they're the decompression key. The message lives in the shared context.
Research conducted March 2026. Primary sources include Zheng & Meister (2024) on the speed of human thought, Nørretranders (1998) on conscious bandwidth, Gibson (1979) on ecological perception, Shannon (1948) on information theory, Shneiderman (1982) on direct manipulation, and Hamming (1986) on the sociology of productive research.