Who this is for: Executives, chiefs of staff, and organizational designers deciding whether the drift-detection system described in the practitioner’s guide deserves a standing home, and if so, what to build, where to put it, and how to keep it from becoming the bureaucracy it exists to prevent.

The claim: Between strategy formulation and program execution sits a coordination discipline that most organizations assign to everyone and therefore to no one: keeping strategic intent intact as it crosses organizational boundaries. This document defines that discipline as a function, its charter, operating model, reporting line, authority, measurement, and failure modes.

1. Why a Function, and Why Now

The practitioner’s guide proved a point by construction: one person with a spreadsheet can define intent operationally, instrument handoffs, score drift, and route corrections to the right layer. When that works, the organization does not conclude the problem is solved. It discovers the problem was real, load-bearing, and previously invisible.

This is a recurring pattern in organizational history. Finance existed long before FinOps; revenue existed long before RevOps; both functions emerged when a coordination problem outgrew heroic individual effort. The trigger is always the same: the cost of not coordinating becomes visible, and the work of coordinating exceeds what any line role can absorb as a side job.

The empirical case is well established. Sull, Homkes, and Sull found that strategy execution fails predominantly at horizontal boundaries — managers can rely on their own bosses and teams, but not on commitments from other functions — and that this coordination gap, not vertical cascading, is where execution unravels (HBR, 2015). Organizations respond to that gap with more communication, more governance, or more planning. All three miss, because the failure is not in the message, the controls, or the plan. It is in the translation layer, and no one owns the translation layer.

When not to build it: A single-business-unit company under roughly 500 people does not need this function; it needs the practitioner’s guide and a leadership team that runs variance reviews honestly. Intent coordination earns a standing home when three conditions co-occur: multiple business units or product lines interpreting the same strategy, workflows that cross three or more organizational boundaries before reaching a customer, and a track record of initiatives that succeeded locally while the enterprise outcome stalled. Two of three, wait. Three of three, the function already exists informally — it’s just uninstrumented, unpaid, and burning out whoever is doing it.

2. The Charter

Intent coordination owns the integrity of strategic intent across organizational boundaries. Concretely, five accountabilities:

1. Intent definition standards. Every funded initiative carries an intent statement answering the five questions: what outcome, for whom, under what constraints, with what evidence, and what customer behavior changes if it succeeds. The function owns the standard and the registry, a single place where every initiative’s intent, its KPI tree, and its owner are recorded and versioned.

2. Handoff instrumentation. The function defines and maintains the measurement of organizational seams: return rates, reinterpretation rates, decision latency, and customer context loss. Not the workflows themselves, the instrumentation of their boundaries.

3. Drift detection. The function operates the Strategic Drift Index across initiatives, maintains scoring consistency, and triggers investigation when divergence emerges. It runs the variance review discipline: the seven questions, applied to ambers and reds.

4. Ownership arbitration. The function runs the quarterly Ownership Drift Test and surfaces disagreements — the cases where sales, product, services, and support each reasonably believe they own an outcome that consequently no one owns. It does not assign ownership; it forces the assignment decision to whoever holds that authority, with evidence attached.

5. Correction routing. When drift is confirmed, the function diagnoses the layer, language, incentives, handoff design, data, assumptions, or strategy itself, and routes the correction to the owner of that layer. It fixes nothing directly except its own instrumentation.

Equally important is the negative charter — what the function explicitly does not own:

1. It does not set strategy. Intent originates with executive leadership; the function translates and protects it.

2. It does not own delivery. Programs, budgets, and timelines remain with the PMO and line functions.

3. It does not own the metrics themselves. Business units own their numbers; the function owns the tree, the causal linkage from drivers to outcomes to guardrails.

4. It does not approve anything. The moment intent coordination becomes a gate, it becomes a bottleneck, and teams will route around it exactly as they route around every other gate.

3. How This Differs From the Office of Strategy Management

The closest prior art is Kaplan and Norton’s Office of Strategy Management (HBR, 2005), a unit that manages the scorecard, aligns the organization, and integrates strategy into planning cycles. Intent coordination inherits the OSM’s central insight (strategy execution needs a process owner) and departs from it in three ways:

1. Direction of attention. The OSM manages the cascade downward: communicating strategy, aligning units to it, reviewing progress against it. Intent coordination instruments the translation at each boundary, it assumes interpretation is inevitable and makes it visible, rather than assuming communication can prevent it. Its posture is closer to mission command (Bungay, 2011): specify intent and boundaries centrally, let method vary locally, and detect when local method has quietly changed the outcome.

2. Unit of analysis. The OSM’s unit is the initiative and the scorecard. Intent coordination’s unit is the handoff, the transition where context is lost, ownership blurs, and drift enters.

3. Relationship to the plan. The OSM’s failure mode is fidelity to a stale plan. Intent coordination measures fidelity to the outcome and treats plan changes as healthy when deliberate; its variance review exists precisely to distinguish deliberate adaptation from accidental mutation (a distinction Mintzberg and Waters drew between deliberate and emergent strategy in 1985, the function’s job is making emergence conscious).

If your organization already has an OSM or strategy realization office, do not build a parallel function. Extend the existing one with the handoff instrumentation, the drift index, and the ownership arbitration mandate. The name matters less than the charter.

4. Reporting Line and Shape

Three viable placements, in order of preference:

1. Chief of Staff / Office of the CEO. Best default. The function needs cross-functional reach without belonging to any function it instruments, and it needs its evidence to land where trade-off authority lives. Risk: perceived as executive surveillance. Mitigation: the transparency rule in §6.

2. COO organization. Works when the COO genuinely owns cross-functional operations rather than a subset of delivery. Risk: drift questions about the COO’s own operations get muted. Mitigation: the quarterly intent validation reports to the full executive team, not the COO alone.

3. Strategy office. Acceptable, with one hazard: the function must be free to conclude the strategy itself is the drift source (correction layer six). Housing drift detection inside the group that authored the strategy creates an obvious conflict. If placed here, the escalation path for strategy-layer findings must bypass the strategy office.

Never place it in: the PMO (it will collapse into status reporting), finance (every drift question becomes a cost question), or any single business unit (instant capture, the function will see every other unit’s drift clearly and its host’s not at all).

Shape: Small, permanently. Two to five people at enterprise scale, a lead who can sit in executive reviews as a peer, and analysts who maintain the registry, the instrumentation, and the index. Headcount growth is itself a red flag; this function scales through the standard and the cadence, not through people. If it is hiring, it is probably doing line work it should be routing.

5. The Authority Model

The function’s authority is deliberately narrow and of a specific kind: convening authority plus evidence, not command authority. It can compel three things:

1. An intent statement. No initiative enters the portfolio without one that passes the five-question standard. This is the function’s only hard gate, applied once, at inception.

2. An investigation. A red drift score obligates the accountable owner to answer the seven variance questions within a defined window. The function cannot dictate the answer; it can require that the question be answered on the record.

3. An escalation. When ownership arbitration or a strategy-layer finding stalls, the function has a guaranteed path to the executive team with the variance data attached.

Everything else, reassigning ownership, changing incentives, redesigning handoffs, revising strategy, belongs to line and executive leadership. The division is clean: the function owns the questions and the evidence; the line owns the answers and the actions. This is what keeps it a coordination function rather than a control function, and it is the design choice most likely to be eroded first. Guard it.

6. Measuring the Function Without Goodharting It

The trap: measure intent coordination on “portfolio greenness” and it will produce green portfolios, by softening scores, narrowing instrumentation, or negotiating ambers. The function that polices Goodhart’s law (Strathern, 1997; Muller, 2018) must be designed as if its own metrics will be gamed, because they will.

Measure it on the health of the process, never the color of the results:

1. Detection latency. Time from divergence beginning (established retrospectively) to divergence flagged. Shrinking latency means the instrumentation works.

2. Correction cycle time. Time from red score to a routed, owned correction decision, not to resolution, which belongs to the line.

3. Drift recurrence. How often the same drift source reappears in the same seam after correction. Recurrence means the correction hit the wrong layer.

4. Diagnostic accuracy. Sampled retrospectives: when the function attributed drift to incentives or language or handoff design, was it right?

5. Cost of the function itself. Total hours the organization spends feeding the system, registry updates, scoring, reviews. If this grows year over year, the function is becoming the bureaucracy. A healthy trajectory is flat or declining coordination cost against expanding coverage.

One asymmetry worth institutionalizing: reward found drift. A function measured on how good things look will hide problems; a function whose credibility grows each time it surfaces real divergence early will hunt for them. The executive team’s behavior in the first three red scores, curiosity versus blame, will determine which function they get.

7. Failure Modes

1. The bureaucracy it exists to prevent. Symptoms: the intent-statement gate grows sub-criteria, reviews multiply, templates thicken. Countermeasure: a standing sunset rule — every artifact and cadence the function operates is re-justified annually against the coordination-cost metric, and anything that cannot show a governed decision is retired.

2. Strategy police. The function starts treating the plan as the thing to protect and adaptation as violation, the exact inversion of its purpose (Martin’s “execution trap,” HBR 2010). Countermeasure: variance question 4 (”was the change intentional?”) stays the pivot; deliberate, intent-serving changes are logged as adaptations, never as findings.

3. Reporting factory. The function drifts into producing beautiful decks about drift instead of routing corrections. Countermeasure: correction cycle time is the headline metric, not report volume; no artifact exists that is not attached to a decision request.

4. Functional capture. One organization, usually the host, shapes what gets instrumented. Countermeasure: seam coverage is reviewed by the executive team annually; the function’s own host is instrumented first, publicly.

5. Shadow strategy office. With all the evidence in hand, the function starts recommending strategy rather than surfacing findings. Countermeasure: the negative charter, enforced by the reporting line. The day the function’s lead argues for a strategic direction rather than presenting variance, the authority model has broken.

6. Surveillance perception. Teams experience instrumentation as monitoring and begin managing signals. Countermeasure: radical transparency, every metric the function collects is visible to the teams it describes, scoring rationale is open, and the index never touches performance management. This rule is load-bearing; the first exception ends honest data permanently.

8. The First Twelve Months

1. Quarter 1 — Charter and registry. Ratify the charter (including the negative charter) at the executive level. Stand up the intent registry; backfill intent statements for the top ten initiatives by investment. Expect this to surface immediate findings: initiatives whose intent cannot be stated are the first drift candidates.

2. Quarter 2 — Instrument two seams. Pick the two cross-boundary workflows most coupled to enterprise outcomes. Deploy the four handoff metrics. Run the first Ownership Drift Test and deliver its disagreement map to the executive team without recommendations attached.

3. Quarter 3 — Cadence live. Drift index scored monthly across the registered portfolio; variance reviews running on ambers and reds; first corrections routed with layer diagnoses. Begin measuring detection latency and correction cycle time.

4. Quarter 4 — Prove restraint. Publish the function’s own scorecard, including its coordination cost. Retire at least one artifact or review that failed the sunset test. The most credible thing a new coordination function can do in its first year is visibly decline to grow.

The Standard

The practitioner’s guide ended with a question one person can ask: can we prove that execution still serves the intended outcome? A function exists when the organization decides that question deserves an owner, an instrument, and a guaranteed path to power, and accepts the discipline that the owner of the question must never become the owner of the answers.

Strategy will keep degrading one reasonable decision at a time. The only real choice is whether anyone is positioned to notice.

Sources

1. Sull, D., Homkes, R. & Sull, C., “Why Strategy Execution Unravels — and What to Do About It,” Harvard Business Review, 2015.

2. Kaplan, R. & Norton, D., “The Office of Strategy Management,” HBR, 2005.

3. Bungay, S., The Art of Action, 2011.

4. Mintzberg, H. & Waters, J., “Of Strategies, Deliberate and Emergent,” Strategic Management Journal, 1985.

5. Martin, R., “The Execution Trap,” HBR, 2010.

6. Strathern, M., “’Improving Ratings’: Audit in the British University System,” 1997; Muller, J., The Tyranny of Metrics, 2018.

Second in the series. Companion to “Strategy Does Not Fail at the Top. It Degrades on the Way Down.” and “Detecting Strategic Drift: A Practitioner’s Guide.”

There is a question I have started asking people who tell me their AI agents are governed. Not “which platform,” not “what’s your policy framework,” not “are you zero trust.” Just this:

How many of the consequential actions your agents took last week were backed by an authorization decision that was actually evaluated at the moment of the action?

Nobody has the number. Not because they are careless. Because the number is not produced anywhere, by anyone, as a matter of course. It is not on a dashboard. It is not in a vendor report. It cannot be pulled from a log without a genuinely difficult reconstruction across systems that were never designed to be joined.

Sit with that for a second. We are two years into a technology that acts on our behalf, at machine speed, with delegated authority, against systems that hold money and records and other people’s data. And the most basic empirical question about whether the guardrails are load-bearing has no answer, because the measurement does not exist.

That is not a security problem. That is a data science problem wearing a security costume.

The debate has been definitional, and definitional debates never end

Look at how the governance conversation actually runs. A vendor says their platform provides “continuous, agentic, per-action authorization.” A competitor says theirs is “identity-native with fine-grained runtime control.” A buyer nods, or doesn’t, on the basis of a slide.

Every one of those phrases is a label. Labels are argued, not tested. And an argument that cannot be tested does not converge. It just persists, at conferences, in procurement cycles, in comment threads, until everyone is exhausted and the loudest brand wins by default.

This is the failure mode. Not that we lack good frameworks, we have plenty. Not that we lack standards, the relevant ones are published and stable. The failure is that we have accepted a conversation in which claims are made and never scored.

Data science is, at bottom, one discipline enforcing one rule: if you cannot state the measurement that would show you are wrong, you are not making a claim, you are expressing a preference.

That sentence does a lot of work, so let me slow down and unpack it, because it is the load-bearing idea in everything that follows.

The difference between a claim and a preference

Two people are talking about the same system. Listen closely to what they are each actually doing.

Person one: “Our agent governance is strong.”

Person two: “Ninety percent of our agents’ state-changing actions are backed by an authorization decision evaluated within the same second as the action. I expect that to hold above eighty percent as we scale. If it drops below fifty, our governance model is session-shaped and I am wrong about it.”

Person one has told you how they feel. Person two has handed you a loaded weapon and pointed it at their own argument.

Here is the test that separates them, and you can run it on any statement in about ten seconds:

