The uncompiled institution

An institution is not a building.

It is not a document.

It is a state machine.

It coordinates roles, authority, budgets, decisions, work, ownership, and value flow. It defines what can happen, who can act, what counts, and what changes state.

But most institutions still run on text.

The mission is in one document. The cap table is in another. Governance is in agreements. Decisions live in meetings. Work lives in task tools. Context lives in chats. Judgment lives in people's heads.

The institution behaves like software. It is implemented as paperwork.

Institutions are software that has not been compiled yet.

Text creates drift

Text is powerful because it can express ambiguity. That is also why it creates drift.

Two people read the same agreement and see different obligations. A spreadsheet lags behind the real ownership state. A decision made in a meeting never becomes an operational rule. A task finished without becoming company memory.

These are not process failures. They are consequences of the substrate. When the canonical state of the institution lives across documents and human interpretation, the institution drifts.

The company says one thing in its docs, does another in its tools, remembers a third in chat, and asks people to reconcile the difference.

Tolerable when organizations moved slowly.

Not tolerable when agents and software can move continuously.

Agents make the old substrate break

AI introduces non-human operational capacity into the company. That capacity needs context, permission, scope, memory, escalation, and accountability.

An agent cannot reliably operate a company whose rules are scattered across PDFs, chat threads, spreadsheets, and informal judgment. The agent needs the company to become machine-readable.

Humans do not disappear. Human intent needs an operating surface. Mission, authority, roles, decisions, and work need to become state the company can execute against.

This is why the programmable company matters.

I spent a year trying to fix this with documents. Better templates, better agreements, better cap-table tools. Documents were the problem.

The compiler

To compile an institution is to turn it into executable state.

Not only legal state. Not only financial state. Operational state: who can act, what is being pursued, what happened, what was decided, what should be remembered, where authority sits.

In an uncompiled institution:

• context lives in people's heads
• authority lives in documents
• work lives in separate tools
• memory lives in chat
• ownership is reconciled after the fact

In a compiled institution:

• roles define responsibility and scope
• agents and humans execute inside those roles
• quests move work forward
• events record what happened
• ideas preserve what the company learns
• governance and treasury sit beside the work

aeqi is built around this compilation. The current product wedge is the execution runtime. The deeper layer is authority, treasury, governance, and ownership.

The point is not to put a shiny agent interface on top of the same old company. The point is to make the company itself executable.

The firm must be compiled

The old company was assembled: documents, accounts, meetings, tools, signatures, cap table, workflows, and manual reconciliation.

The new company is deployed, staffed, remembered, governed, and eventually owned through one operating grammar.

That is the institutional argument. The landscape explains why the existing categories miss it. Programmable capitalism carries the full long arc.

A company is software waiting for someone to ship the runtime.