I. Will the harness disappear?
The Claude Code team at Anthropic recently deleted over 80% of its system prompt for the newest models: rules and examples once needed to keep earlier models on track, gone with no measurable loss on evaluations.
The thing that shrank has a name: the harness, and if you have ever used an agent, you have used one. Everything outside the model is the harness: the loop, the tools, the memory, the prompts. It is what extends a model into an agent that completes real-world tasks. In one line:
Agent = Model + Harness
And the deletion is a pattern, not a one-off: the models keep getting stronger, and every release absorbs a piece of the harness that came before it. The conclusion seems obvious: keep this up and the harness disappears. So, will it?
My answer is no. What a stronger model does is not eliminate the harness but redraw its boundary at both ends: the boundary sits at whatever the model cannot yet do on its own, and the harness exists precisely to cover that.
While models were absorbing instructions, the harness was growing capabilities of its own: memory, sub-agents, skills. Each time the model internalizes something, the harness reaches further out. The layer is not shrinking. It is moving outward, and it will keep doing that for as long as there are tasks a model cannot finish alone, which is to say, roughly, until AGI. I can accept that retirement date.
II. The vertical gap
From coding to knowledge work, the penetration was free
Not long after I started using Claude Code, I noticed it was good at things that had nothing to do with code: research, reports, slides, maybe combining them all. So did the market. With hindsight the pioneer was Manus, which through careful harness work delivered a real jump in agent capability on much smaller models. In late 2025, OpenClaw and Hermes set off the personal-agent wave on a short ingredient list: IM channels as the interface, persistent memory, cron jobs, local files and tools. Then the labs productized it with Claude Cowork and Codex for Work; by Anthropic’s mid-2026 numbers, over 90% of Cowork sessions have nothing to do with software development.
Knowledge work did not need a brand-new harness, because from where the agent sits, the environment (what it can see, what it can do, and how anyone can tell whether it worked) barely changed. A research report, a spreadsheet analysis, a slide deck: the context still comes from local files, tools and skills plug in the same way (and some, web search above all, serve both kinds of work), and the output is a file a person can check on the spot, the same way code is checked. Much the same harness, in much the same environment, took on a different job; the step happened almost by itself.
The next step, measured twice
Everybody knows this intelligence will spread into real businesses in every industry. But when it comes to the harness for industry work, there is a contrast worth a look, from Artificial Analysis, measured on the same model and the same harness.
The good: GDPval-AA v2, 220 tasks from 44 occupations across 9 major industries. Industry work, but simplified into the shape the harness grew up in: reference files in a sandbox, a deliverable out (a document, a spreadsheet, a slide deck), a judge reading it on the spot. Scored blind against human expert work anchored at 1,000 Elo, Claude Fable 5 reaches 1,738: by this measure, the model already does industry work better than the human expert.
The bad: EnterpriseOps-Gym-AA, a ServiceNow Research benchmark, 1,150 tasks across 8 enterprise domains. Here the work stays where it actually lives: inside a live business system, operated through the system’s own tools, graded on the final state of the databases with no partial credit. Its authors frame it as testing what most evals skip: multi-step tasks, irreversible actions, success defined by policy. The best model here is the same Claude Fable 5, and the best score is a failing one: 51.1%.
Abstract the environment away, and the agent is above the human baseline. Put the environment back, and it finishes about half.
From the benchmark to the field, take product-listing automation in e-commerce. Generating the listings, titles, descriptions, images, and short videos included, is the part the model handles with ease. Getting the work done means publishing them to each storefront, and every storefront has its own format requirements and its own way in: one exposes an API, another an MCP server, a third only yields to browser use. Nothing about the model needs to change; everything around it does.
Context, delivery, know-how, evaluation
So why does a harness that crossed from coding to knowledge work so easily not cross into industries? Four reasons.
Context. The current harness reads local files; the context of industry work lives in systems you do not own (CRM, EHR, ERP, POS). Reading them takes an MCP or API integration, a permission, and knowledge of the data itself: how it is structured, and where in those systems the right context sits.
Delivery. The current harness writes files; finishing industry work means writing into those systems, and each call has consequences: the refund went out, the goods shipped, the message reached the customer. No undo, and the right to act belongs not to the agent but, for now, to a specific employee. A footnote from CRMArena-Pro, a benchmark from Salesforce: agents do not spontaneously protect sensitive information, and prompting them to do so raises refusals while lowering accuracy.
Know-how. The current harness ships no sense of how this line of work is done well. Coding’s conventions were absorbed from millions of public repositories; an industry’s practice is written down nowhere: which checks in which order, which exceptions escalate. Without it the agent stumbles through the loop by trial, burning tokens and losing accuracy.
Evaluation. The current harness assumes feedback comes right away. In coding it comes from the compiler and the test suite; in knowledge work, easily from a person reading the file. In an industry it may not come for weeks, and sometimes it only arrives as a customer complaining about a wrong bill.
In Part III, I give my own definition of the layer that puts these four back: the vertical harness.
III. What a vertical harness is
Three layers
I picture the vertical harness as three layers.
The general layer. Everything today’s harness already is: the orchestration (loop, sub-agents, graphs), context management, memory, the mechanisms for skills and tools, model routing that lets the agent draw on different models for different tasks, scheduling (cron jobs), sandboxes, and the interface itself, a desktop app or an IM channel. This layer is largely the same from industry to industry.
The industry layer. What every agent in one industry needs:
Domain knowledge: the rules, terminology, and data structures of the trade.
Integration: the skills and MCP servers that interface with the industry’s existing systems.
Access: identity and permissions, under whose authority the agent reads and writes.
Eval: how good work is recognized, including the labeled data the industry has to annotate for itself.
Audit: the trail the industry demands afterward.
Interface, reappearing here as a variant embedded in the systems the industry already uses.
These are Part II’s four gaps made into components, plus what the industry adds on top.
Role packages. One per occupation, sitting on the industry layer. Each package carries:
Role knowledge: how this particular job is done well, the habits and best practices of the occupation.
Role skills: the concrete routines of the role, encoded and executable.
Collaboration: how the role hands work to, and takes work from, the roles around it, human or agent.
Mini-eval: the role’s own definition of done.
What goes where? Who shares it decides: what every agent needs sinks to the general layer, what every role in one industry needs sits in the middle, what only one occupation needs stays in its package. So knowledge, skills, and permissions appear at every layer, repeating in shape but not in content: a storefront’s listing rules are domain knowledge, because every role touches them; how to pace an ad budget through a holiday belongs to the media buyer alone.
Recent harness projects are already exploring along these seams. DeepSeek Harness makes everything a plugin, from tools and skills to the loop itself; that kind of flexibility makes assembling a vertical harness of your own much easier. Cloudflare OS enhances the access and permission side: agents start with nothing, humans grant resources one by one, and credentials stay with a gatekeeper that logs every read.
Two examples
Take two verticals, legal and e-commerce, as examples.
A legal harness, in this structure: the industry layer holds the firm’s domain knowledge (precedents, templates, playbooks, the legal and regulatory databases) behind conflict walls, integrations into the document and matter systems lawyers already run, access under a licensed professional’s identity with matter-level permissions, an eval built from real matters, and an audit trail a bar association would accept. On top, role packages, one per role: contract review, litigation research, M&A due diligence, and their peers. Harvey’s solution is exactly this shape. Its industry layer: a connector library of API and MCP integrations into iManage, NetDocuments, and Box; ethical walls synced from the firm’s conflict system; admin audit logs; firm precedents and playbooks indexed as grounding; its own benchmarks as the eval; and Word and Outlook add-ins, the interface living where lawyers already work. Its role layer: workflow agents and an agent builder that codify a firm’s expertise into reusable multi-step packages, plus hundreds of ready-made agents for specific practice areas. Anthropic’s open-source legal package, claude-for-legal, follows a similar structure. And Harvey’s own benchmark shows what the vertical harness buys: on its Legal Agent Benchmark, 1,200+ tasks mirroring real client matters and graded all-or-nothing, bare Claude Fable 5 tops out at 13.3%, while inside Harvey’s harness the same class of models was preferred by practicing lawyers up to 70% of the time.
An e-commerce harness fills the same layers differently. The industry layer is dominated by integration and access: OAuth into each storefront and ad account, every storefront’s format requirements encoded as skills, a budget the agent may spend, and no undo. Domain knowledge is platform rules, category taxonomy, seasonality, plus the merchant’s own brand story and operating experience. The eval can lean on scores the business already keeps: ROAS, conversion, refund rate. And the roles split the same way the work does: a listing operator runs batchable, checkable, correctable jobs; a media buyer spends real money at every step and waits days for feedback. Each gets its own package, with its own role knowledge.
Different industries will share this structure; what differs is the emphasis inside each layer.
IV. What enterprises buy
No client buys a harness. They buy an outcome, delivered and proven: the campaign that hit its ROI target, the claim resolved to a satisfied customer, the monthly books closed without error. Delivering takes a runtime; proving takes an eval.
The runtime is becoming the product
As agent tasks stretch from minutes to days and move into business settings, the runtime’s job comes into focus: keep an agent executing stably over long horizons, keep its cost under control, and keep it observable and governable while it runs.
In practice that means a set of modules now taking shape: isolated execution environments, state and checkpointing so runs can resume and be replayed, scheduling and triggers, spend caps, credential scoping, and the monitoring and audit surface where a human can watch a run and stop it. So the runtime is being productized; Anthropic’s Managed Agents is the clearest example so far, putting sandboxing, checkpointing, and credential scoping behind one API. The boundary between harness and runtime is genuinely blurry today, and many modules ship on both sides; my own working rule is that whatever an agent needs to complete a single execution of a task belongs to the harness, and whatever it needs to execute again and again, reliably and on schedule, belongs to the runtime. The loop is a commodity; keeping the loop running, safe, and stoppable is the business.
The hard part is, and will continue to be, the eval
For a vertical harness to keep improving, it needs a good eval, and a good eval needs exactly what every vertical lacks: data. Once the eval exists, the flywheel is standard: the eval scores the work, the scored work becomes data, and the data pays out twice: first it tunes the harness and the runtime, then it feeds agent RL to improve the model itself, lifting not just quality but efficiency, speed and cost.
The principle is simple. The work is not. Every vertical starts cold: the domain data is scarce, private, often privileged, and the experts who can define “correct” bill by the hour. The only way through is ground work with customers, building success cases with agents one by one, until the data and the eval compound. Slow, but worth it: whoever owns the eval owns the vertical.
The vertical harness gives intelligence an industry's structure. The runtime keeps it executing. The eval proves the work, and compounds into the moat. And what comes out the end is the only thing a client ever buys: the outcome.
After coding and knowledge work, I believe intelligence of this kind will reach every industry, via vertical harnesses. I'm building in this space, working with customers along the way. If this resonates with you, I'd love to connect.