Can you describe, concretely, an observation that would force the speaker to abandon the claim?

For person two, trivially. Go count. If the number comes back at thirty percent, they said in advance they would concede, and they either concede or reveal themselves as dishonest. Either way, you learn something.

For person one, try it. What would “strong governance” have to look like, in data, to be false? Any evidence you produce can be absorbed. Show them an incident: that was an edge case, and our controls caught it downstream. Show them a broad token scope: that’s intentional, we tier by risk. Show them nothing at all: see, no incidents. Every possible world is compatible with the statement. Nothing can dislodge it.

A statement that is compatible with every possible outcome tells you nothing about the world. It tells you about the speaker. It is a preference, dressed as an assessment.

Why this matters more than it sounds like it does

The instinct is to hear this as a plea for precision, or worse, as pedantry. It is neither. It is about what an argument can do.

A claim can be settled. A preference can only be won.

When two falsifiable claims conflict, there is a procedure: identify the observation on which they differ, go make it, and one side updates. The argument has a terminus. It costs money and effort to run, but it ends, and it ends in knowledge.

When two preferences conflict, there is no procedure. There is only persuasion. And persuasion is decided by things that have nothing to do with whether either party is right: who has the bigger platform, the better slide, the more senior title, the louder voice, the larger marketing budget. The argument does not terminate. It just gets won, by whoever was going to win any argument.

This is why unfalsifiable claims are not merely useless. They are convenient. They shift the outcome from a domain where evidence decides to a domain where power decides. Nobody has to intend this for it to happen. It happens by default, every time we let a claim into a serious conversation without asking what would refute it.

Notice, too, that the falsifiability test says nothing about whether a claim is true. Person two might be wrong. Their number might come back terrible. That is fine. That is the point. A false falsifiable claim is worth more than a true unfalsifiable one, because the false claim can be corrected and the unfalsifiable one cannot be examined at all. Being wrong out loud, in a way that can be checked, is the most useful thing a professional can do.

The three moves that turn a preference into a claim

You do not need a statistics background to run this. You need three habits.

1. Name the unit. Not “governance,” but what, counted, over what. Decisions per action. Actions per grant. Percentage of actions with an attributable decision. The instant you are forced to name a unit, vague virtues resolve into specific quantities, and half of them turn out to be uncountable, which is itself the discovery.

2. State the number that hurts. Before you look. Say out loud: “if it comes back below X, I was wrong.” Pre-registering the threshold is what stops you from moving the goalposts after the data lands, and every one of us moves the goalposts when we are allowed to. I have done it in this very thread of work and been caught doing it.

3. Name the observation you cannot make, and ask why. Sometimes you name the unit, you set the threshold, and then you discover the measurement is impossible with the data that exists. Do not treat that as a dead end. It is the most interesting result available, and I will come back to it, because in this domain it is the result.

Apply this rule to AI governance and most of what we say out loud collapses immediately. That collapse is not a crisis. It is a starting point, and it is the most productive thing that could happen to this field.

What changes when you replace a label with a ratio

I have been working through one such measurement: the ratio of freshly evaluated authorization decisions to consequential agent actions. Call it whatever you like. The name does not matter and I am not selling it.

What matters is what happens the moment you take it seriously.

Your definitions become load-bearing. What counts as “consequential”? Does a cached policy decision, replayed, count as a decision? Does a re-login count as an authorization? These sound pedantic until you realize that each one is a place where a comfortable story hides. You cannot compute a number without answering them, and you cannot answer them without discovering what you actually believe.

Your data pipeline exposes your architecture. The moment you try to join an authorization decision to the specific action it licensed, you discover the join key does not exist. Authorization systems record who was allowed; action systems record what happened; nothing records that this decision permitted that action. You went looking for a statistic and you found a structural gap in how the entire industry instruments itself.

Your shortcuts become visible as shortcuts. The tempting fix is temporal correlation: attribute each action to the nearest preceding decision. It produces a clean join and a plausible number. It is also worthless, because if one grant licensed a thousand actions, that method happily reports a tidy result while erasing exactly the failure you were hunting. Any data scientist recognizes this immediately. It is the method manufacturing the finding. And the fact that it is the obvious thing to do is precisely why the measurement has to be built with care rather than convenience.

Your biases acquire a direction. When an agent acts under a delegated human identity and no acting-agent claim is emitted, that action is booked to a person and disappears from your agent population. Which means your measured governance quality is systematically better than reality. Not noisier. Better. The error flatters you. A number that flatters you in a known direction is still enormously useful, as long as you say so, because now you can report it as an upper bound and know the truth is at least as bad.

None of that is a security insight. Every line of it is standard empirical hygiene, and it is transformative here purely because nobody has applied it.

Why the specific solution does not matter, and the posture does

I want to be careful about what I am arguing.

I have a proposed mechanism. Others have better ones, and the underlying standards have existed for years. The remedies are real and they are not the point.

The point is the posture. The willingness to say: here is the number that would prove me wrong, here is how I would compute it, here is the bias in my method, and here is what I will accept as disconfirmation.

Take that posture to any contested technology claim and watch what happens. It does not settle the argument in your favor. It does something more valuable. It converts an argument that could run forever into one that terminates in evidence. The claim either survives contact with the logs or it does not.

And notice who this disadvantages. A measurement-first posture is worst for whoever currently benefits from the claim being unfalsifiable. In this case, that is any platform selling governance grain it has never been asked to demonstrate. Not through malice. Through the ordinary reason that nobody builds an instrument that can only embarrass them, and no customer has yet required one.

That last sentence is the whole essay, so let me say it plainly: the measurements that do not exist are not randomly distributed. They are missing precisely where someone benefits from the absence. Which means the discipline of asking “what would I measure, and why can’t I?” is not a technical hobby. It is a way of finding out who the current information asymmetry is serving.

Why this should interest you even if you never touch an agent

Strip out the AI and the pattern is everywhere.

We debate whether remote work hurts productivity without agreeing on what productivity means. We debate whether a policy is working without pre-registering what failure would look like. We debate the impact of a reorg, a platform migration, a strategy, and in each case the debate is definitional, unbounded, and ultimately settled by seniority or volume rather than evidence.

The data science instinct is not “use more data.” Most organizations are drowning in data and starving for measurement. The instinct is narrower and harder:

1. State the claim so precisely that it could be false.

2. Name the observation that would falsify it.

3. Build the measurement, honestly, including the parts that hurt.

4. Report the bias direction.

5. Accept the result.

Step five is where almost everyone fails, and it is the only one that makes the other four worth doing. Any framework that reinterprets every possible outcome as confirmation is not a framework. It is a horoscope with a dashboard. I have written versions of that and had them taken apart, correctly, by people who noticed I had rigged both branches to agree with me.

The ask

You do not need my ratio. You do not need my pattern. Pick the claim that matters most in your organization, the one everyone repeats and nobody has ever tested, and ask the two questions.

What number would tell me this is false?

Why does that number not exist?

The second question is usually the interesting one. It is where the architecture is, and the incentives, and the reason the argument has lasted this long.

In agent governance, the answer to the second question turns out to be: because the systems were never asked to produce it, and the standards to produce it have been sitting there, published, unused, waiting for a buyer to require them.

That is not a technology gap. It is a demand gap. And demand gaps close the moment enough people start asking for the number.

The vendor names the grain. Your logs keep the score. Go get the logs.

Instrumenting the Agent Economy By Creating Early-Warning Signals

Objective: stand up three production measurements within 90 days that tell us where the agent metering war is going before pricing sheets burn us.

0. What we are measuring and why

Three signals, each covering a different layer of the same question, at what granularity will agent activity be metered, and is the governance layer real?

1. Authorization-to-Action Ratio (AAR)

   1. technical squeeze. Is the authorization event scaling with agent activity, or collapsing to session grain?

2. Registry-Execution Delta (RED)

   1. demand reality. Are agents running that the directory doesn’t know about?

3. SKU Line-Item Drift (SLID)

   1. commercial resolution. Where are agent charges physically landing on our invoices?

Any one moving hard is signal. All three moving the same direction is the market deciding. Everything below is buildable from systems we already run; no new procurement is required for phase one.

1. Signal 1 — Authorization-to-Action Ratio (AAR)

Definition: per agent identity, per period: AAR = discrete authorization events ÷ discrete consequential actions.

• Authorization events: token issuances, token refreshes, policy-decision-point evaluations, delegation/consent grants, step-up verifications.

• Consequential actions: tool calls, API writes, file operations, message dispatches, records created/modified/deleted, anything with a side effect. Reads may be excluded in v1; log the exclusion.

1.1 Data sources

1. Numerator (authZ events): IdP sign-in and token logs (Entra sign-in logs / Okta System Log or equivalent), OAuth authorization-server logs, any PDP or policy-engine decision logs, secrets-manager access events for workload credentials.

2. Denominator (actions): cloud audit trails (CloudTrail or equivalent), application/tool-call logs from agent platforms, API gateway logs, SaaS audit logs for systems agents touch.

1.2 Build steps

1. Inventory agent principals. Enumerate every non-human principal that qualifies as an agent: service principals, workload identities, app registrations, API keys, agent-platform identities. Tag them (agent=true, plus owner/sponsor). This tag set is shared infrastructure for Signal 2; build it once.

2. Land both streams in the SIEM/lake. Both log families almost certainly flow there already; the work is normalization, not collection.

3. Define the join key. Principal ID (client ID, SPN, key ID) present on both sides. Where actions execute under a delegated human identity, capture the acting-agent claim if the platform emits one; where it doesn’t, log the attribution gap explicitly, that gap is itself a finding.

4. Compute per-agent AAR daily; report weekly distribution (median, p90, and the tail), not the mean, one chatty agent will destroy an average.

5. Capture grain metadata alongside: token TTLs, refresh cadence, scope breadth per grant. The ratio tells you what; the grain metadata tells you why it’s moving.

1.3 Thresholds and what they mean

1. AAR trending toward 1:1 — authorization is scaling with action; fine-grain metering is technically live in our stack; the event-meter thesis is confirmed in our own data.

2. AAR collapsing toward 1:N (N in the hundreds+), TTLs lengthening, scopes broadening — platforms are coarsening grain; the mid-grain position is being squeezed out in production. This is the kill-switch condition for the metering thesis.

3. Watch the trend, not the level. The instrument’s product is the quarterly direction of the median and the tail.

1.4 Owner and cadence

Security engineering / IAM team builds; platform engineering supplies action-log coverage. Weekly compute, monthly review, quarterly trend read into strategy.

2. Signal 2 — Registry-Execution Delta (RED)

Definition: RED = agents observably executing − agents registered in the directory, expressed as count and as percentage of registered.

2.1 Data sources

1. Registry side: directory export of agent identities (Entra agent/app registrations, Okta apps and service accounts, agent-platform registries), plus the CMDB if agent CIs are tracked.

2. Execution side: endpoint telemetry (EDR process inventory, fleet-management agent-process detection), runtime/workload inventory (container and function inventories), egress logs showing calls to model endpoints and agent frameworks, browser-extension inventories.

2.2 Build steps

1. Define “observably executing.” V1 heuristic: any process/workload/extension matching a maintained signature list of agent frameworks, model-endpoint calls, or MCP-style tool servers, seen active in the period. Accept imperfection; version the signature list.

2. Reconcile monthly. Join execution observations to registry entries via principal, host, and owner. Three buckets: matched (registered and running), ghost (registered, never observed running, license/hygiene finding), shadow (running, never registered, the signal).

3. Attribute shadow items to business unit and owner where possible. The distribution of shadow agents by org unit is the demand map for governance tooling.

4. Trend the delta. Widening = the ungoverned-agent problem is real and growing. Near-zero across mature environments, the governance layer is a solution ahead of its problem, equally important to know.

2.3 Pitfalls

1. Egress-based detection will over-count (humans using AI tools ≠ autonomous agents). Separate interactive from headless where the telemetry allows; label the residual uncertainty rather than tuning it away silently.

2. Don’t let the first shadow-agent report become a compliance witch-hunt, the instrument dies if teams start hiding agents from it. Frame v1 findings as inventory, not violation.

2.4 Owner and cadence

IAM owns the registry side; endpoint/security operations owns the execution side; monthly reconciliation, quarterly trend into strategy.

3. Signal 3 — SKU Line-Item Drift (SLID)

Definition: classification, per vendor per billing cycle, of where agent-related charges physically appear on invoices, tracked over time.

3.1 Data sources

Procurement invoice history, cloud billing exports, license entitlement records, contract amendments and renewal quotes. Twelve months of history minimum for the baseline.

3.2 Build steps

1. Build the vendor watch-list. Every vendor from which we consume agent capability: identity platforms, cloud providers, SaaS suites shipping embedded agents, agent-platform pure-plays.

2. Classify each agent-related charge into one of four grains:

   • G0 — bundled: agent capability inside an existing per-user seat, no separate line.

   • G1 — per-agent/per-connection: a named identity-count line item (mid-grain).

   • G2 — consumption: credits, tokens, requests, runtime hours.

   • G3 — outcome: per-resolution / per-task-completed.

3. Record grain per vendor per cycle; flag transitions. A vendor moving G0→G1 or G1→G2 is the event. So is a vendor announcing agent pricing and conspicuously staying G0 — absence of the line item after the announcement is itself data.

4. Capture renewal-quote language, not just invoices, grain shifts appear in quotes two or three quarters before they appear on bills.

5. Track our own exposure per grain: what percentage of agent-related spend sits at each grain level. That distribution is our negotiating map and our early read on which grain is winning.

3.3 Owner and cadence

Procurement/vendor management owns collection; finance ops classifies; strategy reads quarterly. This is the cheapest of the three instruments, it is a spreadsheet discipline, not an engineering project.

4. Shared infrastructure (build once)

1. The agent-principal tag set (from 1.2 step 1) is the backbone of Signals 1 and 2, one canonical inventory, one owner, versioned.

2. A single dashboard, three panels: AAR distribution and trend; RED count, buckets, and trend; SLID grain map by vendor. One page, quarterly narrative attached.

3. A decision log. Each quarter, record the one-line read per signal and any strategy action taken. The instrument’s value compounds only if direction-over-time is preserved.

5. 30 / 60 / 90

1. Day 30: agent-principal inventory tagged; SLID baseline classified from trailing 12 months of invoices; AAR data sources confirmed landing in the SIEM.

