The Task Economy: Inside the Trillion-Dollar Market Where Work Becomes a SKU

Cold open

One task, three prices, one afternoon

Here is a task: reconcile 400 supplier invoices against purchase orders and flag mismatches. Nothing exotic; some version of it runs in every company on earth. Now price it three ways, the way a buyer in 2026 actually can.

Priced as employment, it's about six hours of an accounts-payable specialist's day. At a fully loaded cost near $38 an hour, the task costs roughly $230, invisible inside a salary line. Priced as a gig, a freelance bookkeeper quotes a flat $95 and turns it around by tomorrow. Priced as an agent run, a loop with a verification gate completes it in 22 minutes for about $2: a dollar and change of tokens plus a few cents of automated checking, the arithmetic we walked through in The Cost of a Loop.

Same 400 invoices. Same output file. Three prices spanning two orders of magnitude, quoted in one afternoon. When the identical unit of output trades at $230, $95, and $2 simultaneously, you are not looking at a productivity story. You are looking at the birth of a market, the moment work acquires a spot price. Everything in this article follows from taking that moment seriously.

Part I · The pattern

The Great Re-Denomination: a century of shrinking units

Markets get bigger when their units get smaller. It's one of the most reliable patterns in economic history, and work has been living it for a hundred years. The career gave way to the job: employment became something you change, and labor markets deepened. The job gave way to the gig: platforms decomposed employment into projects and shifts, and the World Bank now counts between 154 and 435 million people doing online gig work worldwide, as much as one in eight members of the global labor force. Each re-denomination looked, at the time, like a degradation of the previous unit. Each one actually created a larger, more liquid market than the one before it, because smaller units clear faster, price finer, and admit more buyers and sellers.

The task is the next denomination, and it isn't a metaphor: it's already a government data structure. The US Department of Labor's O*NET database decomposes nearly a thousand occupations into roughly nineteen thousand distinct task statements, an official catalog of what work actually consists of, sitting in the public domain [2]. Labor economists have used the task lens for two decades to explain which work technology takes and which it leaves [2][3]. What's new in 2026 is not the lens. It's that tasks became individually executable and individually priceable, because for the first time there's a worker, the agent, whose natural unit of engagement is exactly one task.

And adoption is following the theory with unusual obedience: usage data from frontier AI systems shows AI entering the economy task by task, not job by job, spreading across a growing share of occupations while rarely covering all of any single one. The job survives. Its interior gets re-priced one line at a time.

Part II · The size

Building the trillion from open data, step by step

Big-number claims about AI usually arrive as a consultant's estimate you can neither audit nor reproduce. So let's do it differently: derive the size of the task economy from statistics that sit in the public domain, state every assumption, and let you disagree with any step of the arithmetic.

Step one, the world's wage pool. Global output runs on the order of $110 trillion a year (IMF World Economic Outlook data). The International Labour Organization estimates labor's share of that income at roughly 52 percent. Multiply, and the world pays something like $55 to 60 trillion a year for human work. That is the outermost boundary of any work market.

Step two, the knowledge slice. Occupational statistics in advanced economies (the US BLS classification is the cleanest public example) put management, professional, technical, and office occupations at roughly four in ten workers, and a larger share of the wage bill because these jobs pay above average. Applied globally with appropriate haircuts for economies with smaller formal knowledge sectors, the cognitive wage pool lands in the neighborhood of $20 to 25 trillion.

Step three, the task-decomposable, digitally deliverable slice. Not all cognitive work arrives as discrete, spec-able, remotely deliverable tasks; a large share is relational, physical-adjacent, or inseparable from accountability. Take a deliberately conservative half, and the pool of work that can in principle be denominated in tasks sits around $10 to 12 trillion a year. There's your trillion-dollar market, with an order of magnitude to spare, derived in three multiplications you can check.

