My Life in the Harness
I don’t work in a chat window anymore. I work in the Business Engineer’s harness.
Somewhere in the last few months, the shape of how I produce has changed. I stopped typing prompts and reading answers one at a time, and started setting a frame in the morning and watching a swarm of agents carry it through the day — drafting, optimizing, scheduling, measuring, adjusting — while I did the one thing none of them can do for themselves: decide what was worth doing, and define what good meant before any of it ran.
And I’m rarely at a desk when it happens. I set the frame from a phone — in transit, between other things, walking — because the work no longer runs where I am. It runs in a runtime somewhere else, and the thing in my hand is just the surface I steer it through. The computer I spent thirty years sitting in front of has quietly left the room.
This isn’t a piece about tools. It’s about what’s left for a person to do once the tools can do almost everything. The answer is smaller and sharper than most people expect — and the whole map of it fits in six moves. Here they are, one at a time.
The edge has moved to framing
The scarce, valuable skill is no longer operating the model. It’s framing the work before the model runs.
Here is the rule that governs every technology shift: when a capability becomes universal, it stops being an advantage, and the edge moves up the stack to whatever is still scarce.
Trace it. Hardware was once the edge — until hardware became cheap and abundant, and the advantage moved up to software. Software commoditized, and the edge moved to distribution. Then to data. At each step, once everyone had the layer, it stopped being where the advantage lived, and the advantage climbed one rung higher.
AI capability has now reached that point. Everyone has the same frontier models. The compute is cheap, the interfaces are frictionless, and the gap between a well-funded team and a solo operator with a credit card has all but closed. So the edge has already left the model itself. For a short while it sat one rung up — in operating the model: the skill of working a chat window well, structuring the problem, reading the output, re-prompting toward something sharp.
That rung is commoditizing too, and fast — because of agents. An agent doesn’t wait for you to prompt it. It prompts itself, reads its own output, notices its own errors, and re-runs. The skill of working the chat window is being absorbed into the system. So operating, the thing that was briefly the edge, is becoming something the machine does for itself.
Which moves the edge up one final rung — to the one input the agent cannot generate on its own: the frame. Framing is everything you decide before the agent runs. It has four parts:
Problem definition — what is actually being solved, stated as a mechanism, not a wish.
Constraints — the boundaries any acceptable answer has to stay inside.
Evaluation criteria — what “good” looks like, specified in advance.
Stopping conditions — when the agent should halt, escalate, or hand back.
The frame is the whole of the human contribution. Everything downstream of it is execution. That is the first move, and the rest of the piece follows from it: if framing is the edge, then everything else — why it matters, who’s exposed, how to do it, what it steers, and what it does to the industry — is a consequence.
Autonomy removed the safety net
In the old way of working, a weak first attempt was cheap because you could fix it as you went. Autonomy removes that, so the first frame now decides the outcome.
Think about how working with a chat model used to go. You asked a rough question, got a rough answer, saw it was rough, and asked a better one. The cost of a bad first try was low, because you stayed in the loop turn by turn and caught the drift as it happened. Trial and error did a lot of the thinking for you. A careful operator and a careless one both reached a decent answer in the end — the careless one just took longer.
An autonomous agent removes that loop. It runs fifty steps without checking back. There is a frame at the start and a result at the end, and nothing in between where you correct course. If the frame was weak — wrong problem, soft constraints, no definition of “good” — the agent doesn’t notice. It executes the weak frame faithfully, confidently, and fast, and hands you a polished, internally consistent answer to the wrong question, delivered at a speed that makes it look authoritative.
That is the characteristic failure of this era, and it has a shape worth naming: confidently wrong at scale. A small error in the frame fans out into a large error in the output, because every autonomous step compounds the one before it. The old way punished a bad frame with a few wasted minutes. The new way punishes it with a finished deliverable that’s wrong in a way nobody catches until it ships.
This sorts people into three tiers, and it’s worth being blunt about who’s where:
Prompters — whose skill was phrasing. Obsolete; the agent phrases better than they do.
Operators — genuinely skilled at working the loop turn by turn. Newly exposed, because the loop they were good at is the part being automated away.
Framers — who can specify a problem, its constraints, and its success criteria before any execution starts. This is the tier that wins, and it’s thin.
The uncomfortable part is that the exposed tier is full of capable people. Skilled operators assume their fluency carries over. Some of it does — but the part that carries over is exactly the part that’s commoditizing, and the part that doesn’t carry over, framing, is the part that now decides everything. It was never the thing they practiced.
How to actually frame
Framing is a discipline with specific moves, not a personality trait. Three of them matter most.
Find the binding constraint before you delegate. Most problems aren’t what they look like on the surface, and an agent will optimize whatever you point it at — including the wrong thing. Solving the wrong bottleneck at agent speed is worse than solving nothing, because it produces motion that looks like progress. So the first act of framing is to ask: what is the one thing that, if left unaddressed, makes every other improvement irrelevant? You answer that before the agent opens, because the agent can’t.
Decide what “good” means before anything runs. When you worked in a chat window, you judged the output by eye, after the fact. You cannot eyeball fifty autonomous steps, and you certainly cannot eyeball a hundred parallel runs. So the judgment has to move earlier: you specify what a good result looks like in advance, in terms concrete enough that correctness is checkable without you re-reading everything. Evaluation stops being a final glance and becomes part of the frame. This is the hardest of the three, because it forces you to know what you want with a precision most work never demands.
Separate the mechanism from the story — because the agent won’t. Hand a model a compelling narrative and it will execute the narrative. It has no built-in defense against a frame that reads well and is structurally false. Knowing the difference between what is mechanically true and what is merely a good story is the difference between a system that compounds correctness and one that compounds a plausible mistake.
There’s a practical upshot. A thinking system — a repeatable way of mapping constraints, classifying what’s a real advantage versus a temporary one, separating mechanism from narrative — stops being a personal habit and becomes the thing you load into the machine. It’s the specification you hand the agent so it inherits your structure instead of improvising its own. The frame isn’t just the prompt you type. It’s the encoded judgment you front-load so the autonomous system runs inside it.
What the frame steers: the harness
The frame is the human’s input; the harness is the system that executes it. The model is commoditized. The harness is where the real differentiation now lives.
A harness is the orchestration wrapped around the model: which agents you run, on what schedule, with what feedback loops, what approval gates, and what memory. The same model is available to everyone, so the model isn’t the edge. The harness is — and the ones that actually compound follow a handful of structural rules.
Use a swarm of specialists, not one mega-agent. A single agent asked to do everything degrades under load — the same reason companies have departments instead of one person who does all jobs. What works is a swarm of narrow specialists, each with one job, running on their own schedules. The agent producing content doesn’t need to know how a call-to-action gets tuned; the title optimizer doesn’t care about delivery. Specialization here is org design, not engineering.
Make the loop self-improving, or it’s just a cron job. An agent that runs the same playbook every day is automation that slowly decays. The agents that compound read their own results — which headline drew clicks, which copy converted — and feed that back into the next run. The durable asset isn’t the agent; it’s the learning loop.
Share one source of intelligence. If every agent independently asks “what’s working,” they drift and contradict each other. The fix is a shared module they all read from — one cached source of truth — so every decision is made from the same picture. Coherence is something you design in, not something you hope emerges.
Use gates, not guardrails. The instinct is to fence agents in with rules everywhere. What works is to let them run freely on low-stakes work — updates, optimization, scheduling — and put hard approval gates only in front of high-stakes actions: publishing, sending, spending. The ratio is the discipline: roughly 95% autonomous, 5% gated. Gate too much and you become the bottleneck, which destroys the speed that justified the system.
Treat memory as architecture. A system without persistent memory rediscovers its context every session, like a tourist. Structured memory — feedback rules, project state, preferences, reference pointers — loaded into every run is what lets the system accumulate knowledge. Mistakes become permanent rules; preferences become defaults. That accumulation is what turns a tool into an operating system.
The orchestration is the real engineering. Getting a model to write or send was never the hard part. The hard part is wiring eight or ten systems — content, analytics, delivery, social, payments — so an action in one triggers the right response in another. The plumbing between systems is the work now; the reasoning is the easy part.
Put those together and you reach the punchline: one person with judgment plus a harness produces what used to take a team. The old org chart for this kind of workload was a department — several content people, an SEO specialist, an email marketer, a social manager, an analyst, a developer, a designer. The harness collapses it to one person who supplies taste, judgment, and direction — the frame — while the harness supplies execution and pattern recognition at scale. The winners aren’t building AI. They’re building harnesses.
The computer left the desk
Because the harness runs somewhere else, your physical relationship to computing inverts. The machine stops being a place you sit and becomes a process you steer from anywhere.
There’s a physical change underneath the cognitive one, and it took me a while to see it for what it was. I no longer sit in front of a computer to work. I set the frame from a phone, on the move, and the execution happens somewhere I’m not.
This isn’t a productivity habit. It’s the visible edge of a larger shift: the agent is becoming the computer. The old definition of a computer was a box you sat at — an app, on an operating system, on a chip, operated through a screen. The new definition, the one now being built straight into the silicon, is different: an agent is a brain (the model) plus a body (the harness) plus a runtime — wherever the work actually runs, whether that’s a cloud, a server, or eventually a robot. The runtime is the part that matters here, because by definition it isn’t your desk. Once the computer becomes the agent, it stops being a place you go and becomes a process running elsewhere that you hold a thin handle to.
This is also the end state of a longer progression. AI first ran in a sandbox, then learned to use tools, then learned to operate a whole computer, and finally converges with the computer itself — and convergence, experienced from the user’s side, feels like this: there’s no chair. The interface stopped being clicks and commands and became intelligence. You state a goal; you approve an outcome. And once the interface is intelligence, the form factor is free. A goal doesn’t need a keyboard. An approval doesn’t need a monitor. The big screen and the desk were artifacts of operating — and operating is exactly the part that just left.
What remains for the human collapses to two acts, and both are light enough for any device: set the frame, and clear the gate. A goal goes out; an approval comes back. Neither needs a workstation. A phone does it now. The next surface won’t even be a phone — it’ll be some AI-native object closer to an always-on personal assistant than a PC, something you speak goals into and tap approvals on. The screen shrinks because the work it used to hold moved off it.
Call the pattern the thin surface: when the interface becomes intelligence, the human’s surface shrinks to two interactions — frame-in and gate-out — that fit any device and untether the work from the desk. The harness runs remote; you carry the handle.
The strange part is how natural it feels. For three decades, “using a computer” meant arranging my body in front of one. Now the computer is a process I start with a sentence and check with a tap, from wherever I happen to be standing. I didn’t leave the desk on purpose. The work left, and I followed it.
Where the whole industry is heading
The same logic that reorganized my desk is reorganizing the frontier. The entire industry is converging on a single contest — to own the harness.
Follow the harness up the stack and the macro picture falls into place.
The frontier AI labs are running deeply negative margins on heavy agentic usage. The easy reading is “the economics are broken.” The structural reading is the opposite: the harness is where the next moat sits, and the labs are paying to build it. Two facts make that rational rather than reckless. First, token costs are falling by orders of magnitude — what’s subsidized today is cheap to serve tomorrow, so the loss is really a financing cost on a future-cheap good. Second, once someone runs their whole operation through one lab’s harness, the cost of leaving is no longer the model — it’s the accumulated memory, the tuned loops, the wired-up orchestration. You can swap a model in an afternoon. You can’t swap a harness you spent a year teaching.
That’s why the competitive action is migrating to which features get withheld from subscription tiers and which capabilities stay API-only. The fight isn’t over raw intelligence anymore — that’s converging and commoditizing. It’s over the harness layer, because that’s where lock-in is built and where the margin eventually returns. And it’s migrating to the surface, too: if the computer is now a remote process plus a thin handle, then the runtime and the device that holds it become control points — which is why the hardware makers are suddenly racing to ship an always-on personal-agent device, not just a faster chip. Whoever owns where the agent runs, and the surface you steer it from, owns the next relationship with the user.
So here is the whole picture in one line. The model has commoditized. The frame is the human’s edge. The harness is the system’s edge. And the contest to own the harness — fought with the same logic from a solo operator’s phone to a trillion-dollar lab’s data center — is the real story of the AI industry right now. Everyone is arriving at the same realization: you don’t win by having the AI. You win by owning the harness around it, and by bringing a frame sharp enough to steer it.
The career consequence is direct. The old way rewarded lots of operators each working their own loop. The new way rewards a few people who can frame well, each steering many autonomous runs on a harness that compounds. Headcount in the operating tier shrinks; leverage concentrates in the framing tier. And the gap between a good frame and a bad one stops being measured in minutes — it’s measured in the output of the whole machine, correct versus confidently wrong, and invisible until it ships.
That’s the moment we’re in. Having the tools is table stakes. Operating them is automating. What’s left for a person is the part no model supplies for itself: the harness it runs on, and the frame you build before you let it run.
When people ask what I actually do now, the honest answer is: less, and more. Less operating — the harness handles that. More framing — which turns out to be the harder and rarer half. I live in the harness. But the harness doesn’t run on its own. It runs on the frame I bring it each morning, from wherever I happen to be standing. That’s the whole job now, and it may be the whole job for a while.
Key Takeaways & Mental Models — The Framing Models
The Framing Ladder — When a capability goes universal, the edge moves up the stack. It has now moved past operating the model to framing the work before it runs.
The Vanishing Loop — Autonomy removes the turn-by-turn iteration that let a weak first attempt get fixed. With no loop to recover in, the first frame decides the result.
Confidently Wrong at Scale — A bad frame isn’t caught; it’s executed. A small error in the frame becomes a large, polished, plausible error at the speed and volume of the machine.
Pre-Encoded Judgment — When you can’t watch every step, you have to define “good” before execution, not after. Evaluation moves from a final glance to part of the frame.
The Thin Surface — When the interface becomes intelligence, the human’s surface shrinks to two acts — frame-in and gate-out — that fit any device and lift the work off the desk.
The Frame Is the Moat — The one input that hasn’t commoditized is the structure you bring before the agent runs. Tools are universal; operating is automating; the frame is the edge that compounds.
The Harness Principles
Swarm Over Mega-Agent — Narrow specialists on independent schedules beat one generalist. Specialization is org design.
The Self-Improving Loop — Agents that read their own performance and adjust compound; static automation decays. The loop is the moat.
Shared Intelligence — One cached source of truth keeps agents coherent; independent lookups produce drift and contradiction.
Gates, Not Guardrails — ~95% autonomous on low stakes, ~5% gated on high stakes. Over-gating makes the human the bottleneck.
Memory Is Architecture — Persistent structured memory turns mistakes into rules and a tool into an operating system.
Orchestration Is the Architecture — The plumbing between 8–10 systems is the real engineering. The reasoning is the easy part now.
Harness Theory — One operator with judgment plus an agent swarm replaces a department. The human brings the frame; the harness brings velocity
With massive ♥️ Gennaro Cuofano, The Business Engineer