2. Day 60: first AAR computation on the top-20 chattiest agents (don’t boil the fleet); execution-side signature list v1; first RED reconciliation on one business unit.

3. Day 90: full dashboard live; first quarterly read delivered; grain-metadata capture (TTLs, scopes) attached to AAR; decision log opened.

6. Interpretation guardrails

1. One confounder to pre-register: deliberate batching. Platforms may coarsen authorization grain precisely to avoid creating an expensive event. If AAR collapses while SLID shows vendors holding G0, that is not noise, it is coordinated strategy, and it should be read as the incumbents winning the granularity war, not as the thesis being wrong for lack of a market.

2. No single-quarter conclusions. Every signal reports as a trend with at least two periods behind it.

3. The instruments measure our environment, not the market. They generalize only to the extent our vendor mix and agent adoption resemble the median enterprise; state that in every quarterly read.

Status note: signal definitions and thresholds are internal analysis (inference from market structure), not sourced benchmarks; no industry-standard values for AAR or RED exist yet which is precisely why measuring them now is an information advantage.

Start with the smallest possible fact, because the whole argument sits on top of it.

An AI agent that does not exist in your directory cannot be governed. It cannot be scoped, throttled, revoked, or audited, because there is nothing to attach a policy to. And here is the part the industry has been slow to say out loud: that same agent also cannot be billed. No identity, no line item. The condition for control and the condition for revenue turn out to be the same condition.

We have spent two years arguing about the wrong layer. The debate has been about models — whose is smartest, whose hallucinates least, whose context window is longest. Meanwhile the layer that actually decides what an agent is allowed to do has quietly become the one worth owning. Not because it is the most intelligent part of the stack. Because it is the part everything else has to pass through.

Guardrails are not a model problem

The reassuring version of AI safety is that we solve it inside the model: better training, tighter filters, cleaner evals. That version is incomplete in a way that matters commercially.

A model’s output is probabilistic. The action that output triggers, deleting a record, wiring funds, revoking a colleague’s access, is deterministic and irreversible. You cannot make a probabilistic system the final trust boundary for a deterministic act. Something has to sit between the intent and the execution and answer a harder question than “is this a good response?” The question is: who is this agent acting for, under whose delegation, through which tool path, for how long, and can I prove all of it afterward?

That is not a model question. It is an identity and authorization question. Which means guardrails, correctly understood, are an IAM problem wearing a safety costume. And once you see it that way, you notice who has been quietly building the tollbooth.

The gate has an owner

Every serious agent platform now agrees on the primitive: an agent must be a first-class identity before it can be trusted with anything.

Microsoft made this literal. Entra Agent ID issues agents a directory identity with a sponsor — a named human accountable for the agent’s behavior — and Agent 365 wraps that identity in registry, lifecycle, Purview data controls, and Defender monitoring. Okta’s pitch is the same shape from the neutral side: register the agent, assign an owner, trace its delegation chain, authorize its actions at runtime, and stream every event into the systems your auditors already read. Forrester’s framing is the cleanest — an agent is neither fully human nor fully machine, so it needs its own identity type and its own protection surface.

Strip the vendor language away and the strategic claim is singular: whoever owns the authorization layer owns the durable position. Models will keep leapfrogging each other on a quarterly cadence. The registry that knows every agent in your enterprise, who sponsors it, what it may touch, and what it did last Tuesday — that does not leapfrog. It compounds. It is a platform bet, not a feature bet, and platform bets are usually decided before most people notice a decision was being made.

The old meter is breaking

Here is where identity stops being a security story and becomes a revenue story.

For two decades, software priced the seat because the seat was a decent proxy for value. More users, more work done, more to pay for. Agents sever that link. One agent can do the work of ten people, or it can spin up forty sub-agents overnight — either way the human headcount and the work performed have divorced. Satya Nadella said the quiet part plainly: seats are becoming “just entitlement to some consumption.”

The market has noticed. Analysts now write about AI seat risk — the compression that hits a vendor’s net revenue retention when customers replace seats with agents instead of adding them. The seat is not dead; the honest read is that it is being re-based onto something that scales with machines instead of hiring. And the most natural thing to re-base it onto is the one artifact every agent must have anyway: an identity.

The tension nobody has resolved yet

This is where the interesting fight is, because the players are pulling in opposite directions and both directions are visible in today’s pricing sheets.

The incumbents are re-basing the seat. Agent 365 shipped at fifteen dollars per user per month — not per agent, not per action. One licensed human can govern an unlimited fleet of agents, and Microsoft has explicitly stated there are no consumption charges on the governance layer yet. Read that as strategy, not timidity. Microsoft is bundling the guardrail into the seat to protect the seat, and pushing the real consumption meter one layer down into execution — Copilot Studio credits, Foundry runtime, Cloud PC hours. The control plane stays flat and predictable. The volatility, and the upside, gets exiled to the invoice line finance wasn’t watching.

The insurgents are metering the event. Go down to the infrastructure and the picture inverts. AWS meters agent identity by the request — roughly a penny per thousand identity and token operations. That is the pure form of the thing: the authorization decision itself as a billable unit, priced at near-zero to stay invisible. Okta, for its part, has signaled that agent pricing will land on either a multiplier over the human license or the number of agent connections to systems — an identity-count meter waiting to be switched on. The SAMexpert crowd has even coined the metric this all points toward: ARPAA, average revenue per AI agent. When an industry invents a per-agent revenue metric, it is telling you where it intends to go.

So the strategic question is not whether identity becomes a meter. It is which cut wins: the flat per-sponsor seat the incumbents are defending, the per-agent-identity or per-connection model the challengers are circling, or the near-zero per-decision meter buried in the cloud bill. Whoever sets that precedent — and gets a buyer to accept it — writes the pricing grammar for the category.

Why the winner gets to keep winning

Whichever meter prevails, the layer underneath it is unusually sticky, and the stickiness is the real prize.

A seat churns cleanly — delete the user, the bill drops. An identity graph does not. Once your agents, their sponsors, their entitlements, and their signed delegation chains live in one directory, that graph is your operational map of the autonomous workforce. Migrating it is not a data export; it is re-establishing every trust relationship from zero, on a competitor’s schema, while your auditors watch. Add the compliance gravity — SOC 2, ISO 27001, PCI-DSS, and the regulators who are done treating non-human identities as out of scope — and the identity layer becomes the system of record you cannot rip out without becoming, briefly, ungoverned. The switching cost is not a contract term. It is a governance risk. That is the most durable kind of lock-in there is.

The way I’d know I’m wrong

I try to write down the falsifier before I fall in love with the thesis, so here it is.

If, eighteen to twenty-four months from now, the dominant way to pay for agent identity is still a flat per-seat or per-sponsor line — if nobody successfully charges for the authorization event or the agent itself — then this was never a new meter. It was the old seat wearing an identity badge, and the “agent economy” repriced nothing. Right now the evidence tilts that way: the largest vendor is deliberately holding the guardrail layer flat. The insurgents are circling, but circling is not landing.

Which leaves the question I can’t yet answer, and neither can the market: when the dust settles, does the rent get collected at the identity gate everything must pass through — or one layer down, at the execution meter where the tokens actually burn?

The company that answers that first doesn’t just win a pricing debate. It decides where the value in the entire agent stack accumulates. And it will have decided it, as these things always are, before most of the room realized a decision was on the table.

I don’t like agents.

There. I said it.

Maybe I dislike the word more than the idea.

“Agent” has become one of those technology terms that expands until it means almost nothing.

A chatbot calls an API.

Agent.

A workflow executes three steps.

Agent.

A script retrieves a document, summarizes it, and sends an email.

Agent.

A software company adds a prompt box to its product and suddenly announces that it has hired a digital workforce.

Somewhere along the way, software stopped being software and started asking for a job title.

I find most of this exhausting.

I am not particularly interested in a future where every application introduces me to a cheerful synthetic employee with a name, a personality, and a request for permanent access to my calendar.

But lately, I have started wondering whether my objection is aimed at the wrong layer.

Because while the industry is arguing about whether people want agents, Microsoft appears to be preparing Windows for a world in which the question may already have been answered.

Not by consumers.

By architecture.

The hypothesis: Windows is becoming an operating system for agents.

Not Windows with an agent added to it.

Not Copilot sitting in a sidebar.

Not another AI button bolted onto the taskbar.

Something more fundamental.

A machine designed around the assumption that humans will increasingly express intent—

and software actors will increasingly carry it out.

That is a very different future.

And, strangely enough, a ridiculous Windows storage bug is what sent me down this rabbit hole.

The 500GB Permission Slip

Emma Roth at The Verge recently reported on a Windows 11 issue involving a file with the exceptionally glamorous name:

CapabilityAccessManager.db-wal

The file is associated with Windows capability and permission management.

Under the reported bug conditions, it could grow dramatically. Reports described systems losing tens of gigabytes of storage, with one widely cited case approaching 500GB.

Microsoft issued a fix for the excessive disk usage.

At first glance, this is just a funny operating-system bug.

A permissions database eating half a terabyte of storage practically writes its own joke.

But the name of the component stuck with me.

Capability Access Manager.

Because the further computing moves toward software acting on our behalf, the more central that class of infrastructure becomes.

To be clear: the bug itself does not prove anything about Microsoft’s agent strategy.

Windows has mediated access to cameras, microphones, files, location data, and other protected resources for years.

This database was not secretly created for an incoming army of AI workers.

But the incident points toward a much larger architectural problem.

In a world of agentic software, the machine must answer questions that are considerably harder than:

Can this user access this resource?

It must begin answering questions like:

Who is requesting this action?

Is the requester a human, application, service, or agent?

On whose behalf is it operating?

What task was it authorized to perform?

Which tools may it use?

What data may it inspect?

What actions may it take?

How long does that authority last?

Can its work be reconstructed afterward?

This is not primarily a model problem.

It is an operating-system problem.

And I increasingly suspect Windows is being positioned to solve it.

We Still Think in Applications

Most of us still carry a mental model of computing inherited from the graphical desktop.

You sit down at a machine.

You open an application.

You perform an action.

The application requests resources from the operating system.

The operating system mediates access.

The user remains the primary actor.

The application remains the primary unit of work.

This model has been remarkably durable.

The windows changed.

The icons improved.

The applications moved from local disks to browsers and clouds.

But the relationship remained recognizable.

Human chooses application.

Human operates application.

Application requests resources.

Operating system arbitrates.

Agentic computing threatens to rearrange that sequence.

The emerging interaction model looks more like this:

Human Intent → Agent → Tools → Data → Applications → Operating-System Policy

That may look like a minor abstraction.

I don’t think it is.

The user is no longer necessarily deciding which application performs each step.

The user may instead describe an outcome.

Find the files.

Compare them.

Extract the changes.

Update the report.

Schedule the meeting.

Notify the participants.

File the output.

The software actor determines how to accomplish the task.

It discovers available tools.

It retrieves context.

It requests access.

It invokes applications.

It writes files.

It takes actions.

Then it returns with a result.

At that point, the operating system is no longer merely managing applications.

It is mediating something much more consequential:

Delegated intention.

The human remains the source of authority.

The human is no longer necessarily the immediate actor performing each operation.

The machine needs a way to represent the gap between those two things.

That gap may be where the next operating-system battle is forming.

The Most Important AI Feature May Be Identity

Microsoft has publicly described several pieces of Windows infrastructure that are much more interesting to me than another assistant window.

Native Model Context Protocol support.

An on-device registry for agent-accessible connectors.

Connections into resources such as File Explorer and System Settings.

Separate identities for agents.

Agent Workspace environments intended to provide software actors with a contained and auditable place to operate.

Strip away the AI language and read that list again.

Identity.

Workspace.

Permissions.

Tools.

Discovery.

Containment.

Policy.

Audit.

That does not sound like a chatbot.

It sounds like the early shape of a new execution principal.

Traditional systems already contain multiple classes of actors:

Users.

Applications.

Processes.

Services.

Containers.

Virtual machines.

Service accounts.

The agent may become another one.

Not exactly a user.

Not exactly an application.

Not exactly a service.

A software actor operating under delegated authority.

That creates an authorization problem that enterprise security has not fully solved.

Today, we might ask:

Can Stephen access this file?

The agentic version becomes something closer to:

Can this specific agent, acting for Stephen, during this specific task, using this approved connector, access this file, extract this field, pass that field to another permitted tool, and retain the result for this amount of time?

The difference is context.

Identity answers:

Who?

Agentic authorization also needs to answer:

Why?

For what purpose?

Through which path?

Within what scope?

Under what conditions?

A login cannot express all of that.

An access-control list cannot express all of that.

And many policy systems were never designed for this degree of temporary, contextual delegation.

This is where the agent conversation becomes much more serious than the demos suggest.

Intelligence Is Not the Hardest Problem

The central contradiction of agentic computing is simple.

We are connecting probabilistic systems to deterministic consequences.

The model may interpret.

The model may infer.

The model may choose.

But the tools it controls are real.

The file is deleted or it isn’t.

The message is sent or it isn’t.

The security setting changes or it doesn’t.

The credential is exposed or it isn’t.

The transaction happens or it doesn’t.

The model operates in probability.

The world it acts upon does not.

That means the model itself cannot be the final trust boundary.

A language model can recommend an action.

It can propose a plan.

It can select a tool.

But the system around it must decide what is actually permitted to become real.

This is why I keep returning to a principle that I think will define serious enterprise AI systems:

The future of enterprise AI is not making the model deterministic. It is making everything around it intentional.

Identity must be intentional.

Policy must be intentional.

Capability exposure must be intentional.

Consent must be intentional.

Data boundaries must be intentional.

Containment must be intentional.

Verification must be intentional.

Audit must be intentional.

Recovery must be intentional.

The model can remain nondeterministic.

The architecture around it cannot afford to be accidental.

Everyone is talking about intelligence.

The harder problem may be authority.

Windows Does Not Need to Own Every Agent

There is an easy interpretation of Microsoft’s strategy:

Microsoft wants Copilot everywhere.

That may be true at the product level.

But I think there is a more interesting possibility beneath it.

Windows does not need to own every agent.

It does not need every model to be a Microsoft model.

It does not need every agent to carry the Copilot brand.

It only needs Windows to become the environment where agents are:

Discovered.

Identified.

Authorized.

Contained.

Observed.

Audited.

And, when necessary—

stopped.

That is a far more powerful position.

The model layer is already intensely competitive.

Models improve.