Step four, the moving frontier. How much of that pool is addressable by agents now? The most useful public measurement is METR's task-horizon study: the length of task that frontier models complete at 50 percent reliability has been doubling roughly every seven months, crossing from minutes into hours over 2024-2025 [5]. Independently, open evaluations of AI on real occupational deliverables find frontier systems approaching expert parity on a meaningful subset of well-specified professional tasks while still failing on long, messy, context-heavy ones [6]. Put those together and the honest statement is: single-digit trillions of the pool sit within today's horizon, and the horizon doubles roughly twice a year. The task economy isn't a forecast. It's a compounding process with a published doubling time.

Part III · The unit

Anatomy of a task: a loop with a price tag

For a unit to trade on a market it needs a standard shape, the way a shipping container needed standard corners. A tradable task has five parts, and readers of our loop series will recognize four of them immediately. A spec: what done means, written so a stranger or a machine could check it. Context: the documents, data, and access the worker needs. Execution: the work itself, by a human, an agent, or a hybrid; the market genuinely does not care which. Verification: the gate that decides whether done happened, ideally one the worker can't sweet-talk. And the fifth part, the one that turns a loop into a market: settlement. Payment released on verification, reputation updated, liability assigned.

Look at what that shape implies. A task is an agent loop with money attached, which means everything the loop literature learned about gates, budgets, and memory becomes market infrastructure. And it means the binding constraint on the task economy's growth is not model intelligence. It's the supply of good specs and cheap verification. Work doesn't enter this market when AI gets smart enough to do it. It enters when someone writes down what done means.

For builders · the protocol

The Task Envelope: work as a packet

Every economy that scaled did so by standardizing its unit. Shipping got the container, networking got the packet, and both took off for the same reason: once the envelope is standard, the infrastructure stops caring what's inside. Here is the task economy's equivalent, the envelope a developer would actually implement, shown as our cold-open task:

Read the envelope like a protocol engineer and three properties jump out. It's executor-indifferent: the same envelope routes to a human, an agent fleet, or a hybrid, which is the property that activates every market force in this article. It's self-terminating: budget and gate travel with the work, so no orchestrator has to babysit it, exactly the discipline from the loop anatomy, serialized. And it's portable: schemas outlive vendors, so the envelope, not any platform, is where interoperability lives. And like every protocol object, a task doesn't just have fields. It has a lifecycle:

Part IV · The theory

The Coase Inversion: why tasks leak out of firms

In 1937, Ronald Coase asked a question so simple it won a Nobel Prize: if markets are so efficient, why do firms exist at all? His answer: because using the market has costs, finding a supplier, negotiating, writing contracts, checking the work, and when those transaction costs exceed the cost of just managing an employee, work moves inside the firm's walls [1]. The 20th-century corporation is, in Coase's terms, a machine for avoiding transaction costs. Every org chart is a monument to how expensive it once was to buy a task from a stranger.

Now itemize those transaction costs against the anatomy above. Finding a worker: a routing decision, milliseconds. Negotiating: a posted spot price. Contracting: a spec plus a gate. Checking the work: the verification block, automated. Every line item of Coase's friction is precisely what task infrastructure automates, which yields the cleanest prediction in this article: as verification gets cheap, the boundary of the firm contracts. Tasks whose done is machine-checkable leak out of employment and into the market first; tasks wrapped in ambiguity, relationships, and accountability stay inside longest. The firm doesn't die. It shrinks to its irreducible core, the things Coase's frictions never touched: deciding what's worth doing, owning the consequences, and holding the context nobody can rent, the same conclusion our unit economics post reached from the opposite direction.

Part V · Both sides of the market

One clearinghouse, two task economies

Two groups currently use the phrase "task economy," and they appear to be describing opposite things. The first means tasks done by agents: automation, the $2 invoice run. The second means tasks done by expert humans for AI: writing the evaluations, supplying the judgment, grading the outputs, producing the demonstrations that make models better; a genuine boom, since the path to improving agents runs directly through expert human work. Automation optimists quote the first market. Skeptics quote the second as proof the machines still need us.

