A thinking diary — April 2026
I've been building something I call the Organismo — a network of interconnected systems for taking in raw information, refining it through a reasoning pipeline, and producing structured knowledge outputs. It started as a workshop visualization: nodes and connections, cloud services and API routes, everything laid out like a circuit diagram. Accurate, but lifeless. You could see what connected to what, but you couldn't feel how the thing worked.
So I tried something different. I imagined the whole system as a cow.
Why a cow?
Not as a joke — as a thinking tool. The cow makes visible something the circuit diagram obscures: directionality. Grass goes in one end, milk comes out the other. There's a clear flow from intake through digestion through production. The organism metaphor I'd been using before treated everything as interconnected, which it is, but it hid the fact that there's a pipeline at the heart of it. A refinery. And refineries have a direction.
Once I started mapping components, the analogy didn't just hold — it taught me things about the system I hadn't noticed.
The anatomy
The mouth is where information enters. Right now, that's a Brain Proxy endpoint on a server — you POST text to it, and it enters the system. The cow can eat, but only what you put in front of it.
The eyes are the scanners — systems that would autonomously find things worth ingesting. These don't exist yet. The cow is being hand-fed. This is an honest representation of the current state: no autonomous sensing, no scanning the horizon for interesting grass. Everything that enters the system, a human put there. Making that visible immediately clarifies what the next capability gap is.
The four stomachs are the reasoning pipeline. Real cows have four stomach chambers, each doing a different type of processing on the same material — rumen, reticulum, omasum, abomasum. This maps almost exactly to the four processing layers I've built: Parse (break the input into units), Decompose (crack each unit open, map its dependencies, type its terminals), Evaluate (test the structure), and Stress-Test (try to break it).
The decomposition layer — which I call Clean Well — is where the real work happens. And here's where the cow analogy earns its keep: cows chew cud. They swallow grass, partially digest it, regurgitate it, chew it again, swallow it again. That's recursive decomposition. Clean Well does the same thing to claims — takes a statement, breaks it into dependencies, checks each dependency for further structure, goes back, breaks it down again, until every branch terminates in something that can be typed and assessed. Cud-chewing is the perfect physical metaphor for what recursive epistemic decomposition actually feels like: you keep working the same material until the structure is fully exposed.
The intestines are the synthesis layer — where the refined nutrients actually get absorbed into the body's knowledge. The stomachs decompose; the intestines integrate.
The brain is where structured epistemic objects live. Not raw memory — that's the bloodstream. The brain holds the typed, validated, load-bearing knowledge the system has produced. The things that have survived the stomachs.
The heart is the Brain Proxy on the droplet server. It pumps data around the system. If the heart stops, everything downstream stops. And the arteries map to specific API routes: the carotid carries raw material from the heart to the brain for refinement, the aorta feeds the stomachs their processing power via LLM streaming calls, the portal vein carries analysis results into storage, and the pulmonary artery goes out to the lungs — the external AI APIs where the cow breathes, picking up the computational oxygen it needs from the fields.
The bloodstream is the database layer — it carries nutrients (thoughts, connections, projections) to every organ that needs them.
The farm
The cow doesn't exist in isolation. It lives on a farm.
The fields are LLMs. The cow doesn't own the fields. It grazes on them. Different fields have different grass — Anthropic, OpenAI, Google. The quality of the grass directly affects the quality of the milk. The cow needs the field, but the field doesn't need the cow. This captures something important about the relationship between what I'm building and the foundation models it runs on: they're rented pasture, not owned infrastructure. The cow's value isn't in the grass — it's in what the cow's digestive system does with the grass.
The farmer is the human operator — guided by a set of principles (I call it the constitution). The farmer decides when to milk, which field to graze, whether the cow is healthy. The farmer doesn't micromanage digestion — you don't tell a cow how to process grass in its third stomach. You set the conditions and let the biology work. This maps to a design principle I've landed on: constrain the ontology, not the local cognition. Hard-constrain what types of things the system can produce, what categories it uses, what its stopping rules are. Don't constrain how it gets there.
The udders and teats are the output system. Four teats, four product channels: publishing (books, essays — bottled milk), research (experiments, papers — artisan cheese, takes longer, different audience), applications (interactive tools, governance specs — processed dairy, the milk transformed into something with a different shape), and then the tricky one.
The manure problem
Social media didn't fit the teat analogy. The first three product channels are things you produce and then sell. Social media is a live interaction with the environment. The cow chews grass, digests it, and drops something back into the ecosystem that makes the field more fertile for next time. That's not milk production — it's manure.
I mean that in the most positive agricultural sense. Manure is how a farm creates a feedback loop with its environment. The cow takes from the field and returns nutrients to the field. Social media contributions — contextual replies, discourse participation, the ongoing conversation — are the system's way of fertilising the ground it grazes on. The farmer decides which fields get fertilised. But the manure isn't a product; it's a relationship with the land.
This reframing resolved a tension I'd been stuck on. I kept trying to force social media into the same output model as books and research papers. It's not the same kind of thing. It's a circulatory relationship between the organism and its environment, not a packaged product.
The farm shop, the mill, and the dairy school
The farm shop is where packaged products meet the public. Books on Amazon, the Substack archive, research papers. You walk in, browse, buy, leave.
But the farm doesn't just sell products. Some customers bring their own grain and want it milled — they upload a document, it goes through the four stomachs, they get the refined output back. That's the mill. A processing service, not a product.
And then there's the vision I keep coming back to: an app on everyone's phone. A personal reasoning tool. You're not selling them milk; you're teaching them to think like the cow digests. That's the dairy school — the reasoning framework as something others can wield. You come to the farm not to buy milk but to learn how fermentation works, and you leave with your own starter culture.
Three buildings, three business models: the shop (passive distribution), the mill (processing service), the school (capability transfer).
What the analogy teaches
I built a 3D visualization of this — a cartoon cow you can rotate, click into, see the arteries pulsing, the stomachs churning, the teats labelled with their product channels. It's absurd and it works. My five-year-old could point at the cow and understand the basic flow: food goes in the mouth, gets processed in the stomachs, milk comes out the udders, the farmer takes the milk to the shop.
But the real value of the analogy isn't communication — it's discovery. The cow revealed things the circuit diagram hid:
The directionality of the system. Grass in, milk out. The organism metaphor made everything look equally connected. The cow makes the pipeline visible.
The dependency on fields you don't own. The cow is nothing without pasture, and the pasture is rented. That's the honest relationship with foundation models.
The difference between products and environmental contributions. Milk is not manure. Both come from the cow, both have value, but they work completely differently. Trying to ship manure through the same channels as milk will make a mess.
The customer-facing surfaces aren't all the same. A shop, a mill, and a school serve different needs. Collapsing them into "the platform" would be as confused as calling a farm shop, a grain mill, and an agricultural college the same business.
And the eyes. The greyed-out, not-yet-built eyes. Every time I look at the cow, I see a creature that can digest brilliantly but can't see. It's being hand-fed. The most important thing the analogy does is make the absence of autonomous sensing impossible to ignore.
I'm not suggesting anyone else should think about their systems as cows. But I am suggesting that when your abstractions stop teaching you things, it's worth reaching for a metaphor that has a body. Bodies have directionality, dependencies, constraints, and gaps. Circuit diagrams have boxes and arrows. Sometimes you need the cow.
Felix Pope writes about compression, meaning, intelligence, and the engineering of epistemic systems. His book The Compression Point is forthcoming.