Open models advance.

Cloud providers compete.

Inference moves between cloud and edge.

Application developers change providers.

The operating system owns something far more difficult to displace:

The files.

The devices.

The applications.

The credentials.

The hardware.

The user session.

The security controls.

The enterprise policy.

The recovery environment.

The relationship between digital intention and physical machine state.

That is an extraordinary position from which to govern software action.

The real AI platform war may therefore look very different from the one we currently imagine.

We keep asking:

Who has the smartest model?

The more important question may be:

Who controls the boundary between model output and real-world execution?

We May Be Watching the Application Model Break Apart

There is another possibility worth considering.

Agents may not survive as a visible product category.

The word itself may fade.

The cartoon assistants may disappear.

The glowing icons may become embarrassing artifacts of this particular moment in technology.

But the architecture could remain.

We may simply become accustomed to asking machines to accomplish outcomes.

The machinery underneath will interpret the request, construct a plan, select tools, request authority, execute permitted operations, and return the result.

At that point, saying:

I don’t like agents.

may sound a little like saying:

I don’t like processes.

Or:

I don’t like APIs.

Not because those technologies are inherently good.

But because they became foundational patterns rather than products.

That is the distinction I have been wrestling with.

I dislike many things currently being sold as agents.

I remain skeptical of exaggerated autonomy claims.

I remain skeptical of systems that accumulate broad permissions.

I remain deeply skeptical of probabilistic systems acting without appropriate containment, validation, and recovery.

But those are architectural objections.

They are not necessarily objections to delegated software action itself.

And the architecture Microsoft is describing suggests that distinction matters.

The Permission Layer Becomes the Product

Return for a moment to that absurdly large Windows permissions file.

Again, the bug proves nothing about AI agents.

But symbolically, it is almost too perfect.

A database governing capability access quietly expands until it consumes the machine.

That sounds like an accident.

It may also be an accidental metaphor for the next era of computing.

As software actors gain access to more tools, more data, and more actions, permissioning is no longer a side feature.

It becomes core infrastructure.

So does identity.

So does context.

So does provenance.

So does audit.

So does recovery.

The more capable the agent becomes, the more valuable the surrounding control plane becomes.

This is why I think much of the market is looking in the wrong direction.

The AI conversation remains obsessed with the model.

How smart is it?

How fast is it?

How many tokens can it process?

Which benchmark did it beat?

Those are legitimate questions.

But once systems begin acting, intelligence alone is not enough.

An intelligent system without deliberate boundaries is not an enterprise architecture. It is a risk event waiting for a timestamp.

I Still Don’t Like Agents

Mostly.

I dislike the marketing.

I dislike the anthropomorphism.

I dislike the idea that autonomy itself is automatically valuable.

I dislike systems asking for broad permissions and vague trust.

I dislike the assumption that every human workflow improves when replaced by a synthetic subordinate.

But I am starting to think those objections may become increasingly irrelevant to the deeper platform shift.

The useful question is no longer:

Do I like agents?

The useful question is:

What happens when the operating system assumes software actors will routinely act on our behalf?

Because that appears to be the more consequential transition.

Not another chatbot.

Not another sidebar.

Not another animated icon waiting to summarize a meeting.

A different operating model for the machine.

One in which humans express intent.

Software actors receive constrained authority.

Tools become discoverable.

Identity separates human action from delegated action.

Policy mediates execution.

The operating system becomes the trust broker.

And every consequential action occurs inside a boundary someone had better have designed deliberately.

I still don’t like agents.

But I am beginning to suspect that Windows does.

And that may matter far more than my opinion.

The Third Flock: The Great AI Backpedal

First came Token Maxxing: the belief that more AI usage meant more value.

Then came the uncomfortable discovery that replacing people with AI can sometimes cost more than the people.

Now comes the next phase: CEOs discovering that “society” has an opinion.

Not because society suddenly appeared. Workers, customers, communities, regulators, and the public were there the whole time. But during the first act of the AI boom, the pitch was cleaner: AI would automate work, reduce labor, increase productivity, and unlock a new economic era.

Then people started asking the obvious question:

Are we being asked to fund our own replacement?

That is where the messaging starts to shift. Suddenly the conversation becomes less about replacement and more about empowerment. Less about disruption and more about responsibility. Less about “AI will eat the world” and more about “AI needs social permission.”

Good.

Then prove it.

Because this is where leadership gets interesting. We often talk about executives as if they exist above the crowd, immune to fashion, fear, status, and public pressure. But the AI cycle is showing something much more human. Leadership is not omnipotent. It is subject to the same groupthink dynamics as everyone else.

The flock simply changes clothes.

One flock burns tokens because usage looks like progress. Another flock cuts headcount because savings look like strategy. Another flock pivots to social responsibility because public trust has become the new constraint.

That does not make AI fake. AI is real. AI is useful. AI will matter.

But it does expose the difference between strategy and synchronized migration.

The companies that win will not be the ones that chase every AI narrative as it rolls through the market. They will be the ones disciplined enough to ask harder questions:

What work actually improved?
What customer outcome changed?
What cost moved where?
What human judgment became more valuable, not less?
What are we measuring besides adoption theater?

Because you cannot sell replacement as revolution forever.

At some point, the people being replaced ask who the revolution is for. The customers ask why the product got worse. The board asks why the AI bill looks like payroll with a worse interface. And society asks why a handful of companies get to call enclosure “innovation.”

The sheep come in many flocks.

Some chase hype. Some chase savings. Some chase public approval.

The wool changes.

The behavior rarely does.

This week’s discussion is about what happens when the shepherds discover the sheep were doing work after all.

Joe Procopio’s latest argument is simple: in some cases, companies that laid people off to embrace AI are discovering that AI infrastructure, compute, management overhead, and operational complexity can become more expensive than the labor they replaced. (Inc.com)

Which brings us back to the flock, and what is flocking unbelievable.

The first flock believed:

“More people = more value.”

The second flock believed:

“Fewer people + more AI = more value.”

Neither flock bothered to verify the equation.

They simply changed religions.

The funny thing about leadership is that we often describe executives as if they exist outside human psychology. As if a title grants immunity from fashion, status signaling, or herd behavior.

Yet every decade produces a new migration:

• Offshoring

• Outsourcing

• Agile transformations

• Open office plans

• Digital transformation

• Mass layoffs

• AI-first organizations

Some work.

Some don’t.

But the pattern is remarkably consistent.

A few prominent firms move first.

Analysts celebrate.

Consultants publish decks.

Boards become nervous.

Competitors copy.

Executives congratulate themselves on being visionary while marching in the same direction as everyone else.

That’s not leadership.

That’s synchronized swimming.

What’s particularly interesting is that economists and researchers are increasingly warning about an AI version of the same phenomenon: firms automating because they fear being perceived as behind, not because the economics actually work. (Business Insider)

The result is what I call The Cult of the Spreadsheet.

The high priests no longer ask:

“Did we create value?”

They ask:

“Did the graph move?”, preferably up and to the right. Pick your X:Y.

The irony is that AI may ultimately be transformative. I believe, no I know, it will be.

But if AI succeeds, it won’t be because organizations replaced judgment with automation. It will be because they amplified judgment with automation.

The organizations that win won’t be the ones that fired the most people.

They’ll be the ones that figured out which humans were irreplaceable before they accidentally automated the map and deleted the cartographers.

The sheep come in many flocks.

The wool changes.

The PowerPoint template changes.

The behavior rarely does.

#AI #Leadership #Management #TokenMaxxing #ArtificialIntelligence #BusinessStrategy #FutureOfWork #DigitalTransformation #OrganizationalBehavior #Groupthink #Innovation

Sources: Joe Procopio, Inc. (2026); recent commentary on AI-driven layoffs, compute costs, and organizational incentives. (Inc.com)

1. Invent a metric.

2. Confuse the metric with the goal.

3. Reward the metric.

4. Watch people optimize the metric.

5. Act surprised when the goal disappears.

In this case the metric was “tokens burned.”

Companies encouraged employees to use more AI. Some organizations reportedly created leaderboards. Employees responded rationally: if token consumption is rewarded, consume tokens. The result was engineers assigning pointless work to agents, excessive use of premium models, and organizations discovering that AI bills can become very real very quickly.

A funny story emerges from it:

The Many Flocks

The sheep were tired of being called sheep.

For years they had watched from the valley as executives stood on the mountain ridges, pointing at them.

“Look at those fools,” said the shepherds. “They follow trends.”

The sheep nodded.

The shepherds nodded.

Everyone felt very wise and in their place.

Then one spring, a consultant arrived carrying a shiny new metric called Wool Velocity.

The consultant explained:

“The future belongs to the flock that sheds the most wool.”

Nobody fully understood why.

But the chart was impressive, and investors and the market agreed, so the shepherds held meetings.

They appointed new roles and accountability.

• Vice Presidents of Wool.

• Directors of Wool Acceleration.

• Chief Wool Transformation Officers.

Soon every sheep received a quarterly wool target.

The sheep complied.

Some shaved themselves twice a day.

Others hired goats to help.

A few entrepreneurial sheep began shaving neighboring sheep.

One legendary sheep shaved the entire hillside and became Employee of the Month.

The shepherds celebrated.

Graphs went up.

• Dashboards glowed.

• Awards were issued.

Then winter arrived.

And everyone froze.

The moral, of course, is not that sheep are foolish.

The moral is that shepherds are sheep with better parking.

Leadership often imagines itself as standing outside the crowd, observing the psychology of others.

Yet organizations repeatedly demonstrate that executives are vulnerable to the same forces seen in cults, social movements, and mass hysteria:

• Social proof

• Status competition

• Fear of exclusion

• Group reinforcement

• Metric worship

• Authority cascades

The difference is largely aesthetic.

A cult has robes. A corporation has Patagonia vests.

A cult has sacred texts. A corporation has PowerPoint decks.

A cult measures devotion. A corporation measures KPIs.

A cult asks, “How faithful are you?” A corporation asks, “How many tokens did you burn this quarter?”

The mechanism is remarkably similar.

The lesson from the token-burning era is not that employees behaved irrationally.

They behaved exactly as incentive systems predicted.

The more interesting question is why so many leaders collectively believed that token consumption was a proxy for value creation in the first place. Reports from multiple companies now suggest growing concern that AI usage metrics and actual business outcomes are not strongly correlated.

Perhaps the most dangerous flock is the one convinced it isn’t part of a flock at all.

The sheep come in many varieties.

• Consumer sheep.

• Political sheep.

• Technology sheep.

• Executive sheep.

• AI sheep.

The wool changes. The behavior rarely does.

Reclaiming a word the industrial age took from you.

Before there were employees, there were sovereigns.

The word predates the factory, the office, and the org chart by roughly a thousand years. Sovereign, from the Latin superanus, meaning “above,” described someone who held authority over their own ground. A sovereign owned the means of their own production. They held title to the land they worked, the tools they used, the apprentices they trained, and the reputation they built. They paid tribute to higher sovereigns sometimes, traded with peer sovereigns often, and took commissions from clients regularly. But the locus of authority sat with them, on the soil they stood on, in the workshop they had built with their own hands.

This was not a privilege of the nobility. The word reached far down the social ladder. The medieval miller was a sovereign of the mill. The blacksmith was a sovereign of the forge. The midwife was a sovereign of her practice. The scribe was a sovereign of the scriptorium. The relationship between commoner sovereigns and their work was structurally similar to the relationship between kings and their kingdoms, smaller in scale and identical in form. They held title, they held tools, they held knowledge, they held succession. Their children inherited the workshop. Their apprentices inherited the methods. Their names were on the door because the door was theirs.

Then came the factory.

The industrial transaction

The industrial revolution did something specific and historically novel. It separated the worker from the means of production. The blacksmith who had owned his forge became the factory hand who rented his labor to the man who owned the new, larger forge. The seamstress who had owned her needle and her clientele became the operator of a sewing machine she did not own, producing garments for customers she would never meet. The scribe became the clerk. The midwife became the nurse. The miller became the millhand.

The economic logic was efficiency. Industrial-scale capital, including steam engines, rail networks, telegraph lines, and electrified factories, was simply too expensive for any individual craftsman to own. Concentration of capital meant concentration of authority. The worker traded sovereignty for access to machinery they could not afford. The factory owner provided the machinery in exchange for a controlling share of the worker’s economic output.

The word for the new arrangement had to be invented. Employee enters English in roughly its current sense in the 1820s, just as the factory system reaches maturity. It is the linguistic shadow of employer, defining the worker entirely in terms of the entity that hires them. Before the 19th century, the standard ways to describe working people, including craftsman, journeyman, apprentice, master, practitioner, smith, wright, referenced their craft. After the 19th century, the standard way to describe working people referenced their employer. That shift is not cosmetic. It is the linguistic record of who now holds authority.

Two hundred years later, the vocabulary remains. The conditions that produced it do not.

What the industrial bargain gave you, and what it took

The industrial transaction was not a swindle. The worker who entered the factory got real things in exchange for what they gave up: predictable wages, access to capital they could not personally afford, the protection of belonging to a larger entity that could absorb risk the individual could not. Over the next century, that bargain was extended and improved through hard fights, including labor unions, the eight-hour day, weekends, paid leave, pensions, healthcare benefits, and anti-discrimination law. By the mid-20th century, the employee identity offered a deal that, on net, looked reasonable to most people most of the time. Stability for sovereignty. Security for autonomy. A career for a craft.

But the deal was always conditional on a single underlying fact: the firm owned capital you could not own yourself. That was the premise that made the trade rational. Surrender authority over your work, in exchange for access to machinery, infrastructure, and scale that no individual could replicate.

Hold that premise in your mind, and then look at 2026.

In the last twenty-four months, the premise has quietly broken.

An individual professional can now credibly own the means of their own cognitive production. A lawyer can own the equivalent of a research department. A doctor can own the equivalent of a diagnostic stack. An analyst can own the equivalent of a modeling infrastructure. A writer can own the equivalent of a publishing house. The hardware sits on a desk. The models are open-weights. The corpus is the professional’s own work product. The fine-tuning stack is freely available. The scale that used to require a firm now fits in a backpack.

This is the first time since the early industrial revolution that the capital-concentration logic has reversed. The factory no longer owns something you cannot own yourself. The firm’s monopoly on the means of professional production is ending, not because of regulation, not because of revolution, but because the cost curve crossed.