They're the same market, observed at different points of its flywheel. Every task an agent fails becomes, with a spec and a grade attached, a unit of the second economy: expert judgment that flows back as training signal and hardens into an eval. Every eval that hardens becomes a verification gate. Every new gate makes another task tradable in the first economy. Human task work is the R&D department of agent task work, and agent failures are its order book. A mature task exchange clears both sides with the same machinery, specs, gates, settlement, and the ratio between them is simply where a given task sits on the capability clock [5][6]. Draw them as rivals and you'll misprice both.

Part VI · Pricing physics

What a task costs, and where the price is going

Task prices obey a simple physics with three forces. The ceiling is the buyer's alternative: what the same output costs from labor ($230 in our cold open) or from not doing it at all. The floor is the seller's marginal cost: tokens, plus verification, plus a risk premium for the failure rate. And the spread between them is where every business model in this economy lives. Today that spread is grotesque, $230 against roughly $2, which is what markets look like in the quarter they're born.

Then the physics starts moving. Token prices fall on the order of tenfold per year for fixed capability [7], dragging the floor down. The capability clock [5] moves tasks from "risky" to "routine," shrinking the risk premium. Competition among sellers pushes prices from the labor ceiling toward the machine floor, task category by task category, in the same sequence the horizon unlocks them. Run it forward and the task economy's strange steady state appears: the price of any verifiable task decays toward its verification cost. Execution approaches free; proof does not. Which is the door to this article's central claim.

For builders · the gate funnel

Verification patterns: compose gates cheapest-first

The Verifier Thesis says proof is the scarce asset; here is how builders manufacture it affordably. Gates come in four families, and the craft is that they compose. Deterministic gates (schema checks, test suites, checksums, reconciliation math) cost a rounding error per check and cannot be persuaded; run them on 100 percent of volume, first. Statistical gates (rubric graders, consensus-of-N models) cost cents and catch what determinism can't see; run them on whatever survives. Economic gates (escrow, performance bonds, slashing) cost nothing until failure, then transfer the cost to the party who caused it; they don't detect bad work, they make bad work unprofitable. And human gates, expensive and final, run last, on a sample sized by stakes: 2 percent of routine tasks, 100 percent of consequential ones, the dial we introduced in the CXO post.

Sequence them and you get a funnel where volume falls and scrutiny rises at every stage, so the expensive checks only ever see the traffic that earned them. That's the whole trick: spend the tenth-of-a-cent check a million times so the five-dollar human minute is spent two thousand times, and the blended verification cost per task stays close to the floor the pricing curve demands.

Part VII · The factory

Tokens are the commodity. Tasks are the finished goods.

Zoom out and the task economy snaps onto the industrial map this blog has been drawing all along. At the base sits raw material: tokens, undifferentiated compute-hours of intelligence, deflating like every commodity input in history, the layer where affordable, well-routed inference (jusInfer) decides your input price. Above it sits the machinery: the harness, the loops, gates, context, and caches that turn raw intelligence into reliable execution, the coding-agent layer where jusCode lives and where our 11-layer map spends most of its time. And above that sits the output the customer actually buys: verified tasks, work with proof attached, the finished goods of the AI factory, the layer jusFactory is named for.

The framing earns its keep because it imports a century of manufacturing intuition intact. Nobody brags about steel consumption; they price cars. Nobody should brag about token consumption; the unit that matters is cost per verified task, the factory's true unit economics, and every layer of the harness exists to improve it. Raw material cost falls on its own schedule. Machinery efficiency is engineering. But margin, as the last section argued, concentrates at the quality gate, which is why the factory metaphor's most important station isn't the furnace or the line. It's inspection.

For builders · twin stacks

Where the task stack bolts onto the inference stack

If you've followed this blog from the 11 layers onward, here is how the two worlds join, because they are not competing maps; they are two stacks with one seam. The inference stack moves tokens: gateways, routers, caches, engines, silicon. The task stack moves work: envelopes, exchanges, verifiers, settlement. The seam is Layer 04, the orchestrator: the moment an executor claims a task envelope, that task becomes loop runs, and loop runs become the token demand we quantified in Loops Are Layer 04. Every arrow in the task stack eventually crosses that seam.

