A startup is learning, not code.

Not because software stopped mattering. Because software got cheap enough that code is no longer where value hides.

For twenty years the startup religion was simple. Pick a workflow. Build a product around it. Capture the data. Lock the customer into the workflow. Charge per seat. Expand. Do it well and you owned a system of record. Do it late and you shipped one more dashboard to people already drowning in software. That game is ending.

The future software company isn't a bundle of screens around a database. It's a learning machine for one economic domain. It watches work, turns activity into accepted outcomes, learns which evidence mattered, improves the next run, and charges for the value it created.

Code is just how the loop expresses itself this week.

Most people feel half of this. They've seen AI write code. They know a teenager can build in a weekend what used to take a team a quarter. But they file it under a productivity gain inside the old model. It isn't. When the cost of making software collapses, the reasons software companies existed collapse with it. The backlog loses its power. The roadmap loses its power. The workflow moat loses its power.

The hard thing was never building the thing. The hard thing is knowing what to build, why it matters, what outcome it should optimize for, what proof is required, and how the system should learn when reality disagrees.

Software is getting cheaper. Learning is getting more expensive.

Vertical SaaS was a very good business because it bundled three things: the workflow, the data model, and distribution.

The application defined how work happened. The schema defined what reality was allowed to look like. The sales motion defined who reached the buyer. That bundle was the moat. AI breaks the bundle, and once a moat cracks, even a little, value doesn't politely stay where it used to sit.

The systems of record don't disappear. ERP, CRM, procurement suites, the data warehouse, they all remain as sources, targets, constraints, and audit anchors. They just stop being where the strategic value concentrates. Value moves to the layer that knows how to turn activity into outcomes.

This is the Spotify shift, arriving for enterprise work. Before Spotify you bought the package: album, label, format, shelf space. Spotify pulled out the one activity people actually cared about, listening, and rebuilt the economics around access and use. Enterprise work is going through the same unbundling. The buyer doesn't care which app created the task or which screen looked official. They care that the invoice reconciled, the contract risk was understood, the claim paid correctly, and the audit evidence held.

We're the rails for that shift. Not another vertical app. Not a copilot trapped inside someone else's interface. The rails that let activities become outcomes, outcomes become priced units, and priced units become learning.

We've trained ourselves to see a business as a static picture. The org chart, boxes and reporting lines. Or the pipeline, work in on the left, revenue out on the right. Both are maps, and both are dead the moment they're drawn. Nature and systems theory both point somewhere better: the loop.

Systems theory has a name for it, the reconcilerReconcilerA control loop with a goal. It senses the world, compares it to the goal, acts on the difference, and repeats. A thermostat is one. So is Kubernetes.. It's the primitive under everything in this piece, and it gets powerful the moment you take it seriously.

A thermostat is the smallest honest example. It has a goal. It observes the room. It compares what is to what should be. It acts, heat on, heat off, and then it does it again. It never runs once and declares victory. It optimizes against a state, continuously.

Kubernetes is a reconciler too. You declare what should be true. It looks at what is true. If a pod dies, it brings one back. If capacity shifts, it adjusts. No manager reads a dashboard and decides the next move. The system is built around desired state, observation, action, and correction.

An organization runs on the same machinery, it just doesn't know it. Underneath the map, every function that matters is already a loop: close the books, renew the policy, patch the fleet. Sense, compare, act, again. Today humans run those loops by hand, playing middleware between systems that should already know what they're trying to achieve. The question isn't whether your business has loops. It's whether anyone built them on purpose.

Notice what a reconciler does not do. It doesn't model the whole world. It keeps a reduced, biased picture of the environment, just the few variables that move its goal, and treats the rest as noise. That isn't a shortcut. It's the design. A cell survives the same way, holding operational closure around what keeps it alive rather than representing everything outside it. The environment is the goal, and bias is the direction.

