Agent-native software is built so that an AI agent is the primary operator and the human supervises, rather than software where a human drives an interface that happens to have AI features in it.
That is the definition with the most weight behind it. It is also, right now, one of at least six competing published definitions, and they do not describe the same thing. Some mean cloud infrastructure. Some mean applications. One means a way of organising a company. Anyone using the term in 2026 is picking a side without necessarily saying so.
This page maps the disagreement honestly, then explains the one part of it that changes engineering decisions today.
The short answer
A useful test, and the one that survives the definitional argument: can an agent do the whole job, or does it hand work back to a human halfway through?
In agent-native software the agent holds the task end to end. It can discover what actions exist, take them, read the result, and decide what to do next, because those actions are exposed through something an agent can call rather than through a screen only a person can drive. The human sets the goal, reviews the output, and owns the decision to ship.
In AI-augmented software the human still operates the tool. The AI suggests, autocompletes, summarises, or drafts, and a person clicks the buttons. The difference is not how much AI is in the product. It is who is holding the task.
Why the term exists at all
"AI-native" arrived first and described products built around models from the start rather than retrofitted. But AI-native still assumes a human operator: a person uses the AI-powered thing.
The shift that produced a second term is that agents stopped being a feature inside software and started being the ones using it. A coding agent that can open a browser, click through a signup flow, read what happened, and file the result is not a user of an AI feature. It is a user of the product. Software that expects that user looks different from software that does not: it needs callable actions, readable state, durable artefacts an agent can edit, and outputs that are legible without a screenshot.
Gartner picked the term up early, publishing "Innovation Insight: Agent-Native I&O" in February 2025, and a16z used "agent-native architecture" in a March 2025 piece on MCP. Neither is the popular origin, but both are why the term has institutional footing rather than being pure vendor coinage.
The six definitions, and who holds each
This is the part most explainers skip. The term is genuinely contested, and knowing which sense someone means is the difference between a useful conversation and two people talking past each other.
| Sense | What it means | Who argues it |
|---|---|---|
| Infrastructure | Cloud primitives designed for agents to run on and call, rather than for humans to click through | Google Cloud's "Cloud Infrastructure in the Agent-Native Era"; Alibaba Cloud's Agent-Native Cloud suite; Railway; Daytona |
| Applications | Products where humans and agents operate the same surface through shared actions, data and permissions | Builder.io, which also publishes an open-source framework of the name |
| Architecture | A system design where agents, not applications or APIs, are the primary unit of construction | Every.to; several 2026 technical write-ups |
| Development process | A way of building software where autonomous agents handle multi-step work from a high-level instruction | Factory, which uses "Agent-Native Software Development" as its own descriptor |
| Organisational design | Restructuring a company around agents as individual contributors | General Intelligence Company and similar essays |
| Labour model | The agent is the worker; the person is the reviewer and the signer | ChatFin and adjacent finance-tooling writing |
The infrastructure sense currently has the most weight behind it, because the hyperscalers are the loudest voices using the term. The applications sense has the best-developed public artefacts. Neither is about quality or testing, which is why a search for the bare term returns cloud and app-building results.
Where the definitions genuinely conflict: on whether agent-native software has a human interface at all. Builder.io's version explicitly includes one, on the grounds that humans and agents should operate the same product. Other published definitions describe software operated by agents with no human interaction. Those are not variations in emphasis, they are opposite claims, and a term that can mean both is not yet doing precise work.
The honest caveat
The term is young and its usage is not settled. It first appeared in public developer conversation around April 2025 and is still a small fraction of the volume of "agentic". Two companies that use the term have already published that it is being diluted: one described it as "becoming the new 'AI-powered', a term that sounds meaningful until you realise everyone is using it to mean something slightly different," and another opened its own definitional section by conceding the phrase "has been beaten into uselessness already."
We use the term, so treat that as a disclosure rather than a neutral observation. It is worth using because the underlying distinction is real and load-bearing. It is worth using carefully because the word alone will not carry the meaning for you.
What actually changes when software is agent-native
Four properties separate it from a human tool with AI bolted on. They are checkable, which matters more than the label.
Actions are callable, not clickable. The capabilities are exposed through a protocol an agent can invoke, most commonly the Model Context Protocol, or through a CLI and agent skills. If the only way to do something is to click it, an agent cannot do it, whatever the marketing says.
Artefacts are files, not database rows. The thing the agent produces has to live somewhere the agent can read back, diff, and edit. A record inside a vendor's console is not editable by an agent in any meaningful way. A file in a repository is.
State is readable. The agent has to be able to check what happened. This is the property most often missing: a tool will let an agent trigger an action but return a result only a human dashboard renders.
The human gate is explicit and late. Supervision is part of every serious definition, so the question is not whether a human is involved but where. Agent-native systems put the human at review and approval, not in the middle of the loop being asked to click "next".
What it means for testing
This is the sense we work in, and it is the one the general definitions do not address.
End-to-end testing has always had an unusual property: the expensive part was never running the tests, it was writing and maintaining them. Selector-bound test code breaks when the UI changes, so a suite decays unless someone tends it. Teams have historically solved that with headcount, either their own QA engineers or an outsourced service.
An agent-native testing platform changes who does that work. If the agent can drive a real browser, read what the page actually did, write a test as a file in your repository, run it, diagnose a failure, and repair it, then authoring and maintenance stop being a staffing question. The human's job moves to reviewing what the agent wrote, which is reading, not typing.
The distinction from an AI-augmented testing tool is concrete:
- AI-augmented: you open a console, click record, the AI suggests selectors, and the tests live in the vendor's database. A person drives every step; the AI makes each step faster.
- Agent-native: your coding agent walks the app, writes the tests as readable files in your repository, runs them, and fixes them when they break. You review the diff.
Both can honestly say they use AI. Only one of them can run without a person at the wheel.
For the full version of this applied to quality specifically, see agent-native autonomous QA. For the adjacent term and where the two differ, see what is agentic QA testing.
How to evaluate a tool that claims the label
Gartner named the failure mode "agent washing": vendors describing products as agentic or agent-native without the underlying capability. Its research line estimated that only a small fraction of vendors claiming agentic capability were genuinely building agentic systems. The label is therefore worth nothing on its own. Five questions that are worth something:
- Can my agent call it? Ask for the MCP server, the CLI, or the skill. If the answer is a dashboard walkthrough, that is the answer.
- Where does the output live? If the artefact is in the vendor's cloud rather than your repository, your agent cannot maintain it and neither can you without them.
- Can the agent read the result? Triggering an action is half a loop. Closing the loop needs a readable outcome.
- What happens when it fails? An agent-native system diagnoses and proposes a fix. An AI-augmented one surfaces a red mark for a human to interpret.
- Where is the human? If the answer is "in the middle, approving each step", the agent is not the operator, whatever the homepage says.
Where Shiplight sits
Shiplight is the agent-native testing platform, and by the checks above rather than by assertion.
It installs into your coding agent as a browser MCP server plus skills, so Claude Code, Cursor, Codex and others can call it directly. The agent walks your application in a real browser, writes end-to-end tests as readable YAML in your own git repository, runs them, and repairs them when the UI changes. Failures come back as a diagnosis and a proposed fix rather than a red mark, and when the application itself is broken it reports the bug instead of editing the test to pass. In CI it will diagnose a failure, apply the fix, rerun, and open a pull request, and it never auto-merges.
The human gate is real and deliberate: the tests are plain-language YAML you read and change like a spec, and nothing ships without you.
Two honest limits. Authoring runs through your coding agent's own subscription and needs no Shiplight account, but executing a test file needs an LLM key, ours or your own. And Shiplight is built for web applications, so if your critical flows are native mobile or desktop, this is not the tool for that part of your estate.
FAQ
What does agent-native mean?
Agent-native means software built so an AI agent is the primary operator and the human supervises, rather than software a human drives that has AI features inside it. The practical test is whether an agent can complete a whole task, which requires callable actions, editable artefacts, and readable results.
What is the difference between agent-native and AI-native?
AI-native describes software built around models from the start, but it still assumes a human operator. Agent-native changes who the operator is: the agent uses the product and the human reviews the outcome. A product can be AI-native without being agent-native, and most are.
Is agent-native the same as agentic?
No. "Agentic" describes behaviour, meaning a system that plans and acts with some autonomy. "Agent-native" describes architecture, meaning software designed to be operated by such a system. An agentic feature can sit inside a tool that is not agent-native at all, which is why the words are not interchangeable even though vendors often use them as if they were.
Who coined the term agent-native?
There is no single coiner. Gartner published "Innovation Insight: Agent-Native I&O" in February 2025 and a16z used "agent-native architecture" in March 2025, which are the earliest institutional uses. The term spread through developer writing during 2025 and 2026 and now carries several competing meanings.
Is agent-native just marketing?
Partly, and it is worth being candid about that. Gartner named "agent washing" precisely because vendors adopt the language faster than the capability. The underlying distinction is real and testable, so judge tools by the five questions above rather than by the label on the homepage.
What makes a testing tool agent-native?
That the coding agent, not a person in a console, authors and maintains the tests: it drives a real browser, writes tests as files in your repository, runs them, and repairs them when the UI changes, with the human reviewing rather than operating. See agent-native autonomous QA for the full treatment.
