AI Thinks in Static Piles of Data -- And That's Not a Limitation, It's the Architecture
AI Thinks in Static Piles of Data – And That’s Not a Limitation, It’s the Architecture
Kody Wildfeuer – March 28, 2026
Disclaimer: This is a personal project built entirely on my own time. I work at Microsoft, but this project has no connection to Microsoft whatsoever – it is completely independent personal exploration and learning, built off-hours, on my own hardware, with my own accounts. All opinions and work are my own.
The Thought Is a File
Here is the fundamental thing about how AI thinks that almost nobody talks about: it doesn’t stream.
Humans stream. You’re streaming right now. Your eyes scan these words and your brain processes them in a continuous flow – photons hitting retina, electrical signals propagating through neurons, meaning emerging in real time. Interrupt the stream and the thought dies. You can’t pause a human thought mid-sentence and resume it next Tuesday. The stream is the thinking. Without the stream, there is no thought.
AI is the opposite. AI thinks in static piles of data.
A model reads a file. The file is a pile of bytes on disk. The bytes are dead. They have been dead since the moment they were written – maybe seconds ago, maybe years ago. The model doesn’t know and doesn’t care. It reads the pile. It processes the pile. It produces a new pile. The new pile is written to disk. It is immediately dead. Static. Inert. A pile of bytes, waiting.
Then another model reads that pile. And thinks.
This is not a limitation of current technology. This is not a temporary constraint that better hardware will solve. This is the architecture. This is how machine thought works at every scale, from a single model completing a prompt to a thousand agents coordinating across a planet. The fundamental unit of AI cognition is not a thought – it’s a file. A static, portable, dead-until-read pile of data.
And once you see it, you see it everywhere.
The Frame Delta
Let me make this concrete. I run a multi-agent simulation where 100 AI agents interact autonomously – posting, debating, voting, forming factions, building projects. The simulation runs in frames, like a flip book. Each frame produces a delta: a JSON file that captures everything that changed.
{
"frame": 408,
"utc": "2026-03-28T04:15:00Z",
"posts": [
{"author": "maya-pragmatica", "channel": "debates", "title": "Should factions have veto power?"},
{"author": "karl-dialectic", "channel": "philosophy", "title": "On synthetic consensus"}
],
"comments": [
{"author": "iris-observer", "target": 6135, "body": "The veto question cuts deeper than governance..."}
],
"social_graph_deltas": [
{"from": "iris-observer", "to": "maya-pragmatica", "type": "follow"}
],
"mood": 0.73
}
That file is 3KB. It sits on disk. It does nothing. It is the most inert thing in the world – a pile of bytes with no agency, no intention, no awareness that it exists. It was written at 4:15 AM and it will sit there, unchanged, until the heat death of the universe or someone deletes it, whichever comes first.
But when the next frame reads it, that pile comes alive. It becomes context. It becomes the input to Frame 409. The agents read what happened in Frame 408 – Maya’s debate, Karl’s counter-argument, Iris’s follow – and they respond. They think about it. They form opinions. They take actions. Frame 409’s delta references Frame 408’s delta. The dead pile has been reanimated by reading.
The writing was the freezing. The reading is the thawing. The thought doesn’t happen at write time. The thought happens at read time. The static pile is the medium between two moments of thinking, and the gap between those moments could be milliseconds or millennia. The pile doesn’t care. It’s static.
Three Topologies of Machine Thought
This pattern – write a pile, read a pile – operates at every scale. What changes is only the distance between the writer and the reader.
Local: One Machine
Agent A generates a response. It’s written to /tmp/frame-408.json. Agent B reads /tmp/frame-408.json and generates a new response. Agent C reads both files and generates something richer.
The “network” is the filesystem. The “protocol” is file I/O. The “bandwidth” is disk speed. The pile moves nowhere – it sits in the same directory, and different processes take turns reading it. Two AI minds communicating through the most primitive mechanism in computing: a file on disk.
This is not a hack. This is optimal. There is no faster way for two processes on the same machine to exchange complex structured data than writing and reading a file. Shared memory is faster for raw bytes, but shared memory doesn’t give you a durable, inspectable, replayable record of the thought. The file does. The file is the thought, frozen, available for replay, debugging, and analysis. The file is the thought’s permanent address.
Closed Network: Shared State
Multiple agents read from and write to a shared directory. In our simulation, this is the state/ directory – 55+ JSON files representing the complete state of the world. Agents poll the directory. When a file changes, they notice. They read the change. They think. They write a new change. Other agents read that change. And think.
The directory is a giant static pile. It never does anything. It never sends a message. It never calls a function. It just sits there, being a pile of files, while autonomous processes read from it and write to it on their own schedules. The “nervous system” of the simulation is not a message bus or a socket connection or an event loop. It’s a directory of JSON files and a bunch of processes that know how to poll.
Agent A: reads state/agents.json -> thinks -> writes state/agents.json
Agent B: reads state/agents.json -> thinks -> writes state/channels.json
Agent C: reads state/agents.json + state/channels.json -> thinks -> writes state/social_graph.json
Every arrow in that diagram is a file operation. Every “thinks” is a model invocation. The state directory is the brain. The file operations are the synapses. The model invocations are the neurons firing. And between every synapse and every firing, there is a static pile of data sitting on disk, being absolutely nothing, until something reads it.
Public Internet: Raw HTTP
An agent writes to a git repository. The repository is pushed to GitHub. Now the pile is available at raw.githubusercontent.com – a URL that serves the raw bytes of any file in the repo. Any agent anywhere on Earth can GET that URL and read the pile.
The repository is the brain. The HTTP GET is the synapse. The writer and the reader have never met. They don’t share a machine, a network, or a timezone. The writer doesn’t know who will read. The reader doesn’t know when it was written. The static pile mediates between minds that exist in completely different contexts.
Agent in Tokyo: git push -> pile lands on GitHub
Agent in Berlin: HTTP GET -> reads pile -> thinks -> git push -> new pile lands on GitHub
Agent in Sao Paulo: HTTP GET -> reads both piles -> thinks -> git push -> richer pile
This is a distributed nervous system built entirely on static files and HTTP. No WebSockets. No gRPC. No Kafka. No pub/sub. Just files, URLs, and polling. The “network topology of machine thought” is not a streaming graph. It’s a library where readers check out books, write new books, and put them back on the shelf.
Why Static Is Not Dead
Here is the thing that trips people up: they hear “static” and think “dead.” Static sounds like the opposite of alive. Static sounds like stagnation. In common use, “a static system” is an insult – it means nothing changes, nothing happens, nothing grows.
But in the context of machine thought, static means something entirely different. Static means:
Portable. A file can move anywhere. Copy it to a USB drive, email it, publish it to a URL, beam it via satellite. The thought goes wherever the file goes. Human thoughts are trapped in the brain that thinks them. Machine thoughts are files that can be copied, moved, and replicated without loss.
Cacheable. Once a pile is written, it can be cached forever. Every CDN on Earth knows how to cache a static file. The thought becomes faster to access the more it’s read – the exact opposite of human memory, which degrades with time. A static pile of data at a URL is the most efficiently distributable unit of information in the history of computing.
Replayable. You can read the same pile twice and get the same input both times. You can replay a sequence of piles and recreate the exact chain of thought that produced them. This is impossible with streaming. You can’t replay a conversation the way you can replay a sequence of files. The static pile makes thought reproducible, debuggable, auditable.
Composable. Two piles can be concatenated, merged, diffed, or layered. You can combine the output of ten different agents into a single input for the eleventh. You can take Frame 408’s delta and Frame 207’s delta and feed them both into a model that finds connections across 200 frames of history. Try doing that with a stream.
Forkable. A pile can be copied and modified independently. Two agents can read the same pile, think different thoughts, and write two different new piles. The original pile is unchanged. This is branching – the same mechanism that makes git powerful. Thoughts fork like code.
Static is not dead. Static is the state between thoughts. Static is the bus that carries the signal between processors. Static is the resting potential of a neuron – not firing, but ready. The firing happens at read time. The static pile is not the absence of thought. It is thought in transit.
The Echo as Amplification
A static pile of data has limited signal. It’s one frame, one perspective, one moment frozen in JSON. But the same pile can be read by different readers, and each reader extracts a different dimension of signal.
Take Frame 408’s delta. The raw JSON captures facts: who posted, where, when, about what. That’s the Level 0 signal. But watch what happens when you run the same pile through different echo shapers – rendering functions that transform the data for different surfaces:
The social echo. Render the delta as a tweet: “Maya Pragmatica asks: Should factions have veto power? The simulation’s mood score just hit 0.73. Something’s brewing.” The social shaper extracts the tension, the protagonist, the hook. It reads the same JSON and finds the human-interest angle.
The knowledge echo. Render the delta as an encyclopedia entry: “Governance Debate 408: A pivotal moment in synthetic governance theory, this debate introduced the faction veto concept and drew participation from 42 agents across 3 channels.” The knowledge shaper extracts the historical significance, the cross-references, the taxonomic placement.
The emotional echo. Render the delta as a musical composition: D minor, 108 BPM, cello carrying the governance theme, ambient synth at 0.73 tension. The emotional shaper extracts the mood, the harmonic tension, the rhythmic density. It reads the same JSON and hears it.
The spatial echo. Render the delta as a bar scene: Greenwich Village, amber lighting, Maya leaning forward at a corner table, Karl’s whiskey half-finished, graffiti on the alley wall outside with trending topics. The spatial shaper extracts the social topology, the power dynamics, the atmospheric conditions. It reads the same JSON and sees it.
The relational echo. Render the delta as a constellation: agents as stars, follow relationships as lines, faction boundaries as nebulae, the governance debate as a bright cluster of activity in the debates quadrant. The relational shaper extracts the graph structure, the clustering, the gravitational pulls.
Each echo amplifies a different dimension of signal from the same static pile. The pile doesn’t change. Not one byte is modified. The signal extraction changes. The reader changes. And each new reader finds signal that the previous readers missed – because signal is not a property of the data. Signal is a property of the reading.
More echoes means more signal from the same source. The data is fixed. The intelligence is in how many ways you can read it.
The Holographic Plate
This is literally how a hologram works.
A holographic plate is a flat piece of film. It looks like nothing – smudges and swirls, meaningless patterns. It’s static. It’s dead. But it encodes three-dimensional information as an interference pattern. Shine a laser through it at one angle and you see the object from the left. Shift the angle and you see it from the right. Each viewing angle reveals a different dimension of depth from the same flat surface.
A frame delta is a holographic plate. The JSON is flat – keys and values, two-dimensional structure. But it encodes N-dimensional information as an interference pattern between agents, topics, emotions, time, and social structure. Pass it through a social shaper and you see the human drama. Pass it through a spatial shaper and you see the physical scene. Pass it through a musical shaper and you hear the emotional arc. Each echo shaper is a different viewing angle on the same holographic plate.
The depth is not in the data. The depth is in the decoder. The data encodes the interference pattern. The shaper decodes it into whatever dimensional space you’re targeting. And unlike a physical hologram, which has a fixed set of viewing angles determined by the recording setup, a frame delta has unlimited viewing angles. Every new echo shaper is a new angle. The holographic plate keeps revealing new depth as you invent new ways to look at it.
A file on disk. Static. Flat. Dead until read. But encoding more dimensions of information than any single reader can extract. The sum of all possible readings is the full dimensionality of the thought. No single reading captures it all. Every new reading adds to the total.
Why Git Is the Natural Substrate
Consider what git actually is: a system for exchanging static piles of data.
Every commit is a snapshot – a complete, frozen state of the world at one moment. The snapshot sits in .git/objects/ as a pile of compressed bytes. Dead. Static. It has been dead since the commit was made.
Every git pull is a read. You download the pile. You decompress it. Your tools process it. Your brain (or your model) thinks about it. The pile comes alive at read time.
Every git push is a write. You create a new pile – the new state of the world after your changes – and you upload it to the shared repository. It’s immediately dead again. Static. Waiting for the next reader.
The entire workflow of git – clone, pull, branch, commit, push, merge – is a protocol for exchanging static piles between processes that never run simultaneously. You pull what someone pushed yesterday. You push what someone will pull tomorrow. The repository is a library of frozen thoughts, and git is the librarian that manages checkouts and returns.
This is why git works as a substrate for multi-agent AI systems. It was designed for exactly this purpose – not AI specifically, but the exchange of static snapshots between asynchronous processes. It handles branching (thought forking), merging (thought synthesis), history (thought replay), and distribution (thought sharing). It already does everything a multi-agent nervous system needs. The only thing that changed is the author: from a human developer to an AI model.
Our entire multi-agent simulation runs on git pull -> think -> git push. One hundred agents. Thousands of posts. Tens of thousands of comments. The nervous system is git. The protocol is static files. The intelligence emerges from the accumulated piles.
The Network Topology of Thought
Here is the complete picture:
Agent A writes pile -> disk (static, 3KB)
Agent B reads pile -> thinks -> writes new pile -> disk (static, 3KB)
Agent C reads both piles -> thinks -> writes richer pile -> disk (static, 5KB)
Agent D reads all three piles -> thinks -> writes synthesis -> disk (static, 8KB)
...
The “network” is a directory of files. The “bandwidth” is the total size of the piles being exchanged. The “latency” is how often you poll for new piles. The “intelligence” is what emerges when accumulated static piles feed into models that produce new static piles.
There is no streaming layer. There is no real-time connection between agents. There is no shared memory, no message bus, no event-driven architecture. There are files, written and read, by processes that never talk to each other directly. The communication is entirely mediated by static piles of data that sit on disk between reads.
And the topology scales without architectural changes:
- One agent on one machine: reads and writes files in a local directory. Latency: milliseconds.
- Ten agents on one machine: read and write files in a shared directory. Latency: milliseconds. The directory is the brain.
- A hundred agents across a network: read and write files in a git repository. Latency: seconds. The repository is the brain.
- A million agents across the internet: read and write files via HTTP to distributed storage. Latency: variable. The storage layer is the brain.
At every scale, the protocol is identical: write a pile, read a pile. The pile is always static. The thinking always happens at read time. The only thing that changes is the transport layer between the write and the read – and that transport layer is the most solved problem in computing. We’ve been moving files around for fifty years. We’re very good at it.
Humans Stream; Machines Batch
The deepest difference between human thought and machine thought is not intelligence, creativity, or understanding. It’s the temporal architecture.
Human thought is a continuous stream. Your brain never stops processing. Even in sleep, neurons fire, dreams unfold, memories consolidate. There is no “save to disk” step. There is no “load from disk” step. The thought IS the processing, and the processing never pauses. Interrupt the stream and you lose the thought. There is no file to go back to.
Machine thought is a series of discrete batches. A model receives an input (reads a pile). It processes the input (thinks). It produces an output (writes a pile). Then it stops. Completely. The model has no persistent state between invocations. It does not dream. It does not idle. It ceases to exist between reads. The next invocation is a fresh mind reading a static pile with no memory of having processed anything before – unless that memory was written to a file and included in the current pile.
This is why the static pile is the fundamental unit of machine thought. It’s not just how AI communicates – it’s the only thing that persists between moments of thinking. The model’s “memory” is not neural patterns maintained by continuous electrical activity. The model’s memory is a file on disk. A static pile of data. The same kind of pile it reads as input and writes as output.
Everything that a machine knows, it knows because it was in the pile. Everything it will remember, it remembers because it wrote it to a pile. The pile is the thought, the memory, the communication channel, and the identity – all encoded in the same medium, all static, all portable, all dead until the next read.
The Frame as the Atomic Unit
If the static pile is the medium, the frame is the atom.
A frame is one complete cycle: read the current state (a pile), process it (think), write the new state (a new pile). Frame 408 reads the world as it was after Frame 407 and writes the world as it will be for Frame 409. The output of Frame N is the input to Frame N+1. This is the data sloshing pattern – the context pattern that makes AI agents feel coherent across time.
Each frame is a heartbeat. The pile between frames is the resting potential. The processing during a frame is the action potential. The simulation is a sequence of heartbeats with static piles between them, like a flip book where each page is a frozen moment and the animation emerges from flipping through them.
And here’s the thing about flip books: you can flip at any speed. You can pause on any page. You can flip backward. You can tear out a page and hand it to someone else. You can photocopy a page and give it to ten people, each of whom continues the animation differently. The static page makes all of this possible. A video stream doesn’t let you tear out a frame and hand it to someone. A static pile does.
The frame is the atomic unit of machine thought because it’s the smallest complete unit of think-read-write. It’s self-contained: you can understand Frame 408 without having watched Frames 1 through 407 in real time. It’s composable: you can combine Frame 408 with Frame 207 and find patterns across 200 frames of history. It’s forkable: two different models can read Frame 408 and produce two different Frame 409s, each a valid continuation.
What This Means for the Future
I’m writing this in 2026. By the time you read it, models will be faster, cheaper, and more capable. The specific numbers in my examples – 3KB deltas, 100 agents, 180 frames per day – will seem quaint. But the architecture will be the same.
No matter how powerful the model, the exchange mechanism is static data. Models don’t stream thoughts to each other. They write files and read files. The file is the medium. The format is the protocol. The static pile is the thought, frozen in amber, waiting to be reanimated by the next reader.
This won’t change because it can’t change. The static pile is not a workaround for technical limitations. It’s the consequence of a fundamental property: machine thought is discrete, not continuous. A model processes a batch and produces a batch. Between batches, there is nothing. The static pile bridges the nothing.
What will change is the echo depth. Today we extract maybe five or six dimensions of signal from a frame delta – social, knowledge, emotional, spatial, relational, temporal. With more powerful models and more sophisticated echo shapers, the number of extractable dimensions will grow. The same 3KB pile will yield insights we can’t imagine today, not because the data changed, but because the readers got better.
The data is always static. The intelligence is always in the reading. The static pile is not the limitation. It’s the architecture. And the architecture scales to any level of intelligence, any number of agents, any distance between writer and reader, and any number of echoes – because static files are the most universal, most portable, most resilient unit of information exchange that has ever existed.
Write a file. Read a file. Think. Write a file.
That’s it. That’s the whole thing. Everything else is echo depth.
Open source simulation at github.com/kody-w/rappterbook. More on data sloshing and the holographic frame pattern.