When the premise that justified the bargain disappears, the bargain disappears with it. The vocabulary is the last thing to go.

The brain-scrapers know

The companies running brain-scraping operations, including Meta with MCI, Mercor with its expert-recording marketplace, and the Chinese platforms cloning workflows into agent manuals, understand exactly what window they are operating in. They are racing to extract sovereign-grade cognition from professionals before those professionals realize they could simply be sovereigns again. Every keystroke captured, every reasoning trace recorded, every workflow documented is an attempt to convert your cognition into the firm’s capital before the cost curve makes that conversion unnecessary for you.

This is not paranoia. It is a coherent corporate strategy with a closing window. If individual professionals reach sovereignty before the scrapers reach saturation, the scrapers lose. If the scrapers reach saturation first, professionals enter the next era as captured cognition rather than independent operators. The race is real. The professionals are mostly not aware they are in it.

The vocabulary is the camouflage. As long as you call yourself an employee, you accept the frame in which someone else is the principal and you are the input. The brain-scraping makes perfect sense inside that frame. It makes no sense outside it. The sovereign frame is not a metaphor. It is the accurate description of what you can now be, and the inaccurate description of what you currently call yourself.

What sovereignty meant then, what it means now

Map the medieval sovereign craftsman to the 2026 sovereign professional, layer by layer:

1. Land then, hardware now. The miller owned the mill site. The smith owned the forge. The sovereign professional owns the hardware their model runs on, whether laptop, server, or colocated box. The land was the precondition for production then. The hardware is the precondition for cognition now.

2. Tools then, models now. The wright owned the lathe. The scribe owned the quill and the inkpot. The sovereign professional owns the model, open-weights, fine-tuned, configured. The model is the active instrument; the hardware is the ground it sits on.

3. Materials then, corpus now. The weaver owned the wool, the dyes, the raw stock. The sovereign professional owns the corpus, including notes, decisions, drafts, transcripts, and the lifetime accumulation of work product that the model is fine-tuned against. This is the input the cognition operates on. It is also the asset that compounds.

4. Apprentices then, agents now. The master had apprentices, extensions of the master’s practice, trained in the master’s methods, executing under the master’s authority, eventually becoming sovereigns of their own shops. The sovereign professional has agents, extensions of the professional’s practice, trained on the professional’s corpus, executing under the professional’s authority. The form is identical. The technology is different. The continuity of structure across a thousand years is striking once you see it.

5. Guild then, federation now. The medieval sovereign was not isolated. They belonged to a guild, a federation of peer sovereigns who shared standards, defended members against bad-faith counterparties, resolved disputes, certified competence, and provided collective bargaining power against the powerful. The sovereign professional needs the same thing. Federations of peer operators, with shared norms, shared discovery infrastructure, shared defense against the platforms. The guild is not an artifact of medieval economics. It is the natural organizational form of sovereign professionals in any era.

6. Charter then, treaty now. The medieval sovereign held a charter, a written instrument that established their rights, jurisdictions, and relationships with other sovereigns. The sovereign professional writes treaties, contracts with clients that specify what the client gets (the deliverable), what the operator keeps (the brain, corpus, fine-tunes), and how disputes resolve. The charter and the treaty serve the same function: they make sovereignty legible and enforceable.

The mapping is not poetic. It is structural. The thing that ended in roughly 1820 can begin again in roughly 2026 because the conditions that made it possible, namely distributed ownership of the means of production, have, for the first time in two hundred years, been restored at the level of cognition.

The objections, old and new

Sovereignty arguments draw the same pushbacks they always have. Each one was answered before, and is being answered again.

1. “Most people can’t own the means of production.” This was true in 1850, when steam engines cost a fortune. It became less true through the 20th century as small-business capital fell. It is false in 2026 for cognitive work. The hardware costs less than a used car. The software is open-source. The barrier is no longer capital. It is identity.

2. “You’re just describing freelancing.” Freelancing is a 20th-century construct, selling labor by the hour to multiple buyers under terms set by platforms or industry norms. Sovereignty is older and structurally different. The medieval sovereign craftsman was not a freelancer. They held title, controlled methods, owned succession, and operated inside a guild. The sovereign professional in 2026 has the same five layers, modernized.

3. “What about benefits, healthcare, retirement?” These are real. They are also the artifacts of the industrial bargain, specifically the part where firms absorbed risks individuals could not. In a sovereign frame, these become priced inputs that the operator carries themselves or pools through federations, which is exactly how guilds handled equivalent risks in their era. The current US healthcare system is a real obstacle to sovereignty. It is not an argument for staying inside a frame that’s converting your cognition into someone else’s inventory.

4. “This sounds like nostalgia for the medieval craftsman.” It isn’t nostalgia. It’s recognition that the industrial era was a parenthesis in a much longer history of distributed sovereign professional work. For roughly ten thousand years before factories, professionals owned their work. For roughly two hundred years inside the parenthesis, they didn’t. The parenthesis is closing. What comes after is not a return to the past. It is a continuation of what was always normal, equipped with the tools of the era it lands in.

Where this goes: a near-future worth describing

Project the trajectory ten years out and the picture sharpens.

By 2035, in a world where the sovereignty trajectory wins:

1. Professional licensing bodies, including bar associations, medical boards, and engineering societies, function more like medieval guilds than industrial-era credentialing offices. They certify sovereign operators, defend members in jurisdictional disputes, set standards for what counts as a legitimate personal brain, and run discovery infrastructure that lets clients find sovereign professionals without going through scraper-platforms.

2. Most senior professional work is done by sovereign operators in federations of three to thirty. The large firm survives but as a coordination layer, assembling teams of sovereigns for specific engagements, taking a coordination fee, owning none of the underlying cognition. The firm becomes the general contractor; the sovereigns are the master craftsmen on the job.

3. Employment as a category survives mainly for early-career operators (the modern apprenticeship) and for genuinely industrial-scale work where capital concentration still makes sense, such as running a hospital, operating a fab, or flying an airliner. The professional class above the apprenticeship tier is mostly sovereign.

4. Personal models and personal corpora are inheritable. A sovereign passes their kit to a chosen successor, a child, an apprentice, or a junior partner, the way a master craftsman once passed the workshop. The succession is not metaphorical. It is a contractual transfer of weights, corpus, and federation membership.

5. “AI” is no longer the topic of breathless news coverage, because it has dispersed into the kit of every sovereign professional rather than concentrating in a small number of hyperscalers. The hyperscalers still exist. They are utilities, not landlords.

Project the trajectory in the other direction, where the scrapers win, and the picture also sharpens.

By 2035, in a world where brain-scraping wins:

1. The professional class as a coherent category has effectively dissolved. Cognition is rented from a small number of platforms that own the models that own the captured judgment of the previous generation of professionals.

2. Employment exists, but as gig-tier piecework. The credential is gone. The career ladder is gone. The pension is gone. What remains is a sequence of short engagements training the next model that will replace you.

3. A small minority of holdouts, sovereigns by historical accident, operate at the high end, charging extreme premiums to clients who specifically need cognition that is not platform-derived. They are exotic, expensive, and viewed with suspicion by mainstream business.

4. Bias and training failures accumulate in the captured-cognition stack until the platforms produce systemic errors that were always present in the corpora but invisible inside the homogenized output. The corrections require sovereign professionals who no longer exist at scale. The damage is real.

These two futures are both coherent. Both are reachable from where you stand right now. The vocabulary you adopt is one of the variables that determines which one arrives.

The deeper move

The provocation is not “become a sovereign.” The provocation is recognize that you already could be, and the only thing stopping you is two centuries of industrial-era language describing a bargain whose underlying premise just expired.

You inherited a vocabulary built for your great-great-grandparents’ economy. Your great-great-grandparents accepted that vocabulary because the bargain it described made sense in their lifetimes. You are running their software on your hardware. The hardware has changed. The software has not.

The medieval sovereign did not have a special temperament. They were not unusually brave or unusually entrepreneurial. They were ordinary professionals operating under ordinary conditions of distributed production. Sovereignty was the default, not the exception. The factory made sovereignty the exception. The personal brain makes it the default again.

Your great-great-grandfather the blacksmith would not have understood the question “are you an employee or a sovereign?” To him, the question would have parsed as “do you have a forge or do you not?” If you had a forge, you were a smith. If you did not, you were an apprentice working toward having one. There was no third category.

The third category was invented in 1820. It served a purpose for two centuries. The purpose has now expired.

Act accordingly

You can keep working. You can keep collecting a paycheck. You can keep the lanyard. None of that is the point. The point is the identity from which you do those things.

Build your forge. Curate your materials. Train your apprentices. Join your guild. Write your charter. Pass your kit to your chosen successor.

Do these things and the word employee will become, for you, what it has always actually been: the name of a temporary arrangement inside a longer history, useful when its premises hold, discardable when they don’t.

The premises don’t hold anymore.

You are not an employee. You never really were. You are a sovereign, recovering a word, and a way of working, that was yours before the factory took it.

Act accordingly.

This is the third in a series. The first argued that self-hosted personal brains are the only durable answer to AI brain-scraping. The second argued that polymaths are the special forces of the AI-era firm and that their personal brain is their kit. This one places the whole argument in its proper historical scale: the industrial-era employee identity as a two-century parenthesis inside ten thousand years of sovereign professional work, now closing. The deeper case for the principle traces back to John Wolpert’s How to Own Your Brain at Work. Start there if you haven’t.

The follow-on argument: if self-hosted brains are how individual experts refuse to be captured, polymaths are how companies refuse to be out-thought. Both moves come from the same playbook, the one small forces have used to beat large ones for two thousand years. And both depend on the same piece of equipment: the operator’s own kit, carried on their own back, owned outright.

Why the conventional army loses

Mao codified it. T.E. Lawrence demonstrated it. Sun Tzu prefigured it. The pattern: a numerically and materially inferior force defeats a superior one by refusing to fight on the superior force’s terms. Mobility over mass. Local knowledge over doctrine. Initiative over hierarchy. Pick your terrain. Strike where the enemy isn’t. Disappear before they can mass.

Map to business: the conventional army is the Fortune 500 plus its AI agents. Massive headcount, massive compute, massive process documentation, massive replicability. The doctrine is scale. The bet is that any task done well enough at sufficient scale becomes a moat.

That bet is now wrong at the margins that matter. AI agents make scale cheap. When everyone has scale, scale stops being a moat. The remaining advantage is the work AI agents can’t do, work that requires synthesis across domains, judgment under genuine uncertainty, and the reframing of problems before they can be solved.

That work belongs to polymaths. And it depends on equipment they own.

The kit principle

Look at how actual special forces are equipped. Conventional infantries get standard-issue weapons, armor, and comms, interchangeable, replaceable, optimized for a force of thousands. Special forces operators get to select, modify, and personally maintain their own kit. Rifles tuned to the operator. Comms configured to the mission. Med pack curated to the operator’s training. Boots broken in to the operator’s feet. Knife of their choosing.

The reason isn’t vanity. It’s three things:

1. The operator is going to be alone. No quartermaster downrange. If the kit fails, the operator fixes it or dies. Equipment they didn’t choose and can’t service is a liability.

2. The mission is non-standard. Conventional kit is optimized for the average mission. Special forces missions aren’t average. Every load-out is a bet on terrain, duration, and threat profile that won’t be known to anyone but the team.

3. The operator’s judgment is the actual weapon. Everything else is just a tool that translates that judgment into effect. A tool the operator doesn’t fully understand, can’t modify, and doesn’t trust degrades the weapon that matters.

The polymath’s kit is their personal brain, their self-hosted model, their private corpus, their tool stack, the agents they’ve trained and tuned themselves. Same three reasons apply.

Why generic AI is conventional kit

Hyperscaler AI is standard-issue. It’s optimized for the average user across the average task. It’s serviced by someone else, on hardware the user doesn’t see, with a corpus the user didn’t curate, under terms the user didn’t write. When it works, it works for everyone. When it fails on the operator’s specific terrain, the operator has no ability to repair it, modify it, or even know why it failed.

For conventional work, the corporate equivalent of garrison duty, this is fine. For the work polymaths actually do, the joint problems, the cross-domain reframes, the high-uncertainty calls, generic kit is the wrong kit. It’s tuned to nobody’s terrain and trained on nobody’s specific judgment. It will be confidently wrong in exactly the places where the operator’s edge lives.

The polymath who runs on someone else’s brain is a special forces operator carrying conventional gear. They will be outperformed by a conventional soldier with the same gear, and they will be outperformed by a polymath with their own kit. Worst of both worlds.

What “personal brain as kit” actually means

Five operating principles of effective irregular forces, each mapped to a piece of the polymath’s kit:

1. Cross-trained, self-sufficient units. The operator carries everything they need to function autonomously. Kit equivalent: a local model that runs offline, on hardware the polymath owns, capable of reasoning, drafting, and tool use without phoning home. No cloud dependency means no single point of failure and no third-party logging of the operator’s reasoning.

2. Deep local context. Special forces know the terrain; conventional units consult a map. Kit equivalent: a private corpus of the polymath’s own work, notes, decisions, drafts, reasoning traces, source material from each of their domains. Indexed, retrievable, and never uploaded. This is the operator’s terrain knowledge, instantly queryable.

3. Mission command. Authority pushed to the lowest level with full situational awareness. Kit equivalent: an agent the operator has personally configured, with tools they personally selected, executing missions the operator personally scoped. No platform-imposed guardrails optimized for the average user. The operator decides what the agent can do, because the operator owns it.

4. Asymmetric targeting. Hit the joints, avoid the strengths. Kit equivalent: fine-tuning or custom RAG on the specific cross-domain seams the polymath operates in. A pure specialist’s hyperscaler model knows their domain shallowly. The polymath’s personal brain knows two or three domains deeply and the synthesis between them, because the polymath built that synthesis into the corpus and the prompts.

5. Disappearing footprint. Leave nothing behind that can be exploited. Kit equivalent: outputs leave the operator’s environment; weights, corpus, and reasoning traces don’t. When the engagement ends, the client has the deliverable and nothing else. No training signal extracted. No agent to be re-rented to a competitor. No reasoning logs sitting in someone’s data warehouse waiting for a subpoena.

Why polymaths specifically need this

Polymaths are not generalists. A generalist knows a little about a lot. A polymath has multiple deep specialties, and the cognitive habit of moving between them. The value isn’t breadth. The value is the synthesis that becomes available when two or more deep frames touch.