The economics flow both ways across it. Downward, the task stack is a demand engine: every settled task is a bundle of routed, cached, metered inference, which is why task volume, not chat volume, will drive the next order of magnitude of token consumption. Upward, the inference stack is a cost engine: token deflation and cache discipline set the execution floor that task prices decay toward. A builder choosing where to stand should see both stacks at once: the middle layers of the token stack meter the flow; the trust layers of the task stack price the work; and the seam between them, reliable execution, is where the two flagship theses of this blog shake hands.

Part VIII · The economist's view

Baumol's revenge, and the statistic that will miss it

In 1967 William Baumol explained why services eat an ever-growing share of your income: a string quartet takes exactly as many musician-hours as it did in Mozart's day, so sectors whose productivity can't improve see relative costs rise forever [4]. Cost disease is why education, healthcare administration, legal work, and back-office services swallowed the modern economy: they were made of tasks whose only input was human time. The task economy is, formally, the cure arriving: for the first time, the labor-time content of a vast class of service tasks is falling, not by percentages but by orders of magnitude, our $230 to $2 cold open is a 99 percent cost reduction in a Baumol-diseased task. Sixty years of one-directional drift in relative prices is starting to run in reverse, service category by service category, in the order the capability clock unlocks them.

Two footnotes an economist would insist on. First, Jevons applies to tasks even harder than to tokens: when reconciliation costs $2 instead of $230, you don't reconcile the same 400 invoices cheaper, you reconcile continuously, audit everything, and invent task categories that were never worth their labor price; measured task volume will explode faster than task prices fall. Second, GDP will systematically miss it. National accounts measure spending, and a task whose price fell 99 percent while its volume rose 40x shows up as roughly flat nominal output hiding a 40x real quantity of work performed. The task economy's early years will look, in official statistics, like nothing happening, the same statistical fog that hid the internet's consumer surplus. Watch task counts and task prices, not spend, or you'll conclude the revolution was cancelled.

Part IX · The CFO's view

Restating a department in tasks: a worked ledger

Here's what the re-denomination looks like on an actual budget line. Take an accounts-payable function processing 120,000 invoices a year, run traditionally as six full-time roles. Now restate the same function as a task portfolio: the routine three quarters flowing to gated agent runs, a fifth through human-in-the-loop review, the gnarly residue handled by specialists, with two retained experts owning specs, exceptions, and the verification gates themselves. Illustrative numbers, arithmetic on display:

Three things a CFO should notice beyond the 41 percent. The cost line became variable: a volume surge is a bigger task bill, not a hiring cycle. The unit economics became visible: $2.49 per invoice is a number you can benchmark, negotiate, and watch deflate on the token clock. And the remaining humans moved up the stack, from executing tasks to owning specs and gates, which is the department-scale version of everything in Loop Engineering for CXOs. Budgets stop being headcount plans with salaries attached and become task portfolios with quality gates attached. That's the re-denomination, on one page of your general ledger.

Part X · The worker's view

The human premium map, honestly drawn

Labor economics saw this coming before AI did. The canonical 2003 framework showed that computers substitute for routine tasks and complement non-routine ones, redistributing work rather than simply deleting it [2]; its successors formalized how automation displaces labor from existing tasks while new tasks are created in which labor holds advantage [3]. The task economy is that literature, industrialized. So the honest question for any individual is not "will AI take my job," which is malformed because jobs aren't the unit anymore, but "task by task, where does my premium survive?"

Two axes sort it cleanly. Is done machine-checkable? And how expensive is being wrong? Checkable and low-stakes: the agent takes it, at machine prices; defending these tasks is defending a wage against a $2 competitor. Checkable but high-stakes: agents execute, humans own the gate, the review economy, and gate-owners are already among the task economy's best-paid roles. Unverifiable but low-stakes: taste, tone, judgment calls; humans direct, agents draft, and the premium goes to whoever's taste customers seek out. Unverifiable and high-stakes, the top-right corner: accountability itself, the signature that means a person stands behind this, regulated sign-offs, relationships, decisions under ambiguity. That corner isn't shrinking; the Coase Inversion makes it the entire remaining definition of the firm. The strategy that falls out is unfashionable and true: climb the verification axis. Learn to write specs, design gates, and own outcomes, the skills of the loop engineer, because the premium doesn't go to whoever works hardest inside a task. It goes to whoever defines and judges the task.

