Every other function got software that does the work. Support got software that routes the work to a human faster. This is the argument for why that ends, and why it ends at the interface rather than the API.
The last three years solved understanding. Any vendor can now classify an intent, retrieve the right document, and write a fluent, on-brand reply. That problem is finished.
And yet the tickets that cost real money — the refund, the cancellation, the address change on an order already picked — still end with a person clicking a button. The conversation layer got solved. The action layer did not move.
Understand the intent, find the answer, write the reply.
Actually complete the thing the customer asked for.
The industry's answer to action is integration. Expose your endpoints, map your objects, wire each capability one at a time, then do it again for the next capability and the next customer.
It works. It is also why these deployments are measured in quarters. Every product multiplied by every capability is a separate project, and the arithmetic never closes — which is why "agentic" vendors quietly ship with a services team attached.
Capabilities on the left, systems on the right. Each line is an engineering ticket, and it grows with both.
One layer that reads and operates the interface. It is built once, and it does not grow with your roadmap.
There is a place where every one of those actions is already possible, already permissioned, already logged, already tested: the product itself. The refund button exists. The cancel flow exists. Somebody spent a quarter getting the edge cases right.
They were built for humans, which is the only reason we ever assumed an agent could not use them. An agent that can read a real interface and operate it does not need a second copy of your business logic in API form.
The screen already knows who is allowed to press the button. Nothing new to model.
The action writes the same records it always did, through the same path your team uses.
Edge cases, validation and rollbacks were solved when the flow shipped. They stay solved.
Once an agent can perceive an app and act inside it, an interface no longer has to be designed ahead of time for every case. It can be assembled for the case in front of you — the exact control, pre-filled from live state, for this customer's problem, and nothing else.
That is the whole idea, and it is why we gave it a name. Generative resolution: the interface is generated, the action is performed, the problem is gone.
“cancel order 1423 and refund me”
Each era automated the step in front of it and left the expensive one alone. This is the first one that touches the expensive step.
Software made a human faster. Templates, routing rules, SLAs. The work stayed human, start to finish.
automated the typingSoftware answered the question. Search, then chatbots, then good ones. Anything requiring a change escalated.
automated the answerSoftware performs the action, in the product, behind a confirm gate. The ticket closes because something changed.
automates the workof common support issues resolved autonomously by 2029, on Gartner's 2025 forecast.
AI customer service by 2033, from $13B in 2024. The spend is not in question.
Deflection is not resolution. The market has started pricing the difference.
The only honest measure of a support agent is whether something in the product is different afterwards. Everything else is a deflection with better prose.
Endpoints get versioned, deprecated and gated. The refund button has been in the same place for three years because customers need it there.
An agent that finds controls by looking at pixels is a party trick. One that resolves a named element can be audited, and audited is the only version anyone will deploy.
Confirm gates, declared boundaries and a real audit trail are features customers use, not paperwork. An agent that acts without them will not get past a risk team, and should not.
If it takes a quarter to prove value, most teams never find out whether it worked. Ten minutes is not a marketing number, it is the thing that makes adoption possible.
A thesis you cannot argue against is not a thesis. These are the assumptions the whole idea rests on. If one of them breaks, we would rather find out early than defend it.
If products move to surfaces an agent cannot read, perception gets harder. We think the opposite happens — accessibility and test attributes are becoming more common, not less.
Acting carries risk that answering does not. If confirm gates and boundaries are not enough, this stays a read-only assistant and the category is smaller than we think.
Products ship daily. If a redesign breaks every trained flow, the maintenance cost eats the saving. This is the engineering problem we spend the most time on.
The helpdesks own distribution. If they build a real action layer rather than more integrations, our head start is the whole advantage — so we are spending it.
When resolution is the default, a support team stops being a room of people working a backlog and becomes a small group deciding what the agent may do, watching what it did, and handling the genuinely hard cases that deserve a person.
The queue does not get faster. It stops being the unit of work. That is the part we think is inevitable, and the reason we would rather build it than watch it happen.
We onboard a handful of design partners at a time. Bring your highest-volume request and we will show it resolving in your own app.