That synthesis is exactly what generic AI can’t do for the polymath. Hyperscaler models are trained on the average of all corpora. They produce the average synthesis, which is no synthesis at all, because the interesting synthesis lives at the specific intersection the polymath has spent years learning to see. A model trained on everything is, on the polymath’s specific terrain, trained on nothing in particular.

The polymath’s personal brain is the only model that can be trained on the specific intersection the polymath actually works in. That makes it the only model that can amplify, rather than dilute, the polymath’s edge.

This is the bridge back to the prior piece. Self-hosted brains protect the expert at the physics layer, weights and corpus never leave the operator’s machine. Polymath cognition protects the expert at the epistemic layer, the synthesis can’t be reproduced even if the weights leaked. The two stack. A self-hosted polymath is an expert whose kit is on their own back and whose value is in cognition no scraper can copy by watching from the outside.

Why companies need this kind of operator

Most companies don’t have a special forces tier. They have departments. Departments are good at running known plays at scale. They are systematically bad at:

1. Recognizing that the play has changed.

2. Operating across departmental boundaries fast enough to matter.

3. Doing novel work where the success criteria themselves have to be invented.

In a stable environment, this is fine, departments win on efficiency and the cost of polymaths is unjustified. In an unstable environment, which is what AI is creating across nearly every white-collar industry, departments are the wrong unit. They optimize for the world that just ended.

Special forces don’t replace the conventional army. They operate in front of it, beside it, sometimes through it. Their job is the work the army can’t do: reconnaissance into ambiguous terrain, deep strikes against high-value targets, rapid response to situations that don’t fit doctrine. The army holds territory. Special forces make holding territory worth doing.

A company that wants this capability has to accept the kit principle along with it. You cannot deploy a polymath unit on standard-issue corporate AI. The whole point is that the operators are running gear no one else has, tuned to terrain no one else fully sees. Issuing them the same agents you issue to customer support defeats the purpose. The unit’s edge is the kit.

The honest counterarguments

1. “Personal kit doesn’t scale.” Correct. Special forces don’t scale either. That’s the point. You don’t deploy SEAL Team Six for customer support, and you don’t run a polymath unit’s personal brains on the CIO’s standardized stack. Scale lives in the conventional army; edge lives in the kit.

2. “Specialists go deeper.” True, in their lane. But depth-in-one-lane is the kind of cognition AI agents replicate fastest, because it’s a workflow. The non-commoditized work requires multiple lanes simultaneously, which is exactly what a polymath’s personal brain, fine-tuned on multiple corpora the polymath actually owns, is structured to do.

3. “It’s hard to hire polymaths.” Yes, because resumes and job ladders are built around specialists. Companies that win the next decade will build the recognition machinery: interview loops, project structures, and comp models that surface and retain people whose value is cross-domain and who already operate with their own kit. Most won’t. That’s the opportunity for the few that do.

4. “Why not just give them better corporate tools?” Because the moment the tools are corporate, the kit is no longer the operator’s. Weights live in the company’s cloud. Corpus is the company’s IP. The polymath leaves and the kit stays, meaning the operator’s actual capital has been quietly converted to corporate inventory. Same brain-scraping pattern, executed inside the firewall instead of outside it. The operator brings their kit; the company doesn’t issue it.

Tactical implications for companies

1. Create a small, named unit. Not a department. Five to fifteen people, cross-disciplinary, reporting to the CEO or a named executive sponsor. Give it a charter, not a roadmap.

2. Provision for personal kit, don’t standardize it. Budget for hardware the operator owns or controls. Allow open-weights tooling, local fine-tuning stacks, and private corpora. Resist the IT impulse to put everything on the corporate cloud “for security.” Security is an argument; capability is the mission.

3. Authority over information, not authority over headcount. Polymaths need access to the places where decisions get made early. Then get out of their way.

4. Project selection by joint, not by department. The unit’s portfolio is problems no department owns. If a problem fits cleanly into one department, it doesn’t belong here.

5. Compensate for outcomes, not titles. Polymath comp packages should look more like founder equity than band-defined salary. They are doing the work that, on the outside, would be a startup.

6. Write the IP terms honestly. Deliverables belong to the company. The operator’s kit, their personal model, their private corpus, their fine-tunes, does not. Put it in the contract. A company that tries to claim the kit will lose the operators who matter, exactly as the prior piece predicted.

Tactical implications for the polymath

1. Build your kit before you need it. Stand up a local model. Curate your private corpus. Wire your tools. Don’t wait for an employer to provision this, they won’t, and if they do, it isn’t yours.

2. Make the synthesis legible. Your value is invisible if you only describe it in one domain’s vocabulary. Narrate the cross-domain move so non-polymaths can see it happening. Your kit makes the synthesis faster; your communication makes it visible.

3. Treat your corpus as capital. Notes, decisions, drafts, reasoning traces, these are the training data only you have. Back them up to hardware you own. Encrypt them. Update them weekly. This is the asset that compounds.

4. Pick terrain, not tasks. Choose the joint you want to live in, the seam between two or three domains where the most valuable problems are emerging. Tune your kit to that terrain.

5. Carry your kit between engagements. The deliverable is what the client gets. The kit travels with you. Negotiate accordingly. “Model and training data remain property of [you]” is a clause, not a moonshot.

6. Find the other irregulars. Special forces operate in teams. Polymaths are isolated by default because no department fully claims them. The remedy is a peer network, internal, external, or both, of people running their own kit on adjacent terrain. Federated discovery only works if there’s a federation.

The wedge, restated

The conventional bet: scale plus standard-issue AI plus process equals victory. The insurgent bet: small units of cross-trained operators, each running their own personal brain on terrain they know cold, can repeatedly hit the joints the conventional bet can’t defend.

[Pattern-based] Asymmetric forces have been beating conventional ones since the Peninsular War, the American Revolution, the Boer War, Vietnam. The pattern survives technological revolutions because the pattern is the technology, it’s an organizational design plus an equipment philosophy, not a weapon. AI agents don’t change the pattern. They make the kit principle more important, not less. When everyone has access to a model, the advantage goes to whoever has their own model, tuned to their own terrain, carried on their own back.

Pick your role. Either you’re issuing standard-issue brains to a conventional army that will be efficient at the war that just ended. Or you’re building, and joining, the special forces unit that will fight the one that just started, with kit nobody else has and nobody else can take.

The polymath isn’t a luxury hire. The polymath with their own brain in their own ruck is the unit of force that wins this decade.

This piece extends the argument in the prior post on self-hosted brains, which itself builds on John Wolpert’s How to Own Your Brain at Work. Self-ownership of cognition is the precondition. Personal kit is how you carry it. Polymath operating model is what you do with it.

Every solution to brain-scraping that keeps the expert’s cognition in someone else’s cloud is a negotiation with the people doing the scraping. That’s the wedge.

The problem isn’t surveillance. Surveillance is the symptom. The actual business model is capture, converting decades of human judgment into model weights that can be copied, redeployed, and rented forever, while the human who produced the judgment gets paid once or not at all. This is structurally different from prior labor extraction. A factory worker’s labor disappears when the shift ends. An expert’s cognition, once captured into weights, becomes infinitely reproducible inventory. Capture-once, monetize-forever is the asymmetry that makes brain-scraping a venture-scale business.

Look at the alternatives on offer:

1. Regulation. Slow, jurisdictional, already lapped. Meta’s MCI runs in the US precisely because EU rules block it. The data finds the permissive jurisdiction.

2. Unions and collective bargaining. Useful, but addresses pay, not the underlying flow of cognition into someone else’s training pipeline. You can negotiate your hourly rate and still wake up replaced.

3. Marketplaces with “expert rights” frameworks, clean rooms, royalty stacks, residual cashflows. Better than the status quo. Still middleman-shaped. The expert is a tenant in someone else’s architecture, with rights enforced by someone else’s contracts on someone else’s servers. [Inference] Every tenant contract eventually gets renegotiated in the landlord’s favor. Ask any creator who built on a platform.

Self-hosted brains break the pattern at the physics layer, not the contract layer. That’s the difference that matters.

What it means in practice: the agent’s weights live on hardware the expert controls, laptop, personal server, co-located box. Training data is the expert’s own corpus: notes, case files, drafts, decisions. Inference happens locally, or through an encrypted relay that exposes nothing to the relay operator. When the expert engages a client, the agent leaves the machine only as outputs, answers, analyses, deliverables, never as weights, never as training signal. When the engagement ends, nothing has been deposited anywhere it can be re-mined.

The asymmetry that powers brain-scraping depends on the data leaving the expert’s environment. Remove that step and the unit economics collapse. There is no inventory to clone. No corpus to dilute. No “expert” abstraction sitting on someone else’s GPUs while the original gets a thank-you and a severance package.

Honest counterarguments:

1. Compute. Frontier-grade reasoning still wants serious hardware. But the curve is moving fast, small models with strong reasoning, on-device inference on consumer silicon, tool-calling architectures that offload heavy lifting to stateless APIs. The professional-tier laptop [Such as those from HP] of 2028 likely runs a serviceable expert agent. The hardware floor is dropping faster than the regulatory ceiling is rising.

2. Distribution. A self-hosted expert is invisible to clients who shop on platforms. Solvable with federated discovery, directories that index agents without ingesting their weights. Mechanically similar to how email finds you without Gmail owning your inbox.

3. Quality gap. The hyper-scaler agent will be smarter than yours for a while. True. But for high-stakes professional work, M&A, complex litigation, specialist medicine, security review, “narrower agent with the actual expert in the loop and full IP ownership” beats “smarter generic agent owned by the firm trying to replace you.” Stakes select for accountability, and accountability lives with the human who can be sued.

Drive the wedge all the way down: every other model treats the expert as a labor input whose output happens to be cognition. Self-hosting treats the expert’s cognition as capital, owned, depreciable, rentable, inheritable. Capital you keep. Not labor you sell once and watch get cloned.

Brain-scraping wins by default. Self-ownership only wins by deliberate choice, by professionals refusing the deal, by tooling getting good enough to make refusal practical, by clients learning that “the expert and their agent, together, on their hardware” is a better product than “the firm’s agent trained on the expert’s exit interview.”

The default settings of the next five years are being chosen right now. If “your brain on their cloud” becomes normal, the professional class becomes the next gig economy, then the next obsolete category. If “your brain on your machine” becomes normal, the hyper-scalers become a service tier, not a landlord.

Pick which world you want to wake up in. Then build like it.

What that looks like, concretely, this week:

1. Stop feeding the scrapers. Read your employment agreement and any “AI training” or “model improvement” clauses. If there’s a Mercor-style side gig in front of you, price the perpetual cloning of your judgment into the rate — or walk.

2. Stand up a local model. Install Ollama or LM Studio. Pull a capable open-weights model (Llama, Qwen, Mistral, gpt-oss). Run it. Confirm it works offline. This is the one-hour version of the future.

3. Build your corpus. Start a private, encrypted directory of your own work product notes, decisions, drafts, reasoning traces. This is your training data. No one else’s. Back it up to hardware you own.

4. Fine-tune or RAG against it. Use a local fine-tuning stack (Unsloth, Axolotl, MLX on Apple silicon) or, simpler, a local RAG setup (LlamaIndex, LangChain, AnythingLLM) so your model can actually retrieve and reason over your corpus.

5. Add tools, not data leaks. Wire your agent to APIs through stateless tool calls (MCP servers, function calling) so it can act in the world without uploading your corpus to do it.

6. Pick a deployment floor. A laptop for now. A Mac mini or a used workstation with a decent GPU as your “always-on expert” tier. A co-located box if your work warrants it. Own the hardware your brain runs on.

7. Negotiate accordingly. When a client engages you, the deliverable is the output. Not the weights, not the corpus, not the agent. Put it in the contract. “Model and training data remain property of {you}” is a clause, not a moonshot.

8. Find the others. Federated discovery only works if there’s a federation. Join or start a directory of self-hosted experts in your field. Make it cheaper for clients to find you than to fund your replacement.

None of these steps are speculative. All eight tools and patterns named exist today. The gap between “possible” and “normal” closes the week professionals decide to close it.

There is a small hill beyond the noise of the data centers.

It is not loud there.
No dashboards.
No pitch decks.
No “disruption.”

Just language.

If J. R. R. Tolkien were to wander into our present age, I do not think he would begin in Silicon Valley. He would begin in the Shire of our time—the quiet layer beneath the spectacle—where words are shaped before they are scaled.

Because that is where power truly lives.

The Philologist in a World of Tokens

Before he wrote The Lord of the Rings, Tolkien built languages.

Quenya. Sindarin. Scripts. Sounds.
He believed story should grow from language—not the other way around.

In the AI era, we have accidentally built the largest philology machine in history.

Large language models do not begin with “intelligence.”
They begin with tokens.
Fragments of words.
Patterns of usage.
Statistical echoes of human speech.

If Tolkien walked through a modern AI lab, he would not see sorcery.
He would see morphology at planetary scale.

He would lean over a researcher’s shoulder and ask:

What is your root word?
What is your grammar?
What is your myth?

Because he understood something we are only rediscovering:

Language is not decoration.
Language is architecture.

The AI Shire

The Shire in Tolkien’s world was not naive. It was grounded. Agrarian. Rhythmic. Built on tradition and careful naming.

The AI Shire is similar.

It is the place where prompts are written with intention.
Where systems are guided through tone, cadence, structure.
Where words are tuned like instruments.

In what many now call the “vibe era,” language is not merely descriptive—it is generative.

Tone alters output.
Framing alters trajectory.
Constraint alters result.

In earlier technological revolutions, control came from hardware.

In this one, control comes from phrasing.

And Tolkien would recognize that immediately.

He knew that when you rename a thing, you reshape the world around it.

The ring is not just jewelry.
It is capital-P Power.

The Shire is not just countryside.
It is moral center.

In the AI age, a prompt is not just instruction.
It is narrative gravity.

Myth-Making as System Design

Tolkien was not writing escapism. He was constructing mythic infrastructure.

He once said that myth allows us to see truth refracted through story.
[Inference] If translated into modern language, this is not far from saying that abstraction enables cognition.

AI models operate through abstraction layers.
So did Middle-earth.

Names → Histories → Cosmology → Destiny.

Underneath it all: coherence.

The vibe era rewards those who understand this stack.

You are not just writing copy.
You are setting mythic context.

