The machine

In Thicket Web Mind, the machine is the foundational building block. Not a server, not a service, not a container — but a machine in the original, almost mechanical sense: something that exists to do, react, and persist its own continuity. Everything else in the methodology — Thickets, Symbionts, Avatars, Mycelium, Membranes — is built on top of this idea.

Compile-time configured executable

A machine is a single executable, configured at compile time. This is a deliberate constraint. Instead of late-bound configuration, dynamic wiring, or runtime composition, the machine is decided before it starts running. Its role, capabilities, and boundaries are known in advance. The consequences are predictability, inspectability, and explicit failure modes. Meaning is not injected at deployment time; it is compiled into the machine itself. The executable is not a shell — it is the organism.

Event-based reactive stream manager

At runtime, the machine acts as an event-based reactive stream manager. It does not “handle requests” in the traditional sense. It observes, produces, transforms, and reacts to events. Events form streams, streams form behavior, and behavior defines the machine’s life. Time becomes a first-class concept: events happen in sequence, in relation, and in context. The machine does not compute isolated answers; it participates in an ongoing flow.

State

The machine is stateful — unapologetically so. But state is not something that is poked, mutated, or casually rewritten.

State managed with events.

All state transitions happen through events. An event is not merely a trigger; it is a fact — something that happened. State is therefore derived from the history of events the machine has processed. This makes state explainable: when something looks wrong, the question is not “who changed this variable?”, but “what events led us here?”.

State persisted into the store.

State is persisted into a store, local to the machine. There is no implicit global database. Persistence is not an external service but a responsibility of the machine itself. Each machine owns its data, understands its structure, and decides how it should be stored. This reinforces locality, autonomy, and resilience. A machine can stop, restart, or move — and still remain itself.

Producers and long-running functionality

Some behaviors cannot be expressed as short-lived reactions. For this, machines use Producers. A Producer is a long-running process inside the machine — often implemented as a fiber — that continuously produces events. It may listen, poll, wait, aggregate, or mediate between different streams. Producers are how machines stay alive.

RPC for the Mycelium.

Within a Thicket, machines communicate through the Mycelium, typically using RPC-like interactions. This communication is explicit, structured, and intentional. Machines know which other machines they can talk to, and why. The Mycelium is not a free-for-all network; it is a connective tissue. RPC here is not about pretending everything is local — it is about acknowledging distance while still enabling cooperation.

HTTP for the Membranes.

When a machine needs to communicate beyond its Thicket — with users, browsers, external systems, or the wider web — it does so through the Membrane, most commonly via HTTP. The Membrane is a boundary, not just an interface. It translates between the internal, event-driven life of the machine and the request-response expectations of the outside world. Internally, the machine remains stream-based and stateful; externally, it speaks in the languages the world already understands.

Finale

This post describes the machine in isolation, but no machine is meant to exist alone. In the next parts of the series, we will look at how machines form Thickets, how they cooperate through the Mycelium, and how higher-level roles such as Symbionts and Avatars emerge naturally from these foundations.

Next installment