we believe the most productive companies of the next decade will be agent-native by design — and that no company built before now could be one. this paper makes the claim checkable: a precise definition, a benchmark anyone can run, the maturity rungs inside the category, and the benchmark's first live test.
read the full research report →
the best-run companies in the world today are artifacts of the mobile and cloud era. their org charts, their software stacks, their workflows — departments owning processes, saas systems recording them, humans carrying work between both — are the optimal design for how work could be done over the past fifteen years. that's not a criticism; it's what winning looked like.
even the frontier ai labs share the constraint. anthropic operates further into the agentic era than almost anyone — more than 80 percent of the code merged into its codebase is authored by claude, by its own stated method — yet it was founded in 2021 and structured like the excellent conventional company it had to be, years before an agent workforce was possible. a company's architecture is set by what was buildable on its founding day, and until roughly last year, a company that ran on agents was not buildable at all. every organization on earth carries that as structural debt.
our hypothesis is that this dates them all: the most efficient, most productive companies of the next era will be agent-native by design — workflows built for agents end to end, agents as the workforce, humans directing and accountable. not ai added to the old structure; the structure itself rebuilt around what executes the work.
and you can tell the transition has started, because everyone is claiming it. executives assert ai does 30 to 50 percent of their company's work, methodology never published. startups raise on "agent-native" positioning while hiring hundreds of conventional operators. a handful of real numbers exist — block's shareholder letter reports its internal agent making 15 percent of production code changes nearly fully autonomously; salesforce invented a formal earnings metric for agent work, the "agentic work unit," and applies it only to the agents it sells, never to its own organization. the term itself means three different things depending on who's selling what.
so we're in the ambiguous stretch of the transition: a category of company being claimed into existence, real money raised on the claim — and no definition precise enough to test, and no test. this paper supplies both.
our previous paper (the rise of the agent-native company) put every company on a ladder of four rungs, defined by what its structure assumes:
that paper argued rung 4 is the destination. what it left open is everything this paper is about: what rung 4 means precisely enough to verify, and what maturity looks like inside it.
the rung-4 definition decomposes into four properties. each one is checkable.
agents hold roles, not tasks. a role owns an outcome end to end: a defect agent finds, fixes, and ships. the check is tracing completed work items — did an agent carry the item across every step, or did humans stitch the steps together?
that requires a hard definition of agent-executed: the agent received an objective, decomposed it, accessed the company's systems, did the work, evaluated its own output, iterated, and produced the final artifact — with zero human execution steps. humans directing, reviewing, or approving don't break it. a human performing one intermediate step does. "ai wrote 40 percent of our code" is assist share, not agent-executed share; the distinction is the whole test.
one operating system. a single shared substrate of state and context that every agent reads and writes. agents invoke each other directly. adding a function means adding a role, not buying a system.
the check: trace one unit of work across two functions and ask whether a human ferried the context. the sharpest version is a question — if every saas application were deleted tomorrow, could the agents recreate the workflows those products provided? in an agent-native company the answer is yes, because the company's logic lives in the agent os, not inside the saas.
output decoupled from headcount. over a trailing window, output grows and headcount doesn't — and the marginal unit of output is priced in compute, not payroll.
humans direct, review, and are accountable — never a step. count the workflows where a human is an execution step rather than a reviewer or approver. the agent-native target is zero by design.
nine measures, all readable from a company's own systems of record. no instrument like this exists today — the maturity models in circulation count agents, grade demos, or check governance boxes; none measures the work. so this is our proposed one.
| # | measure | what it reads |
|---|---|---|
| 1 | agent work share | % of completed work items agent-executed end to end |
| 2 | human intervention rate | % of completed work where a human performed a step of the work themselves — not directing it, not reviewing it, not approving it, but doing it. direction and review are counted separately, because they are the human's actual job |
| 3 | initiative share | % of completed work that originated from something an agent noticed, not something a person assigned |
| 4 | wall count | places where a human carries context between systems by hand |
| 5 | headcount elasticity | output growth against headcount growth |
| 6 | marginal cost mix | compute vs payroll in the cost of the next unit of output |
| 7 | reorg cost | the time to stand up or reshape a function — minutes of configuration, or quarters of re-org |
| 8 | function autonomy | every business function graded on the five-step scale below |
| 9 | organizational time horizon | how long a task agents complete reliably — across company operations, not just coding |
function autonomy uses named grades, per function:
manual (humans execute) → assisted (ai helps humans) → task (ai executes individual tasks) → workflow (ai executes complete workflows) → standing (ai runs recurring workflows as a job, unprompted) → self-directed (ai identifies and executes work from objectives).
the jump that matters most is the last one: from "produce the weekly report every monday" to "grow qualified acquisition" — where the agent decides what work needs to happen.
for companies that can't be audited from outside, four public proxies: what roles they post, whether agent-supervision titles exist, whether pricing is per outcome or per seat, and the build test — idea to shipped product, how many people, how long.
rung 4 isn't a binary, and treating it as one is how every current claim escapes scrutiny. underneath it are two axes — coverage (how much of the company runs on the agent os) and autonomy (what humans still touch) — and the ladder is the diagonal through them.
| sub-rung | what it is | the test |
|---|---|---|
| 4.0 agent-native function | one function runs agent-native; the rest of the company is conventional | that function passes the test above; the company doesn't |
| 4.1 agent-native operation | all core functions on one os; humans review every consequential action | the test passes company-wide, functions at workflow grade or above |
| 4.2 agent-managed | agents coordinate agents; humans review exceptions and set policy | coordination itself is agent work; human touch measured in exceptions |
| 4.3 agent-run enterprise | the os runs a customer-facing company at scale | the full test at enterprise scale, under external audit |
4.0 is demonstrated. 4.1 is possible today — our research found no clear examples yet. 4.2 is theoretically possible now, but with nobody demonstrated at 4.1 and open questions like legal accountability for autonomous decisions, realistically 2027. 4.3 is technically conceivable and would be reckless today — no audit standard, no legal precedent — estimate 2028 and beyond.
applying the public-evidence proxies to the strongest candidates:
| company | evidence supports | the evidence |
|---|---|---|
| anthropic | 4.0 — engineering | >80% of merged production code authored by claude, method stated; 8x code per engineer vs 2024. the clearest verified 4.0 anywhere |
| block | 3 → 4.0 | its agent makes 15% of production code changes nearly fully autonomously; ai reviews >90% of change requests — engineering-scoped, disclosed in an investor letter |
| basis | 3 | sells accounting agents and runs an internal team building agents across its own operations — the design pattern is right, but its job postings read like a conventional software company's, and no operating numbers are published |
| the anthropic–blackstone–goldman services venture | watch | a $1.5b services firm incorporated this year to run client work on agents from day one — the purest test of "build it that way"; nothing disclosed yet |
the finding is the pattern: above 4.0, the ladder is empty as measured — occupied only as claimed. the two companies with real numbers are function-scoped to engineering — and even the leaders are agent-native in a function, not agent-run as companies: anthropic's other functions may lean the same way, but nobody would claim its hr runs on agents. same for block. the companies structurally built for more publish nothing yet. and what would move any of them up is always the same three disclosures nobody makes: a work-share metric applied org-wide, an intervention rate, and agent supervision on the org chart.
here is the claim this paper actually wants to defend: a fully agent-native operation — 4.1 — is buildable today, at small scale. not projected. buildable now, with current models.
what makes it possible is not a smarter agent. some people think the constraint is that ai isn't here yet. it is. what isn't here is the operating-system redesign — and that part is still deeply experimental. the os is one substrate where the work, the context, and the record live together:
this architecture is why the rung-3 company can't get here by adding agents: its work graph is scattered across a dozen saas silos built for human hands, so its agents spend their day logging in, translating, and waiting.
be clear-eyed about what 4.1 costs, though. you either start from the ground up or blow up your existing structure — every workflow changes, and every person in one works differently. even going from 4.0 to 4.1 is hard: making engineering agent-native is one thing; putting hr into the same operating system means personnel data now lives in the substrate everything shares, and the boundaries protecting it — who sees what, what reaches production unapproved — are enforced by ai, not a settings page in workday or sap. who even owns the os itself, end to end? these risk and leakage questions are exactly why large companies keep their functions walled apart, and they deserve their own paper; we'll return to them.
the payoff of the architecture, for this paper, is measurability: an agent-native company can measure itself because the os already holds the data. what share of work agents executed, who originated each item, where humans intervened — those are queries against systems of record, not surveys. a conventional company can't produce these numbers without months of instrumentation. that asymmetry is itself a test.
nobody has published a benchmark for 4.1 — for what it measurably means to be an agent-native company. so we're proposing one. each criterion is stated so another company can score itself from its own systems of record, over a defined window of at least one month with a longer trend series behind it.
| criterion | threshold | how it's measured | why this line |
|---|---|---|---|
| agent work share | > 50% of completed work items agent-executed end to end | count every work item completed in the window; classify each against the hard definition in section 03; validate the classification on a random hand-labeled sample and report the error bars | below a majority, agents assist a human workforce; above it, humans direct an agent one |
| human intervention rate | < 30% of completed work items contain a human execution step | from the same labeled sample, count items where a human did part of the work — and count separately the items whose records don't say who performed a step outside the tracked systems (a console click, a tap on a phone). report both: the confirmed rate and the worst case | an agent that needs a human mid-loop hasn't replaced the loop |
| standing responsibilities | ≥ 1 per core function — recurring workflows that fire on schedules or events, unprompted | enumerate the scheduled jobs and event triggers that ran in the window; each must have produced its output without a human initiating it | a workforce has jobs, not sessions |
| function autonomy | every core operating function at workflow grade or above; none at manual | grade each function on the named scale in section 04, with one line of evidence per grade | one brilliant function is 4.0; 4.1 is the company |
| human role | zero standing workflows with a human execution step — exceptions enumerated | walk every recurring workflow end to end; list each place a human executes rather than directs or approves | the definition's fourth property, enforced |
| duration | all thresholds hold for ≥ 4 consecutive weeks, consistent with a ≥ 12-week trend | re-run the same scripts over the trend series; discontinuities explained | anything can be staged for a demo |
nobody has published numbers against anything like this. and there's a simpler test hiding in it: drop this benchmark into your company's agent harness and ask it to set up the evals, run the analysis, and report the results. if it can't, you're not 4.1 — the data isn't in one system.
so, as the testing ground, we ran it on the one company whose systems of record we hold — ours.
we ran the benchmark on our own operation — a one-person company, started in march 2026, running two consumer products in beta — over the four weeks of july 20 to august 16, 2026, against a 21-week trend series reaching back to the company's first weeks. definitions were pinned before measurement; every number comes from a committed script reading the work tracker, the version-control history, and billing records; classification was validated against a hand-labeled sample of 60 work items, and the error bars are published.
against the benchmark:
| criterion | threshold | our reading | grade |
|---|---|---|---|
| agent work share | > 50% | 98.3% of 1,777 completed items [91.7% conservative¹] | exceptional |
| human intervention rate | < 30% | 8.3% — five of the sixty sampled items involved, or may have involved, a human doing part of the work². only one is confirmed (a purchase the founder had to make on a phone to reproduce a defect); we report the higher figure because the other four cannot be ruled out. the human's 3,868 messages in the window were direction and review: ~48 agent actions per human sentence | exceptional |
| standing responsibilities | ≥ 1 per core function | 68 scheduled jobs + 4 event triggers, enumerated, spanning every core function | pass |
| function autonomy | core functions at workflow+ | engineering self-directed · it infrastructure standing · finance ops standing · product workflow | pass |
| human role | zero standing human execution steps | 2 places remain where a human carries context by hand; 1 confirmed human execution step in the 60-item sample | pass |
| duration | 4 weeks + trend | the measurement window is 4 weeks, but the operation isn't — the company has run this way since march, and the 21-week trend series holds the thresholds throughout | pass |
| organizational time horizon | (reported, not thresholded) | of the sampled work, agents completed ~90% regardless of size — from 15-minute fixes to jobs equivalent to ~3 days of human work. but that's measured on work we chose to give them; we don't yet hand agents multi-day tasks and walk away, so the true horizon is untested past 3 days | borderline |
¹ the conservative reading charges every step the record doesn't attribute — a console click, a device tap — to a human, even where an agent likely performed it.
² we report the ceiling, not the floor. human execution is visible only through the artifacts it leaves, and the human's least-recorded actions — signing into a console, tapping a phone, reading a screen — are exactly the ones nothing logs, so an unattributed step is counted against us. confirmed rate: 1.7%. separately, of 25 sampled code changes not attributed to an agent, none were written by a person. mid-run check-ins ("what's happening here?") are direction, counted in the 3,868 — not execution. the gap is an instrumentation gap, and closing it — logging the out-of-system actions a human takes — is now tracked work; the next reading of this measure will not need a ceiling.
score: 4.1. not higher — and the function census is why:
five readings from the tables:
an agent-native company comes down to one thing: an operating system where the work, the context, the record, and the execution all live together — agents as the workforce on top of it, humans directing and accountable. we believe that's the design the best companies of the next era will share. and as of today, we can find no organization anywhere that has demonstrated it with numbers that can be checked.
so here we are. who knows — maybe we're the first.
p.s. — now to get some customers.