The goal can be almost anything a business can price. Cash payback on a cost removed. A cleaner insurance renewal. A faster close. Point the same loop at a different number and you get a procurement thermostat, or an insurance thermostat, or a finance one. Which number, and which evidence counts toward it, is a taste question — that's chapter 05.

Graphs get interesting here too, not as fashionable data structures, but as part of a reconciler. The goal isn't graph completeness. The goal is economic movement: payment, savings, a lower dispute rate, a shorter cycle, accepted evidence. The field notes in chapter 04 show what that discipline looks like in practice.

from the treeThe good regulator theorem, 1970: every good regulator of a system must be a model of that system. The case against the map, settled formally.open the node

A workblock is not a workflow. It's a small, governed machine for doing work: boundaries, inputs, evidence, human checkpoints where they matter, a price, and a result. It can be reused, improved, or killed if it doesn't work.

But here's the part that matters most. Every workblock is also a sensor.

It observes which inputs were actually needed, which document mattered, which policy changed the decision, which human correction altered the outcome, which source system was trusted, which exception repeated, which output was disputed, which model call was waste. Legacy systems lagged that signal so badly they just saved everything, the data lake as a prayer. Store it all, structure it later, hope someone finds value in the swamp.

That made sense when interpretation was expensive. It makes much less sense when a reconciler can ask a better question. Did this signal improve an accepted outcome? If yes, promote it. If no, leave it as residue.

This is why activity-based pricing matters. It's the highest-order evidence layer we have; the commercial model is almost a side effect. When a client pays because a workblock created savings, processed a claim, or proved compliance, the system gets a cleaner signal than any survey or roadmap vote could give it. Money isn't the only truth, but in business it's the least fake one.

Work Credits make the loop economic. Partners earn when workblocks run and create value. Clients pay when work is accepted. We learn from what gets consumed. Dead workblocks stop earning; useful ones compound. That's a very different loop from traditional SaaS, where revenue can lock in for years while the product quietly gets worse.

from the treeActive inference: acting and sensing are one move — every act tests the model that chose it. A workblock is that move, with a price on it.open the node

If software can be generated around the problem, taste becomes the scarce input.

Business people tend to misread taste as polish. Nicer typography, rounded corners, a founder being precious. Taste is harder than that. Taste is knowing what matters before the spreadsheet can prove it. It's compressed experience. It's the scar tissue of judgment.

In this architecture, taste decides what the reconciler optimizes for. It decides which evidence is real, which exception deserves automation and which should stay human, and whether a generated interface makes work disappear or just adds a cleverer obstacle.

A cybersecurity graph with taste isn't a pile of controls; it knows which proof creates trust. An insurance graph with taste isn't a map of every claim relationship; it knows which signals change payout quality and fraud risk. A procurement graph with taste isn't a supplier database in costume; it knows where the money leaks, where the policy gets ignored, and where the leverage lives.

Taste, plus distribution, plus learning. That's the new moat.

from the treeEnactivism, 1991: knowing as the practiced fit between organism and environment. Taste is that fit, compressed into judgment.open the node

Here's the harsh, liberating part. A lot of enterprise software isn't very valuable.

Much of it is routing, forms, approvals, field mapping, dashboards, and reminders. People pretending that clicking buttons is knowledge work. It exists because building something more specific used to be too expensive, and changing the system underneath used to be too risky.

AI changes that. The common ninety percent becomes automation infrastructure. The domain-specific ten percent is where the value lives: evidence policy, exception logic, economic tuning, human judgment, taste, and the reconciler. The learning from automation is valuable. The screen is not.

This is also why the consulting and service layer gets more valuable, not less. It holds the operating reality software vendors rarely see. The playbooks, the workarounds, the exception queues, the escalation paths, the audit evidence, the human corrections. The stuff traditional software treated as garbage is the shadow operating model of the enterprise. Thirty years of BPO and consulting residue can become gold.

Not by dumping every client's data into one training lake. That would be stupid, and probably illegal. By turning lived operating knowledge into reusable workblocks, late-binding ontologies, evidence policies, and domain reconcilers that prove their value through accepted outcomes.