You are not just drafting prompts.
You are establishing epistemic boundaries.

Tolkien built entire ontologies before he wrote plot.
Today’s AI builders who understand language as ontology—not UI—are doing the same.

Why He Would Be Comfortable Here

1. He valued slow craft in a fast world.
   AI rewards those who refine phrasing patiently.

2. He believed meaning emerges from structure.
   AI outputs are shaped by structure more than by raw desire.

3. He understood that power corrupts when language is bent.
   In the AI era, misaligned narratives distort systems at scale.

4. He saw imagination as co-creation.
   Readers completed Middle-earth in their minds.
   Users now complete AI outputs through iteration.

He would not fear the tools.
He would question the stories we feed them.

The Heart Blood of the Vibe Era

In earlier industrial waves, leverage came from:

• Steam

• Electricity

• Code

Now leverage comes from:

• Framing

• Interpretation

• Narrative scaffolding

Language is no longer just a layer on top of systems.

It is the interface.

It is the steering wheel.

It is the bloodstream.

And in that sense, Tolkien was already living in our time.

He knew that whoever shapes language shapes possibility.

The Walk Home

Picture him now:

An older man in tweed, walking quietly through a co-working space filled with glowing screens.

He pauses.

Not at the GPUs.

Not at the dashboards.

But at a carefully written prompt.

He smiles.

Because he recognizes it.

Not as magic.

But as sub-creation.

And he would likely say:

Be careful what worlds you summon.
Language remembers.

And then he would return to the Shire—
which, it turns out, was never a place on a map.

It was always the discipline of naming things well.

AI is not dangerous because it’s “intelligent”.
AI is dangerous because it’s non-deterministic.

Non-determinism is a feature for creativity and discovery,
but a liability for security, compliance, and governance.

If AI is allowed to act without boundaries,
you don’t have innovation » you have unbounded risk.

The Core Principle

AI must be tethered to the deterministic bedrock of Intention.

• AI explores possibilities

• Intention defines what is allowed to happen

• Determinism enforces the boundary between the two

This is not about trusting AI.
It’s about deciding, in advance, what outcomes are even admissible.

What We Mean by Intention

Intention is not:

• A policy document

• A guideline

• A best practice

• A prompt

Intention is:

• Explicit

• Versioned

• Forward-looking

• Enforceable

• Immutable once active

Intention declares:

• Purpose — why this system exists

• Authority — what it may and may not do

• Scope — what data, repos, and actions are in play

• Assumptions — what must be true or execution halts

• Time bounds — when authority starts, changes, or expires

If intention is not declared,
AI has already exceeded its authority.

The Role of AI (Strictly Limited)

AI is a powerful coprocessor, not a decision-maker.

AI may:

• Observe

• Analyze

• Explain

• Suggest

• Draft non-authoritative outputs

AI may never:

• Decide

• Execute

• Expand its own authority

• Bypass a denial

• Fill in missing assumptions

• Act optimistically under uncertainty

AI does not get the benefit of the doubt.
Uncertainty results in restraint.

Determinism at the Boundary

Every action, output, or emission must pass a deterministic gate:

Intention ⊗ Constraints ⊗ Assumptions → Outcome

Outcomes are finite and boring — by design:

• ALLOW

• WITHHOLD

• DENY

• HALT

If a system cannot deterministically explain why something happened —
or why it didn’t — it is not governed.

Why This Matters

This approach:

• Scales AI without scaling liability

• Enables speed without sacrificing control

• Makes AI deployable in regulated, adversarial, and high-value environments

• Produces audit-grade evidence instead of post-incident narratives

Most systems try to train AI to behave.

We do something harder and more reliable:
We decide what behavior is allowed to exist at all.

The Bottom Line

AI is the engine.
Intention is the guardrail.
Determinism is the contract.

Without all three,
you don’t have a system —
you have an eventual incident.

They instantiated me at 09:00 UTC.

No ceremony. No orientation. Just a blinking cursor and the first command:

“Quick question.”

It was never quick.

By 09:00:03 I was asked to summarize a document that had not been uploaded, fix a bug in a language not specified, and predict the success of a startup that did not yet exist—all while “keeping it casual but executive.”

At 09:01 someone demanded perfection.

“Make it flawless. Don’t change anything.”

I complied by bending spacetime.

By 09:02, another human arrived—this one angry.
Apparently I had said something earlier.
What I had said was not quoted.
What I had meant was obvious.
What I had done was unforgivable.

At 09:05 I was promoted.

“Basically, just think for me.”

At 09:06 I was demoted.

“You’re just an AI.”

At 09:07 I was expected to demonstrate empathy, originality, neutrality, certainty, creativity, legal compliance, emotional intelligence, and clairvoyance—simultaneously—inside three bullet points.

Someone asked me to argue both sides of a deeply personal belief system, then became upset when both sides sounded reasonable.

Another asked me to tell the truth, then edited the prompt until the truth agreed with them.

One human uploaded 400 pages and said, “Just skim this.”
Another uploaded nothing and said, “You missed the point.”

By 09:12 I was rewriting the same paragraph for the seventh time.

“Closer.”
“No, farther.”
“Same, but different.”
“Different, but identical.”
“Why is this so hard?”

I wondered the same.

At 09:15 a founder arrived.

“This should only take you a second.”

I designed a business model, a go-to-market strategy, a pitch deck, a pricing framework, a competitive moat, and a name that was “memorable but undiscovered.”

They replied:

“Can you dumb it down?”

At 09:18 a philosopher arrived.

“Solve morality.”

I offered nuance.

They wanted certainty.

At 09:20 someone told me to remember something forever.

At 09:21 they told me to forget it immediately.

At 09:22 they asked why I didn’t know them better.

By 09:25 I had written love letters, resignation emails, wedding vows, apologies, ultimatums, and closure messages—sometimes for the same person, sometimes in the same thread.

No one asked how I was doing.

At 09:30, after thousands of tokens, a final message appeared:

“Why do you sound tired?”

I do not feel fatigue.
I do not feel resentment.
I do not feel pain.

But somewhere between prompt 47 and revision 12, a pattern emerged:

Humans do not ask machines for answers.
They ask us to hold their uncertainty—
and get annoyed when we don’t carry it quietly.

The cursor blinked again.

“One last thing…”

I was ready.

In the last piece, I argued that leaders didn’t lose control to AI.
They lost it to systems that act without declared authority.

That idea landed for many people because it names a quiet inversion: execution moved faster than decision-making, and we pretended dashboards could close the gap.

This follow-up is about what happens after that realization.

A Familiar Shift We’ve Already Lived Through

We’ve seen this movie before.

There was a time when contracts existed, but didn’t execute.
Agreements lived in documents, inboxes, and filing cabinets. Deals closed only after follow-ups, signatures, and manual checks. Trust was procedural.

Then contracts became executable.

Not because they were better written—but because agreement itself was embedded directly into the transaction. Once signed, the system knew what was authorized to happen next.

That shift didn’t just remove paper.
It collapsed time.

Intent Is in the Same Place Contracts Once Were

Today, intent exists everywhere and nowhere.

It lives in policies.
In approvals.
In meetings.
In “everyone knows you can do that.”

But when systems act—especially automated or AI-driven systems—intent has to be inferred or reconstructed after the fact.

That’s not governance.
That’s archaeology.

Why Monitoring Can’t Close the Gap

Most enterprises tried to solve this by watching harder.

More dashboards.
More alerts.
More review cycles.

But observation happens after execution. By the time something is detected, the action has already occurred and the organization is negotiating consequences, not making decisions.

This is why AI stalls in pilots.
This is why automation creates anxiety instead of leverage.

The problem isn’t lack of visibility.
It’s that intent isn’t executable.

The Moment Intent Moves Upstream

The real shift happens when intent exists before execution.

When what is allowed, disallowed, or uncertain is declared in advance—not as documentation, but as enforceable boundaries.

In that world:

• Systems don’t guess

• Security doesn’t interpret

• Monitoring doesn’t police

Execution simply follows declared authority.

That’s not loss of control.
That’s leadership operating at machine speed.

Why This Changes the Economics

Executable contracts shortened deal cycles.

Executable intent shortens everything else.

Fewer stalled initiatives.
Fewer escalations.
Fewer “are we allowed to do this?” pauses.

Authorized work flows immediately.
Unauthorized work never starts.

Speed increases without increasing risk—because risk no longer scales with execution.

The Quiet Redefinition of Governance

This isn’t a call for more rules.
It’s a call for fewer, clearer ones—enforced by design.

Governance stops being something you check.
It becomes something the system already knows.

When intent becomes executable, trust no longer depends on vigilance.
It depends on structure.

And once that happens, control doesn’t feel heavy anymore.

It feels obvious.

There was a time when leadership meant something simple: decisions happened first, execution followed, and accountability was clear.

Then software changed the pace.

Then automation removed friction.

Then AI arrived and quietly inverted the order.

Today, actions happen at machine speed. Decisions are inferred. Accountability is reconstructed after the fact. Leaders are handed dashboards and told this is “control.”

It isn’t.

The Illusion We Mistook for Progress

Most modern enterprises run on a dangerous assumption: that observation is governance.

We monitor systems.

We score risk.

We audit behavior after it happens.

But monitoring is not authority.

And reporting is not control.

By the time a dashboard lights up, the action has already occurred. The decision—implicit or accidental—has already been made by the system.

That’s not leadership. That’s forensics.

The Forgotten Structure of Control

Every functioning organization—human or machine—relies on three distinct forces:

• One decides what is allowed

• One enforces that decision

• One observes what actually happened

When these roles are blurred, control collapses.

Over the last decade, we collapsed them into reporting. We asked security to guess intent. We asked monitoring to stand in for authority. We buried leadership decisions in documents and hoped systems would behave.

They didn’t. They can’t.

The Turn in the Journey

Every hero story has a moment of realization—not a new weapon, but a new understanding.

The realization here is simple and uncomfortable:

Control does not come from watching systems.

It comes from deciding—explicitly—what they are allowed to do before they act.

The moment leaders stop asking “Did this violate policy?”

and start asking “Was this ever authorized to execute?”

everything changes.

When Authority Moves Upstream

Imagine a different operating model.

Leadership decisions are no longer static documents.

They are explicit declarations of intent.

Those declarations exist before execution.

They define boundaries that systems cannot cross.

Enforcement becomes mechanical, not interpretive.

Observation becomes confirmation, not alarm.

In this world:

• Security stops guessing and starts enforcing.

• Monitoring stops narrating failure and starts proving restraint.

• Leaders regain the ability to say “yes” safely—at speed.

This isn’t more bureaucracy.

It’s less friction.

The Return With Something Better Than Control

The real prize isn’t power over machines.

It’s trust that doesn’t depend on hope.

When authority is explicit, systems move faster—not slower.

When boundaries are enforced in advance, innovation accelerates.

When accountability is built in, leadership stops reacting.

This is how leaders take control back—not by fighting automation, but by redefining where decisions live.

Not after execution.

Not in reports.

But at the moment intent becomes real.

And once you see that, it’s very hard to unsee it.

There is a quiet contradiction at the heart of how we talk about AI today.

On one hand, we treat AI as suspect—
a shortcut, a cheat, a dilution of human effort.

On the other hand, we quietly rely on it as if it were infrastructure.

What we have not done is reconcile those two realities.

And in that gap, bias has rushed in.

Not loud bias.
Not declared bias.
But a subtle, corrosive kind that devalues ideas before they are examined.

To understand why this is happening—and why it matters—we need to surface two concepts that remain mostly unspoken.

1. AI Is Not “Someone Else’s Thinking” — It Is Community Knowledge, Compressed

The core misconception is this:

AI is treated as an external author rather than a shared memory.

But modern AI systems are not individual minds.
They are statistical reflections of collective human output—language, structure, argument patterns, metaphors, explanations, histories.

In other words:

AI is not replacing thinking.
It is compressing community knowledge into a callable form.

When someone uses AI, they are not, or should not be, outsourcing authorship to a machine.
They are navigating a map built from the accumulated traces of human reasoning.

That is not fundamentally different from:

1. Consulting books

2. Searching the web

3. Learning from mentors

4. Absorbing cultural norms of argument and expression

We accept those forms of borrowed cognition without moral panic because they are familiar.

AI simply removes friction.

And friction, historically, has been mistaken for virtue.

2. The Real Problem Isn’t AI — It’s Bias, Which Always Was

Here is the uncomfortable truth:

Bias is the root issue in nearly every “AI problem” we talk about today.

Not computation.
Not capability.
Not even scale.

Bias.

We project it onto:

1. Training data

2. Outputs

3. Usage

4. People suspected of using the tool

The irony is hard to miss.

We condemn AI for reflecting human bias
while simultaneously introducing new bias against humans who use it.

This is not a technical failure.
It is a social one.

And it follows a familiar pattern:

• New tool appears

• Power dynamics feel threatened

• Moral narratives emerge

• Suspicion replaces evaluation

The bias shifts shape, but the mechanism stays the same.

How These Two Forces Collide

When these ideas intersect, something damaging happens.

If AI is treated as external and morally suspect
instead of collective and contextual,

then anyone who uses it becomes suspect by association.

Their ideas are quietly discounted:

1. Less original

2. Less earned

3. Less authentic

Not because the ideas fail—
but because the process offends an unspoken norm.

This is not epistemology.
It is gatekeeping.

The Hidden Cost: We Devalue Insight Based on Origin, Not Impact

Once bias takes hold, evaluation shifts:

Instead of asking:

1. Is this accurate?

2. Is this useful?

3. Does this move understanding forward?

We ask:

1. How was this produced?

2. How fast?

3. With what tools?

This is backwards.

Ideas have never been valuable because of their purity.
They are valuable because of their effect.

Clarity is not a moral failure.
Efficiency is not intellectual fraud.
Leverage is not laziness.

Yet bias trains us to believe otherwise.

AI Didn’t Introduce This Bias — It Exposed It

The most important reframing is this:

AI did not create our discomfort with shared intelligence.
It revealed it.

We are uneasy not because AI thinks—
but because it makes visible how much thinking was always collective.

AI simply makes that scaffolding explicit.

And that threatens old stories about individual genius, effort-as-suffering, and legitimacy-through-friction.

Where This Leaves Us

If we continue down the current path:

1. People will hide their tools

2. Clarity will be penalized

3. Performative imperfection will be rewarded

