The Protocol Firm

Where the last series stopped

The Firm Under AI ran for sixteen posts around a Coasean question: why do firms exist, and what happens to that answer when intelligence, execution and coordination all get cheaper?

It ended with a claim I still think is right.

The firm does not disappear. More execution moves outside the payroll, into networks of people, contractors, suppliers, software services and agents. But intent, accountability, liability and governance do not disappear with it. They remain institutional.

The closing line was:

The firm does not disappear. It ascends from operator to governor.

That was a useful ending, but it left the hardest part under-specified. What does “governor” actually mean in operating terms?

This series starts there.

The question

How does a firm operate when it governs more work than it directly executes?

I am not asking whether this is desirable in some general sense. I am asking what the operating model looks like if it is already happening.

What does the organisation contain when a meaningful share of the work is performed by parties it does not employ, systems it does not own, and processes no manager directly watches?

That question has become sharper because software has crossed a practical threshold. The important change is not that software can produce better text or pass more benchmarks. It is that software can now act.

An agent that drafts a reply is a tool. An agent that sends it, spends money or changes a production system has been given authority.

That is the line I care about. Not intelligence in the abstract. Consequence.

What governance has to become

Traditional governance mostly sits around the work:

Policy → training → human judgement → periodic audit

Policies are written and published. People read them, sometimes. Managers apply judgement at decision points. Auditors check samples later.

That model depends on a human being in the path. Someone can be trained. Someone can be asked why they made a decision. Someone can be disciplined, overruled, promoted, insured, sued, or removed from the role.

Once work is delegated to agents, services, suppliers and dynamic networks, that assumption weakens.

A policy document does not constrain a process that never reads it. An audit may still matter, but it arrives after the action has reached a customer, supplier, payment rail or production system. Training is not the right control for a non-human actor.

So some governance has to move closer to execution:

Intent
  ↓
Policy
  ↓
Machine-readable rule
  ↓
Identity + delegated authority
  ↓
Runtime constraint
  ↓
Action
  ↓
Evidence
  ↓
Evaluation
  ↓
Escalation or learning

This is not a claim that judgement, ethics, law or context can all be encoded. They cannot. Any system that pretends otherwise is dangerous.

The practical claim is this:

The parts of governance that can be made explicit can increasingly be made executable.

That is where the idea of the Protocol Firm begins:

Authority becomes a software primitive.

Authority stops being only a job title, a policy paragraph or a line in an approval matrix. It becomes a capability a system can hold, check, grant, scope, observe and revoke.

The three planes

The structure I am going to use throughout the series separates three things:

1. what the organisation intends;
2. how interaction is structured;
3. who or what performs the work.

                 HUMAN INTENT
                      │
          ┌───────────▼──────────┐
          │   GOVERNANCE PLANE   │
          │   policy, identity   │
          │   authority, risk    │
          │   budgets, evidence  │
          └───────────┬──────────┘
                      │
          ┌───────────▼──────────┐
          │    PROTOCOL PLANE    │
          │  contracts, events   │
          │  workflows, schemas  │
          │  interaction rules   │
          └───────────┬──────────┘
                      │
          ┌───────────▼──────────┐
          │    EXECUTION PLANE   │
          │  humans, agents      │
          │  services, suppliers │
          │  other organisations │
          └───────────┬──────────┘
                      │
                   OUTCOMES
                      ↓
                   EVIDENCE
                      ↓
                  EVALUATION
                      ↓
            ACCEPT OR EXCEPTION
                      ↓
               HUMAN JUDGEMENT
                      ↓
                   LEARNING
                      └──────→ GOVERNANCE

These are conceptual planes, not a vendor architecture. Policy engines, identity systems, durable workflows, evaluators, MCP servers, A2A-style capability descriptions and agent gateways may all implement parts of the model. None of them is the model.

The governance plane decides what may happen. The protocol plane defines how interaction happens. The execution plane does the work.

Evidence then flows back up. The organisation decides whether the result is acceptable, whether a human needs to intervene, and whether the rules should change.

Most firms already have all three planes. They are just tangled together inside job descriptions, approval chains, spreadsheets, contracts and institutional habit.

The Protocol Firm pulls them apart because delegated execution only works if the firm can retain intent.

Participants, not just employees

The execution plane contains a mixed population:

employees      contractors      suppliers
specialists    AI agents        software services
partners       other organisations

