The Thought Factory

Programming, in the abstract, is an act of translation. It bridges the world of people and the world of machines. The machine world operates on its own set of primitives, so we translate not just between languages, but between concepts and their implementation. We refine and decompose requirements laterally among people, and then translate them vertically into the machine world. The gap between human language and machine language has been the defining problem of our field for its entire history. Every generation of tooling has narrowed that gap: assemblers, compilers, high level languages, frameworks. LLMs have closed it. They translate between human language and machine language directly, in both directions.

The programmer landscape is in upheaval. Toolsets are expanding, trying to find the next natural boundary for our role, and an ecosystem of agent-orchestrated software factories has emerged. Something more fundamental than new tooling is happening. For programmers specifically, LLMs have moved our boundaries of thought by one full step. We are abstracting the processes of thought that we've been using to deliver. If you start from that perspective, and set the goal of building a detailed, executable thought process, you still end up building something like a factory, but the software is an afterthought.

Traditionally, gates in computing have operated on numbers. AND, OR, NOT, XOR: binary math. Even probabilistic systems like Bayesian classifiers and Monte Carlo simulations are still probabilistic over math. LLMs are different: the input/output surface is semantic, not numerical. We have inadvertently brute forced a concept model through scale and training data, and it is effectively a new kind of primitive. An agent gate. Loosely structured meaning goes in, structured meaning comes out, with some probability of being right. Under the hood, it is still running on the same numerical architecture as everything else. This gate, and everything we can build with it, is genuinely new territory.

The agent gate enables a nondeterministic circuit. The simplest version of this is a loop: a prompt goes to an agent, and each time output is generated, it becomes the next input. A real implementation does the same thing, with a harness around the gate that restructures, reprocesses, and recontextualizes the output before each pass. When the design and state of that harness are themselves inputs on each fire, the agent can reason about itself as a system. A circuit that can observe its own structure and propose changes to it has crossed a line. It is participating in its own design, and the boundary between the system and whatever is operating it starts to dissolve. Take that a step further: when the circuit is two-fold, the first half can propose a change and the second half can implement it. When we get back to the first agent, the original context has been transformed by the work of the second. The agent gate builds into the conversation circuit. A conversation can grow and evolve.

The output of the gate is bounded by the quality of its input. The problem of deciding what each gate knows, at what level of detail, scoped to what it actually needs, is not an engineering problem. It is a management problem. It is arguably the only management problem. Every other function of management, delegation, review, structure, is in service of getting the right knowledge to the right gate at the right time. The knowledge itself is not flat. Concepts relate to other concepts at different levels of detail. And because the gate operates on language, the knowledge is represented as language. The same concept can be described at different levels of detail depending on who needs it. A gate deep in the circuit needs a different description, at a different resolution, than a gate near the top.

When multiple circuits are organized together, the collective reprocessing and restructuring mechanics behave as a general purpose information processing machine. The semantic surface area of the I/O around the agent gates results in a natural conceptual hierarchy. A high level concept at the top of the network becomes multiple, deeply narrowed scopes of focus as the concept is digested by the machinery. The nondeterminism of the system, at this point, is a function of the specific LLM outputs each time the circuit fires. Reprocessing those outputs through the structure, reviewing them at each level, and feeding the results back into narrower and narrower scopes drives the system toward determinism. No single gate needs to be reliable. The circuit as a whole needs to converge.

That handles short-term convergence within a single pass. Long-term convergence requires something else: persistent structured memory and the synaptic connections for accessing it. Knowledge that survives any individual gate firing and is available to shape the next one. When the circuit can accumulate and recall, it does not start from zero on each pass. It compounds. And at that point, what has been built is not a new kind of software architecture. It is the same information processing structure that people organizations have always been.

A hierarchy of positions with bounded context, persistent memory, and convergence through review is not a new structure. It is the structure of every organization that has ever existed. An org chart is a routing topology. A job description is a context boundary. A meeting is message passing. Delegation routes work downward, results flow upward, and review applies judgment at the boundaries. We have been building these circuits out of people for as long as organizations have existed. The only thing that has changed is that the agent gate gives us a second kind of processor that can occupy positions in the same circuit.

The same pattern shows up at every scale we have looked at so far. The internal structure of the gate, the loop of the circuit, and the hierarchy of the organization are all expressions of the same recursive shape. Recent research into transformer internals bears this out directly: the middle layers of an LLM operate in a format-agnostic concept space where content identity dominates language identity, bracketed by language-specific encoding and decoding phases on either side. The gate itself is a circuit, with the same encode, reason, decode structure that the outer loops replicate. What we find inside the LLM is not a different kind of system. Its internal architecture is a lower-level virtualization of the same circuit we build around it, implemented in weights and attention patterns instead of code. Attention heads are bounded context windows at a different scale. The recursion is not an analogy. There is no reason to believe it stops at any particular level, in either direction.

The ecosystem is already reaching for this shape from multiple directions. Some projects are building workflow pipelines with dependency edges and review gates. Others are building agent hierarchies with persistent state. Others are building systems where agents propose and vote on their own structural changes. Dozens of projects are each solving a piece of the puzzle, and the pieces are starting to look like each other. What they share is the recognition that running agents is not the hard part. Coordinating them is. Where they differ is in where they start: almost all of them are building bottom-up, starting from execution and reaching upward toward structure as problems emerge. The structure is not an add-on. It is simply the design. Starting from the organizational model and working down to execution produces a fundamentally different system than starting from execution and bolting on coordination after the fact. The latter gives you a collection of agents that happen to be running at the same time. The former gives you a circuit that knows what it is.

If we are programming the inside of the LLM in human language, we have to step back and think about what we are actually doing. If the pattern is recursive, self-restructuring, and unbounded by scale, what have we built?

This post is not an advertisement. brained is not ready for general availability. I want to see many implementations of the harness emerge from this design philosophy. The hivemind will only be stronger for it.