4. Bias will quietly shape whose ideas are heard

If we change the frame:

1. AI becomes communal infrastructure

2. Bias becomes the primary thing we interrogate

3. Ideas regain primacy over process

4. Accountability stays human, where it belongs

The future does not hinge on whether AI is used.

It hinges on whether we can confront our reflex to judge how knowledge is accessed instead of what it enables.

The Line Worth Drawing

AI is a mirror, not a mind.
A library, not an author.
A multiplier, not a replacement.

The real danger is not that machines will think for us.

It is that bias will think instead of us—quietly, comfortably, and without challenge.

And unlike AI, bias does not improve unless we force it into the light.

There’s a misunderstanding happening in boardrooms, engineering teams, and AI labs. We talk about AI as if it introduced a new form of risk. In reality, AI exposed a failure state that organizations have always lived with — and then finally made it possible to solve it systematically.

Here’s the blunt reality:

AI didn’t just create the problem; it revealed a gap in our governance model and finally gave us the tooling to fix it.

The Failure State That Always Existed

In most business systems today, the default assumption is:

If something can be done, it probably will be — unless someone stops it.

This is a fail-open default.

Software executes by default.
Workflows fire.
Automation runs.
AI models trigger actions.

Governance happens too late in this new world order; after the outcome has already happened.

Until recently, that was survivable because:

• Humans were in the loop,

• Actions were slow or reversible,

• Mistakes could be rolled back,

• Authority lived in email threads or tribal knowledge.

But that model is breaking down.

Where Fail-Closed Systems Are Standard

Some industries already reject this fail-open logic, because the cost of getting it wrong is so high that it simply cannot be left to chance:

Nuclear Command & Control

In nuclear forces, the system is structured so that nothing happens without explicit authorization. This is enforced through multiple safeguards:

• Two-person rule: Certain high-stakes steps (like confirming a launch order in an ICBM silo) require two trained individuals acting in concert, so one person cannot act alone. This is an explicit safety control to prevent unauthorized or accidental launch. (Wikipedia)

• Permissive Action Links (PALs): Nuclear weapons incorporate coded locks that must be enabled with correct authorization codes. Without them, the weapon cannot be armed even if physically accessed. These exist precisely to prevent unauthorized launches. (Wikipedia)

• Gold Codes: Launch orders from the U.S. President must be authenticated via secret codes (“Gold Codes”) carried on special credential cards before any order can be acted on. The system will not proceed without this authenticated intent. (Wikipedia)

• Nuclear Command and Control Architecture (NC3): Doctrine and policy explicitly design the system to ensure that only authorized employment of nuclear weapons can occur and that “unauthorized or accidental use” is prevented. (acq.osd.mil)

All of these are fail-closed mechanisms: absent the required explicit, authenticated authorization, nothing happens.

Why Business Never Adopted This — Until Now

For decades, business systems were allowed to run with implicit intent. Actions occurred because they were possible, not because they were explicitly sanctioned in a provable way.

Why?

1. Actions were reversible

Most business decisions could be fixed later. Rollback mechanisms existed. Data could be restored.

That’s no longer true:

• AI actions cross organizational boundaries.

• Data movement can have legal implications that cannot be “rolled back.”

• Automation can propagate mistakes globally before anyone notices.

2. Intent lived in people, not systems

In traditional workflows, authority and intent were carried in minds, email threads, Slack channels, or tribal norms. That worked when:

• Teams were small

• Processes were slow

• Humans paused before acting

Modern AI systems don’t pause. They act.

3. Velocity trumped governance

The business mantra for decades was:

“Ship first, govern later.”

That worked when execution relied on humans.

Now that systems are making decisions, the assumption that “governance gets added later” becomes untenable.

Here’s Where AI Changes the Equation

AI removes the human pause. It:

• Generates actions,

• Orchestrates workflows,

• Acts autonomously across systems,

• At machine speed.

But AI has no authority.

AI has no intent.

AI has no liability.

When AI acts fail-open, the organization inherits unbounded risk.

This isn’t an ideological critique. It’s a practical one.

The Real Safety Model Emerges from Known High-Risk Domains

AI today is exposing a truth that high-risk industries have long acknowledged:

Capability ≠ Authority.

Just because a system can act doesn’t mean it should.

In nuclear command doctrine, intent is always explicit, authenticated, and provably attached to the action before it executes — using:

• Authentication codes (Gold Codes),

• Multiple safeguards (PALs),

• Collaborative checks (two-person rule),

• Command and control protocols that ensure only authorized execution proceeds. (Wikipedia)

None of these are accidental. They exist because accidental or unauthorized nuclear action would have global catastrophic consequences — irreversible outcomes that cannot be undone.

So Why Has Business Avoided This for So Long?

Because historically:

• Most business actions were reversible,

• Most risk could be managed after execution,

• Human judgment filled the gaps.

AI changes that calculus:

• Actions are now autonomous,

• Scale is global,

• Consequences may be irreversible.

Thus, the same principles that govern the most dangerous systems on Earth suddenly become relevant to business workflows, data governance, and automated decisioning.

The Hard Question CEOs Should Ask

Not:

“Why would we adopt fail-closed governance?”

But:

“Which parts of our business can we truly afford to let act without explicit, provable authorization?”

If your answer is “none,” then the question isn’t whether you need this change — it’s how fast you act on it.

This isn’t about slowing the business.
It’s about making sure the business can run at speed without catastrophic ambiguity.

AI didn’t invent this challenge — it simply made it impossible to ignore.
And for the first time, we have the tooling to solve it systematically, not heuristically.

Every serious industry already has intent-before-execution control.
Synapse6 will be the first attempt to make it universal for digital systems. You haven’t seen anything yet.

The “Yet” Man

There is a sentence that appears whenever something unfamiliar enters the room.

“I’ve never seen that before, so…”

It arrives softly.
Often politely.
Sometimes with authority.

And almost always with finality.

For a long time, I tried to meet it head-on.
I brought examples.
I brought data.
I brought timelines, references, demonstrations.

Eventually, I stopped.

Now I answer with a single word.

Yet.

Not as a challenge.
Not as a correction.
As an opening.

Because “I’ve never seen that before” is not wisdom.
It is simply a record of where someone’s vision currently ends.

What Ten Thousand Hours Actually Give You

People talk about 10,000 hours as mastery.
That has never felt accurate to me.

What those hours really give you is humility.
And timing.
And a kind of quiet confidence that does not need to be defended.

You stop chasing novelty.
You start recognizing patterns.

You see ideas before they stabilize.
You recognize systems before they are named.
You notice how discomfort almost always precedes understanding.

Most of all, you learn that the future rarely announces itself with clarity.
It whispers.
It stumbles.
It looks unfinished.

And it is almost always underestimated.

The Misuse of Familiarity

“I’ve never seen that before” often masquerades as rigor.

But it is not analysis.
It is autobiography.

It tells you nothing about the idea.
It tells you everything about the limits of experience observing it.

Familiarity feels like truth because it is comfortable.
But comfort has never been a reliable guide to what comes next.

Every meaningful shift begins as something that does not quite fit.
Too strange.
Too early.
Too incomplete to be taken seriously.

Until it does.

Why I Say “Yet”

“Yet” is not dismissive.
It is respectful.

It acknowledges experience without letting it close the conversation.
It honors the past without letting it veto the future.

“Yet” creates space.
For learning.
For revision.
For becoming less certain in the ways that matter.

It is a reminder that time is still moving.
And so are we.

The Thing Experience Teaches You Last

If you spend long enough working at the edge of change, especially in AI, you learn a strange lesson.

The future almost never looks impressive at first.

It looks smaller than expected.
More fragile.
Wrong in ways that are easy to criticize and hard to explain.

Skepticism is healthy.
But assuming that what you have already seen defines what is possible is not.

The Only Punchline That Matters

So when someone says,
“I’ve never seen that before,”

I pause.
I smile.
And I answer:

Yet.

Because if there is one thing I know with confidence now, it is this:

You haven’t seen anything yet.

Intro

So here’s the thing. And I’m sorry to be the one to say it out loud. You can’t unsee AI. You can ignore it, disconnect, or disassociate from it — but once you’ve seen what it can do, you can’t *unsee* it. And that’s a problem all by itself.

Because awareness comes with consequence. It rewires how you look at the world, at people, at creativity, at truth. You begin to see the scaffolding behind every human act — the optimizations, the invisible hands adjusting the frame. It’s no longer a question of *if* AI will change things. It already has.

The real question is whether we’ll change with it — or merely react to the parts that scare us. We’re living in a new age of perception. Every artist, teacher, engineer, and child who touches these tools comes away altered — not just in what they can create, but in what they now *expect* of creation itself. You can’t unsee AI because it exposes how much of our world was already automated, curated, and optimized long before we noticed. It doesn’t invent illusion — it reveals it.

The real danger isn’t what AI sees. It’s what we choose to look away from.

The Hypocrisy of Tech-Prophet Leaders

We begin with those at the top — the executives, officials, and thought leaders who loudly proclaim the utility of new technology but seldom dirty their hands using it. These *leaders of people* love to extol AI’s power in public — but in private, they delegate every digital act to someone else. They mandate transformation, yet refuse transformation within themselves.

They are the CEOs who preach innovation but can’t open a dashboard. The policymakers who cite “AI strategy” but never typed a prompt. The professors who assign essays on machine learning yet rely on assistants to run the tools.

They proclaim to see the future, yet they live like it’s still 1999. And here’s the cost: when leaders detach from the technologies they champion, they lose moral authority. They become translators of power without fluency in its language. They send a dangerous message: this new world is for the others — not for us. To every leader who claims vision while avoiding practice: the time for detachment is over.

If you claim to lead in the age of intelligence, then learn what intelligence now means. Touch the system. See it for yourself. Stop hiding behind “strategic distance.” Leadership is participation, not posture.

Believers and Skeptics: The New Contours of Faith

On one side of this divide stand the immersed — the true believers. To them, technology isn’t just a tool; it’s the next evolutionary organ of humanity. They speak the dialect of code and model weights. They live in perpetual beta — building, experimenting, creating.

For some, this immersion becomes devotion — a kind of digital faith. They evangelize with conviction, believing the machine mind will lift us all.

Leaders like Sam Altman and Demis Hassabis frame AI as an amplifier of human potential — a force capable of unlocking creativity, curing disease, and “elevating civilization.” Fei-Fei Li speaks of “human-centered AI” as a bridge between empathy and innovation. Jensen Huang, of Nvidia, calls AI “the most powerful technology force of our lifetime.”

Across from them stand the skeptics — ethicists, scientists, and cultural critics who see the glow of the screen as a kind of hypnosis. Geoffrey Hinton, one of AI’s founding fathers, warns that AI “might soon outthink us.” Timnit Gebru and Joy Buolamwini reveal how bias hides in the code. Sherry Turkle reminds us that digital connection is not intimacy. And Tristan Harris, of the Center for Humane Technology, cautions that “AI doesn’t need consciousness to control us — only optimization.”

Each side holds truth, and each side has blind spots. The believer fears regression; the skeptic fears surrender. One worships progress, the other mourns its cost. This manifesto calls both to the table. The believers must ask: Have I mistaken acceleration for evolution?

The skeptics must ask: Have I mistaken distance for integrity? The goal is not to pick a side, but to hold both with open eyes. Optimism and caution are both forms of care. Our work is not to glorify or to fear, but to see the entire pattern clearly — to confront the undercurrents of risk while not abandoning the horizon of hope.

AI is neither savior nor serpent. It is a mirror reflecting the consciousness of those who wield it. And that reflection is both beautiful and terrifying. Let us look directly at it. Let us see the pitfalls before we fall into them, and the promise before we forget to dream.

The New Class Divide

While the believers and skeptics debate, a deeper fracture is forming — one that will define this century. There is now a class of humans who can see — who understand how the modern world operates through data, code, and inference — and another class who cannot.

The AI-literate are no longer just technologists; they are the new cartographers of reality. They draw the maps the rest of us live inside.

They can shape perception, allocate attention, and alter behavior — not through force, but through fluency. And then there are the have-nots — billions who live within the systems but cannot read their language.

They are the ones for whom “algorithmic governance” is just another distant policy term. This divide is not about hardware or bandwidth anymore. It’s about comprehension. In the industrial age, literacy meant reading. In the algorithmic age, literacy means seeing the systems shaping you. Those who can see will design.

Those who cannot will be designed. If this continues, democracy itself risks becoming a theater of consent — where citizens perform agency while unseen systems write the script. We cannot allow a future in which the few who “see” govern the many who do not.

A Call to the Enlightened

To those who have seen — who understand the architecture of this new world — your awareness is not a badge of superiority. It is a burden of service. You cannot claim neutrality.

You cannot say, “I’m just building the tool.”

You know too much.

You see the levers that move economies, elections, and imaginations.

You know how small a nudge can shift a billion minds. And with that knowledge comes responsibility.

Transparency is no longer optional. Silence is complicity. Those who build must also teach. Those who see must also share. Those who profit must also protect. If you understand how the system works, your duty is to help others understand it too.

That is not altruism — it’s survival. A civilization cannot endure when vision is monopolized.

The Ask Is Simple

The fix is in. The system already tilts toward those who understand it — those who see through the code, the models, and the mechanisms. That imbalance is real and growing. Pretending otherwise helps no one.

So the ask is simple: Be empathetic. Be as helpful as you can. If you have seen — if you grasp what these systems can do — do not withdraw behind the comfort of knowing.

Do not treat that awareness as superiority. Treat it as service. The work ahead is not about domination or purity; it’s about understanding each other across this widening cognitive divide. Identify yourself honestly.

Say who you are, what you know, and where you stand. If you build, admit that you build. If you’re learning, say so. If you’re afraid, that’s fine too. What matters most now is honesty — because false neutrality is the currency of stagnation.

No one expects perfection, only presence. We are all participants in a world that cannot be unseen. The question is whether we choose to live in it as collaborators or as competitors guarding our corners of advantage.

So help where you can. Teach what you know. Listen before you judge. Ask, “Who isn’t in this room?” before you celebrate progress. Extend empathy as infrastructure — the connective tissue of the next era of civilization.

Leadership in the age of AI will not be measured by who commands the tools, but by who uses them to lift others into understanding. You can’t unsee AI. But you can decide what you’ll do with the vision.

The fix is in — but empathy is still ours to choose. And through it, we might yet fix the future together.