That is the company.

from the treeLuhmann, 1984: organizations are self-producing. The workarounds and exception queues aren't noise around the company — they are the company.open the node

In a world where software stops being a destination, two things are left: intelligence and distribution.

Right now, almost all the money is betting on intelligence. Models, agents, benchmarks, compute, data centers, energy. That bet is real. Intelligence will be valuable. It'll also commoditize faster than most people want to admit. The frontier moves, open source catches up, routing abstracts the differences, and enterprises stop caring which model did the work if the outcome is trusted.

Distribution is different. In enterprise, distribution isn't a download button. It's trust, liability, context, access, and reputation. The ability to sit with a client when something breaks and say, we own this. That doesn't commoditize the same way. No Fortune 500 rebuilds core operations with a random vendor because a benchmark moved three percent. They call the people they already trust.

Silicon Valley is betting intelligence replaces the human layer. We're betting intelligence makes the human layer more valuable when it's amplified correctly. Not human in the loop. That phrase is too small; it makes the person a safety brake on an otherwise autonomous machine. We're building an amplifier of human value. The consultant closest to the problem can now author a workblock. The domain expert can turn judgment into a reusable asset. The partner can leave behind something better than a slide deck.

The model doesn't know the client. The human does.

from the treePromise theory, 2005: autonomous agents making voluntary commitments about their own state. Enterprise trust, formalized.open the node

Charlie Munger's rule: invert, always invert. Don't only ask how to win the game — ask which game you shouldn't be playing at all.

The obvious game is to build another vertical SaaS company with AI features. Pick a category. Raise money. Build workflows. Hire sales. Overspend on acquisition. Bolt on a copilot. Pretend the data model is a moat while the workflow gets generated around the problem. That's chess on someone else's board.

Invert it. What if the most valuable software company of this era doesn't own the workflow, but owns the ability to create, price, govern, deploy, and learn from workblocks across many workflows? What if the vertical app becomes an implementation detail, the static schema a temporary binding, the operational residue the training signal, and the consultant not a labor cost to remove but distribution to amplify?

And here is the part people miss. This company isn't really about what we build. It's about a moment in time when everything breaks. Spotify didn't kill the record labels, and it never needed to. Their pain simply grew big enough that the old economic model came apart, and someone was standing there with a better one. That's the unbundling from chapter 02, read as timing. The same setup is true for us. Everything is in place, the incumbents are straining, and the whole thing is waiting for someone to light the fuse.

Don't build the palace. Build the rails the next thousand palaces run on.

The old model rewarded careful feature planning because software was expensive.

Every feature was maintenance debt. Saying no was usually right, because saying yes cost too much. When the cost of trying collapses, reflexive restraint becomes the wrong instinct. The new question isn't whether a feature is worth a quarter of engineering. It's whether we can learn something economically useful by trying it now.

That rewards a different kind of organization. Build quickly. Ship agentically. Get close to the client. Watch the ass-kicking honestly. Keep what works; throw away what doesn't.

Pods are the right metaphor, because the company should behave more like Kubernetes than a corporate hierarchy. Small units with clear purpose, bounded autonomy, health checks, fast replacement, continuous reconciliation. If a pod works, scale the pattern. If it doesn't, kill it and learn. The center shouldn't become a permission machine. It should become a scaling layer.

from the treeAshby's homeostat, 1948: a machine that found viable states by rewiring itself and keeping what held. Build fast, throw away, keep what holds.open the node

Conway's law says organizations end up shaping the software they build. Bureaucratic company, bureaucratic software.

Beyond Work inverted it on purpose: shape the org like software instead. That turns out to be the same rule already running the pattern. Write down how one small piece behaves. Let enough of them run. See what shape falls out.

A pod is the growing tip. Three to seven people, forward-deployed inside a partner's delivery, never asked to see the whole company, only to be right about the one client in front of them. Beyond Work doesn't scale a pod by making it bigger, any more than lichen scales a branch by making it longer. When a pod has enough to spend, it branches. A new pod, cloned from what worked, not grown from what's already there.

