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, and work. 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. 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.

And software that has not been compiled cannot run on its own. That is the real cost: a company stitched together from prose only moves while the people holding the threads keep pulling. Step away and it stops.

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 decision made in a meeting never becomes an operational rule. A task is finished without becoming company memory.

These are not process failures. They are consequences of the substrate. When the canonical state of the company lives across documents and human interpretation, the company drifts — saying one thing in its docs, doing another in its tools, remembering a third in chat, and asking people to reconcile the difference.

Tolerable when organizations moved slowly.

Not tolerable when agents can move the work continuously.

Agents make the old substrate break

AI introduces non-human operational capacity into the company. To use it, you need a company an agent can actually operate: context, permission, scope, memory, escalation, and accountability — all legible, not buried in PDFs and informal judgment.

An agent cannot reliably run a company whose rules are scattered. It needs the company to be machine-readable. So the question behind "can my company run itself?" is really: has the company been compiled?

Humans don't disappear. Human intent needs an operating surface. Mission, authority, roles, and decisions become state the company can execute against — and then keep executing against without a person in the loop for every step.

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

The compiler

To compile an institution is to turn it into executable 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 company:

• context lives in people's heads
• authority lives in documents
• work lives in separate tools
• memory lives in chat
• nothing runs unless a person runs it

In a compiled company:

• 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
• the work keeps moving when you step away

aeqi is built around this compilation. The wedge is the execution runtime — the part that lets a Company actually run. Authority, treasury, and governance sit deeper, beside the work.

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, workflows, and manual reconciliation. It runs at the speed of the people inside it.

The new company is deployed, staffed, and remembered through one operating grammar — and it keeps running between the moments you touch it.

That is the whole argument behind starting something that can work without you. A company you have to operate by hand is not leverage. A compiled one is.

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