Designing living systems

This is how bloom thinks about system design in the age of AI. The shift is from doing the work to architecting the system that does it, modelled on how natural networks actually work, with the human focus on the checkpoints and the loops.

When computation was scarce and expensive, the valuable human skill was doing the work: writing the copy, building the page, reconciling the spreadsheet. When computation becomes cheap and abundant, the valuable skill moves up a level. It is no longer doing the work. It is designing the system that does the work, and placing the checkpoints that keep it correct.

This is the discipline bloom is built on. The machine does the heavy, data-dense computation inside the system. The human designs the system: what flows in, what comes out, where the work is checked, and where the loops close. Your leverage is no longer in the computation. It is entirely in the architecture, and above all in the checkpoints.

Most people are not yet good at this. It is a new kind of engineering, and getting good at it is a real edge.

The instinct to model this on mycelium and tree networks is not decoration. Natural networks are the most successful distributed, feedback-driven systems we know of, and they solve exactly the problems AI systems have to solve.

A forest is not run by a central brain. A mycelial network has no controller. Intelligence is distributed across the whole network, and intelligent behaviour emerges from many simple parts following local rules. Nutrients, water, and chemical signals flow along the network to where they are needed. A dying tree sends its carbon to its neighbours. A mother tree feeds its seedlings through the fungal web. When part of the network is cut, it reroutes. Paths that carry value are reinforced. Paths that do not are abandoned.

That is a working description of a well-designed AI system. Many processes, not one monolith. Inputs flowing to where they are transformed, outputs flowing to where they are needed. Signals travelling back to trigger response. The system reinforcing what works and pruning what does not. Resilience through redundancy rather than a single point of control.

So the vocabulary bloom uses to design systems is the vocabulary of living networks. Not because it looks good, though it does, but because it is genuinely how these systems behave when they work.

Every system bloom maps, whether it is the intelligence layer, a client workflow, or the build pipeline itself, is built from the same six elements. Three are nodes (nutrients, growth, soil), one is the connector (channels), and two are the controls (membranes, signals). The controls are where the human’s attention belongs. Naming them in living terms keeps the thinking clear.

Nutrients (inputs). What flows into the system, and from where. Research, client answers, existing content, live data. For each, the question is its source, its form, and whether it can be trusted, the way a network draws from soil, sun, and rain, each with a different reliability.

Growth (transformation). Where raw input is transformed into something useful. This is where the heavy computation lives, the photosynthesis of the system. It is the part the machine does, and the part the human no longer does by hand. Nutrients feed growth.

Soil (the store). What the system remembers, and the richest, most living part of it. At the scale of a single client it is their brain: the structured understanding of that one business. At the scale of the whole network it is the soil proper: the collective intelligence accumulated across every client, the patterns of how businesses work, the commons that every engagement draws from and feeds back into. Each client’s brain draws nutrients from the soil and enriches it in return, the way a tree trades with the network through its roots. The soil gets richer with every engagement. That compounding is the moat.

Channels (flow). The hyphae and roots, the connections along which everything moves. In a map these are not dead arrows. They are living channels, and where they run determines what the system can do.

Membranes (checkpoints). The most important element, and the focus of the human’s attention. A membrane is a selective interface that only lets through what meets its criteria. In nature the root and the fungus exchange across a membrane, each passing only what it should. In a bloom system, a membrane is a checkpoint: a point where the flow is checked against a goal before it is allowed to continue. Some membranes are automated, checking against a rubric, a validation, a threshold. Some are human, where a person must approve before the flow proceeds. A membrane with nothing to check against is not a membrane. It is a hole.

Signals (feedback loops). The chemical messages a network sends back through itself, warning of a pest, calling for resources, triggering a response. A feedback loop is a signal that measures the output against a goal and feeds the error back as a correction. For a loop to be real it needs three things, the same three a forest needs to respond to drought: a goal it is trying to reach, a measured sense of how far it is from that goal, and a correction it makes in response. A loop missing any of the three is not a loop. It is a re-run, and it will burn resources circling. And every loop must know when to rest: it pauses when its goal is met or while it waits on a signal, and wakes when the next trigger comes. A loop that never rests runs forever and exhausts the system.