Traditional management treats these as different categories governed by different mechanisms: employment law for one, commercial contracts for another, IAM for another, and for AI agents, often improvisation.

The Protocol Firm treats them first as participants in governed work.

Participant = identity
            + capability
            + authority
            + obligation
            + reputation
            + risk

That does not mean agents are people. It means employment was never the only thing doing the governance work.

Employment bundles identity, authority, obligation, accountability, reputation and risk into one institutional form. When work is unbundled, those elements have to be named and governed directly.

A contractor, a supplier API and an AI agent can all be participants. What differs is the authority they hold, the evidence they must produce, the way their output is verified, and who carries the loss if they are wrong.

We are already seeing pieces of this in the open. The protocol layer is being built in public: agent-to-agent protocols, tool permissions, capability descriptors, delegated identity and increasingly explicit runtime policies. Much of it is being built by engineers who are not trying to write a theory of the firm. That is partly why it is interesting.

The economic catch

There is an optimistic version of this argument that goes: execution gets cheap, so organisations get cheap, so the firm dissolves into a market of agents.

I do not think the arithmetic works.

Delegating work does not remove its cost. It changes the cost structure:

C_agentic =
    C_execution        performing the work
  + C_specification    defining the safe envelope
  + C_governance       constraining and supervising authority
  + C_verification     producing confidence in the outcome
  + E(C_failure)       expected residual loss

A better model may reduce C_execution. That is real. But it does not automatically reduce the cost of specification, governance, verification or failure. In some cases it increases them, because a wider operating envelope has to cover more decisions and more consequential actions.

This is the basic economics behind the series.

The interesting question is not simply:

How autonomous can the system be?

It is:

How much authority can an organisation economically afford to delegate?

The answer depends on the work. Reversible, observable, cheaply checked work can carry more autonomy. Irreversible, opaque, expensive-to-verify work should carry less, even if the model is capable.

This is why the firm remains important. Someone still has to decide how much authority is safe, how much verification is enough, where risk sits, and who is accountable when delegated work causes harm.

Where the series goes next

The series has fifteen posts in five movements.

The first movement sets up the model and the economics. The second asks how much autonomy a given piece of work should receive and when autonomy stops paying. The third builds the governance architecture: what the governance plane contains, how policy becomes a runtime constraint, and what a governed action has to prove about itself.

Then the series moves into operations: where humans belong, how failure is contained, and how management sees work it no longer directly supervises.

The final movement returns to the institutional questions: where risk lives, who counts as inside the firm, and what the operating model looks like when the pieces are assembled.

The subject is the firm. AI governance and agent architecture matter, but they are inputs into the argument. The core question is what happens to the institution when execution can be delegated more widely than before.

The hand-off

Coase’s basic insight was that firms exist because coordinating through markets costs something. Search, contracting, monitoring and enforcement are not free. When internal coordination is cheaper, the firm absorbs the activity.

AI does not repeal that argument. It reprices parts of it.

A firm can now coordinate more activity through participants it does not employ, across systems it does not fully control, at a scale where no human reads every decision.

That changes where the boundary of the firm is drawn. It is no longer only the payroll. It is also the boundary of authority, evidence, risk and accountability.

The proposition for the series is:

The firm increasingly governs work it does not directly execute.

For that to hold together, one thing has to be true.

If the work is programmable, the governance has to become programmable too.

Policy that only exists in a document cannot govern work that never reads documents.

That is the next post.

References & Intellectual Lineage

• Coase, R. (1937). The Nature of the Firm.
• Williamson, O. (1985). The Economic Institutions of Capitalism.
• Simon, H. (1947). Administrative Behavior — on bounded rationality and delegated decision-making.
• Alchian, A., & Demsetz, H. (1972). Production, Information Costs, and Economic Organization.
• Jensen, M., & Meckling, W. (1976). Theory of the Firm: Managerial Behavior, Agency Costs and Ownership Structure.
• Ostrom, E. (1990). Governing the Commons — on governance that is neither market nor hierarchy.
• The Firm Under AI — the preceding series, in sixteen parts.
• Why Corporations Exist — A Coasean Foundation — the starting point.
• The Protocol Layer — where protocols first entered the argument.
• The Firm in 2026 — where the last series ended.
• The Protocol Layer: Watching the Theory Play Out — the same argument, observed in the wild.