Part XI · The founder's view

The toll positions of the task economy

Map this market the way we mapped the token economy's tolls and the defensible positions surface quickly, in ascending order of moat. Execution shops, selling agent-done tasks, will be numerous and thin: they sit on the deflating curve, differentiated only by their harness efficiency. Task routers earn a real spread deciding, per task, whether it goes to an agent, a hybrid, or a human specialist, the same neutrality economics as model routing, one level up. Marketplaces and settlement rails take the transaction toll: escrow conditional on verification, reputation ledgers, dispute resolution; classic network-effect businesses, winner-take-most per vertical. And at the top, verification-as-a-service: the eval suites, gates, audit trails, and certification marks that everything else depends on. The Verifier Thesis prices these positions for you: the closer to proof, the fatter and more durable the margin. If the last era's advice was own the meter, this era's is own the gate, and the deepest version of the play is the standard itself: whoever's definition of "verified" becomes the market's default owns the task economy's equivalent of the credit rating, an asset that outlasts every execution shop built on top of it.

For builders · the exchange

Reference architecture: order book + CI + escrow

Strip a task exchange to its skeleton and it's three systems developers already know, glued together. An order book holds open envelopes with posted prices, the marketplace primitive. A CI pipeline generalized into the verifier pool runs the gate funnel on every deliverable, the quality primitive. And an escrow ledger holds the buyer's funds and releases them on gate.pass, the trust primitive. Around those three: a task router matching envelopes to executors on price, capability, and reputation, and a reputation store turning every settled state machine into the statistics that feed the next routing decision. That loop, settle → score → route, is the exchange's compounding asset; everything else is replaceable plumbing.

One deployment note that matters more than any component choice: exchanges will start private. The first order book you build should clear tasks between your own departments with internal chargeback, because that's where specs, gates, and reputation can mature without adversaries. Firms that run an internal exchange well become the natural nodes when private exchanges federate into public ones, the same path corporate networks took to the internet.

For builders · the error budget of work

Yield is the new uptime

SRE gave software a mature vocabulary for imperfection: SLOs, error budgets, burn alerts. The task economy needs the identical discipline, one substitution deep: replace uptime with first-pass yield, the share of tasks that clear the gate funnel on the first attempt. A task class gets an SLO (say, 98 percent first-pass), the 2 percent gap is its error budget, and burning the budget triggers the same graduated responses an SRE would recognize: route away from the failing executor, raise the price to fund more verification, or clamp the human-review dial to 100 percent until yield recovers.

Yield also belongs in every price quote, via the one formula this section exists to install in your head: effective price = posted price ÷ first-pass yield. A $0.30 task at 95 percent yield really costs $0.316; the same task from a flashier, sloppier executor at 80 percent costs $0.375 plus the latency of retries. Cheap and low-yield is expensive; the formula is how buyers see it and how honest sellers win. And when the budget burns anyway, the dispute path assigns the cost with incentives attached: executor at fault, escrow refunds and reputation takes the hit, which funds seller self-checking; spec defect, the buyer pays the re-spec, which funds better specs. Every failure makes exactly one party invest in exactly the right fix.

Part XII · The CXO's view

The org chart becomes a task graph