A spoke is the mycelium, not a department. It curates a domain, it doesn't create the work in it. Procurement, finance, payroll, running across every partner at once, moving what one pod already learned about a client's process to the pod that's about to need it, before it has to relearn it the slow way. A spoke doesn't decide what a client needs. That stays with the pod, the way the tree decides what's worth growing toward, not the network underneath it.

A pod knows the client. A spoke knows the network. Neither one runs the other.

The hub isn't the trunk of one tree. It's what foresters call a hub tree, the most connected node in a network, the one every other tree ends up drawing through, not because it's the biggest but because of where it sits. Builders keep the craft sharp. Impact keeps it reaching. Scalers keep it light. It's capped at 150 for the same reason a hub tree never tries to become the whole forest: past a certain size, adding more of yourself stops being leverage and starts being the bureaucracy the whole company exists to replace.

Fabric is the part no client ever sees. The nervous system, not the face. Every escalation, every routing decision, every quiet handoff from one pod to the next runs through it, and none of it is visible from the client's side of the table. They just get a pod that already knew, and a workblock that arrived faster than it should have. The way nobody sees mycelium unless they dig, or sees Uber's dispatch layer, only the car that shows up. Invisible isn't a gap in this design. It is the design.

Pods and partners move because they're close to the problem, not because a planning cycle finally cleared them to. This is asymmetric warfare against entrenched systems: small units, local knowledge, intimate terrain, and a platform that lets the pattern travel.

Small units. Local knowledge. Fast adaptation. More Che Guevara than NATO procurement.

Reward the people who move, not with vague partner points, but with economics. Create accepted outcomes, you earn. Build reusable workblocks, you compound. Keep quality, you keep earning. The workblock dies, the economics stop. Nobody drew this shape. It's what the rule looks like once enough pods have run it.

from the treeAutopoiesis — self-making, 1972: a closed network of processes that produces its own components. The org chart nobody drew has a name.open the node

It would be a mistake to turn this into a roadmap. Roadmaps feel safe because they pretend the future is a sequence of planned features.

What's happening now isn't a feature sequence. It's a correction of an imbalance. For decades, enterprise software accumulated power because building was expensive, integration was hard, and structured data created lock-in. AI breaks enough of that for the system to rebalance.

Capital is flooding into intelligence. Enterprises still need trust, distribution, liability, and judgment. One side is getting overbuilt. The other is barely getting built. Markets correct.

We don't need all of this ready tomorrow. That's not how self-optimizing systems grow. The economic engine structures the rest. Work Credits create the signal. Workblocks create the unit. Fabric creates the operating layer. Reconcilers emerge where the outcomes justify them, and data gets structured only when the value is worth the maintenance.

Still, some pieces are not optional. The thermostat cannot run without them. Activity-based pricing is the first: it carries every workblock from accepted work to an economic outcome, and that outcome is the signal the loop reads. Fabric is the second, our own system of work, the Conway’s-law hack that shapes the company like the product instead of the other way around. And then we need iterations, many of them, so the learning graphs start to fill across every domain at once.

from the treeThe open question near the top of the tree: can environment-coupled reconciliation replace the spec? A roadmap is a spec. This chapter is the wager against it.open the node

So here's the bet, stated plainly.

It's governed systems of work that understand intent, sense reality, act through workblocks, prove outcomes, and improve continuously. That's why Beyond Work matters. Not a nicer interface. Not one more AI workflow platform. We're placing the company where the system will rebalance: where intelligence meets distribution, trust meets automation, and thirty years of operational residue becomes accepted work, then signal, then advantage.

The old software company asked: what can we build? The new one asks: what can we learn that makes every future unit of work better? That's a better question. It's also a much bigger company.

Software is getting cheaper. Taste, trust, and learning are getting more expensive. That's the bet.

from the treeOne loop, four lineages? — the question the whole tree points at. This chapter is the bet that the answer is yes.open the node