The reason the human focus belongs on the checkpoints is simple: the quality of a system is set by its membranes, not by its computation.

The machine inside can be brilliant or mediocre. What guarantees the output is good is the membranes catching what is wrong before it passes. A well-membraned system running ordinary computation beats a brilliant computation with no checks, because the checks are what make the output reliable rather than merely impressive. So you do not optimise the computation. You optimise the checking. That is where all the leverage is.

Getting good at membranes is a discipline with real principles.

Place a membrane where being wrong is expensive. Not every step needs a gate. You check before anything irreversible or high-stakes: publishing, sending, spending, deleting, anything a client will see. Cheap, reversible, internal steps flow freely. The skill is gating exactly where an error is costly and nowhere else, because every needless membrane slows the system and consumes attention that is better spent elsewhere.

A membrane needs something to check against. A gate with no criterion is theatre. Every checkpoint must hold an explicit standard: passes the seven jobs, contains no invented content, meets the threshold, the human approves. If you cannot say what is being checked, the checkpoint is not real.

Human membranes are the scarcest nutrient. Spend them deliberately. Every human gate consumes a person’s attention, and attention is the true bottleneck of the whole system. So human gates go only where human judgement is genuinely irreplaceable: taste, the final check that nothing was fabricated, the approval of an irreversible action, the strategic call. Anything an automated check can catch, it should. Reserve the human for what only a human can judge. The art is the smallest set of human membranes that still keeps the system safe. Too many, and you have rebuilt the manual process you were trying to escape.

A loop should converge, not circle. In a healthy loop the error shrinks each pass, the way a network grows steadily toward a nutrient. If the error is not shrinking, the loop is broken: the goal is unclear, the signal is wrong, or the correction does not address the error. Watching whether loops converge is how you tell a living system from a thrashing one.

This reframes the human role entirely, and it is worth holding onto.

In a forest, no one photosynthesises on the tree’s behalf. The work happens in the network. What a good forester does is shape the conditions, decide where the membranes are, prune what is not working, reinforce what is, and redirect flow when it stalls. They tend the living system. They do not do its growth.

That is the role. You are not the computation. You are the one who designs where the channels run, places the membranes, names what each one checks for, sets the loops and when they rest, and tends the whole thing as it grows. The machine does the heavy work inside. You make the system correct, efficient, and alive.

This is why mapping matters so much. You cannot tend a system you cannot see. The map is how the living system becomes visible: where the nutrients come from, how they flow, where they are transformed, where the membranes sit, where the signals loop back. And because the map is editable, it is also how you improve the system. You find the weak membrane or the loop that will not converge, and you change it. The map is not a picture of the work. It is the instrument of the work.

bloom is, underneath everything, a set of living systems. The studio build is a system that draws in a business’s reality, transforms it against bloom’s standard, and passes it through membranes that catch invention and enforce the craft. The intelligence layer is a system that ingests how a company runs and keeps a living model of it current. A workflow automation is a system that senses a trigger, drafts a response, and passes it through a human membrane before it ships. Each one has nutrients, growth, soil, channels, membranes, and signals. Each one is tended, not operated.

So the visual mapping tool is not a feature. It is the instrument through which bloom designs and tends all of this, and through which it shows clients their own systems, current and improved. It should speak in the living vocabulary, and it should make the membranes and the loops the most prominent things on the canvas, because those are what the human is there to optimise. Boxes and arrows draw the obvious. A bloom map should draw the channels, the membranes, and the signals, because that is where the thinking lives.

The principle to hold above all the rest: you are designing the system and placing the membranes. The machine does the computation inside. Your entire leverage is in where the channels run, what the membranes check for, where the loops close, and where a human must decide. Everything else, the system can do itself. Tend it well, and it grows.