Inside the firm, the re-denomination lands as an organizational identity change. A company that thinks in jobs manages people who contain tasks opaquely; a company that thinks in tasks manages a graph: nodes of work, each with a spec, a gate, a cost, and an assigned executor that might be an employee, an agent fleet, or a market. Managers stop being supervisors of hours and become portfolio owners of tasks: deciding which nodes to automate, which to buy from the market ring, which to keep on the accountability core, and watching per-node unit costs the way plant managers watch line yields. The governance kit is the one we specified in Loop Engineering for CXOs, applied at company scale: owners, budgets, gates, audit trails, and a human-review dial per node. The uncomfortable, energizing implication: your org chart is currently an undocumented, unpriced task graph. The first team to draw it explicitly, and there is no reason that team can't be yours, gets to run the Coase Inversion on purpose instead of having it run on them.

Part XIII · What can go wrong

Failure modes: how a task economy breaks

Every market this young carries its collapse modes inside it, and honesty about them is part of the map. Verification fraud is the systemic one: gates that can be gamed, agents optimizing the metric instead of the work, Goodhart's law with a settlement layer attached; one well-publicized wave of "verified" garbage could reprice trust across the whole market, which is why gate quality is a public good and not just a product feature. Race-to-the-bottom task mills replay the content-farm era at task scale: floods of cheap, technically-passing work that satisfies the letter of weak specs. Spec debt is the quiet one: firms that outsource execution but never learn to write specs discover they've outsourced their own understanding of their work. And the displacement path is real even when the destination is good: the bottom-right quadrant of the premium map employs a great many people today, and "climb the verification axis" is a strategy, not a safety net; transition support is a policy question this article can pose but not settle. Regulation, notably, cuts the other way from the usual story: rules demanding auditability, liability assignment, and human accountability for agent actions are, economically, a mandate to buy verification, a subsidy to the exact layer the Verifier Thesis says matters. The trust stack may end up being the most regulation-proof business in AI.

Part XIV · 2030

What it looks like when it's normal

Project the doubling clock [5] and the deflation curve [7] forward a few years, resisting the sci-fi temptation, and the mundane version of 2030 is strange enough. Companies publish task catalogs the way they publish APIs. Procurement negotiates cost-per-verified-task the way it negotiates cloud commitments today. A department's capacity is quoted in tasks per day with a quality attachment, elastic on demand. Job postings decompose into the quadrants of the premium map, and the best-paid line items are gate ownership and spec authorship. National statistics agencies, several years behind as always, begin publishing task-price indices because wage indices stopped describing the economy. And somewhere in every organization, a dashboard shows the three numbers this whole article reduces to: tasks completed, cost per verified task, and the human review rate, the vital signs of a firm that learned to run its own Coase Inversion. None of this requires artificial general anything. It only requires the curves on the charts above to keep doing, for four more years, what they have verifiably done for the last three.

References

The research this stands on

• Coase, 1937. The Nature of the Firm (Economica). Why firms exist: transaction costs. The task economy is what happens when those costs collapse. doi:10.1111/j.1468-0335.1937.tb00002.x
• Autor, Levy & Murnane, 2003. The Skill Content of Recent Technological Change (Quarterly Journal of Economics). The paper that made the task the unit of labor economics: machines take routine tasks and complement the rest. doi:10.1162/003355303322552801
• Acemoglu & Restrepo, 2019. Automation and New Tasks: How Technology Displaces and Reinstates Labor (Journal of Economic Perspectives). The displacement-and-reinstatement framework the premium map is built on. doi:10.1257/jep.33.2.3
• Baumol, 1967. Macroeconomics of Unbalanced Growth (American Economic Review). Cost disease: why services got relatively expensive for sixty years, and the baseline the task economy reverses. jstor.org/stable/1812111
• METR, 2025. Measuring AI Ability to Complete Long Tasks. The capability clock: the task length frontier models complete at 50 percent reliability doubles roughly every seven months. arXiv:2503.14499
• OpenAI, 2025. GDPval: Evaluating AI Model Performance on Real-World Economically Valuable Tasks. Open evaluation across occupational deliverables: near-parity on well-specified tasks, failure on long messy ones. openai.com/index/gdpval
• Stanford HAI, 2025. The AI Index Report. The deflation clock for the raw material: inference cost of fixed capability fell roughly 280x in two years. hai.stanford.edu/ai-index