Agents call your software now

For forty years, the answer to "what can this software do?" was a picture: a window, a button, a menu, a settings pane. The picture was the contract. To use the software you looked at it, and to explain it you took a screenshot.

That contract is dissolving. Underneath the picture, sometimes replacing it, sits a new surface: a registry of typed, permissioned actions that a human, a model, or another piece of software can each call in its own idiom. The app stops being the thing you open and becomes a thing that agents address from outside.

We wrote a white paper about this. The short version, and what it means for anyone shipping an inference-backed product, is below.

The unit of software is the intent, not the app

An intent is a named, typed, authenticated request to change state or read it, expressed so that it is both human-utterable and machine-callable. Not "send the user a friendly note," but messaging.send(to: ContactId, body: PlainText). Once intent becomes the addressable primitive, the GUI is just one caller among several. A button click and an agent call take the same path through the same gateway. Only the rendering differs.

This is not the chatbot-in-the-corner pattern, where an assistant is bolted onto an app and mysteriously cannot do everything the app's own buttons can. That gap is an architecture failure, not a chatbot bug. When the action model is the primary surface, every caller reaches the same set of typed actions.

Why now, and not in 2016

Alexa Skills, Google Actions, and first-generation SiriKit all tried this and stalled by 2019. The missing piece was never the schema. It was a client that could reliably turn free-form language into a typed call. Large language models are that client, and three things made them load-bearing:

• Tool calling became a service-level guarantee. Function calling turned "translate language into a typed call against a declared schema" from a research problem into something you can put behind an SLA.
• MCP gave intents a wire format. Any agent can discover and call an application's capabilities over a standard protocol.
• The OS vendors shipped it. Apple's App Intents is already the largest typed-action runtime in production, across more than a billion devices.

The idea is old. The technology to make it work at scale is new, and it is new enough to rewrite the set of architectures you can actually build.

Agents are clients, not features

The design rule that falls out of this: do not build "an AI assistant" as a feature inside your product. Build a typed action surface, expose it over MCP, and let any agent be a first-class client. Yours, the user's preferred one, or a peer service's orchestrator. The application stops being a thing that has an agent inside it and becomes a thing that agents address from outside. The caller changed. The software has to change shape to match.

The seat is no longer the unit

Per-seat pricing assumed a human was the caller and that a seat was a fair proxy for value. When one human seat fronts an agent making thousands of calls a day across dozens of services, that proxy breaks. The meaningful unit is no longer the seat. It is the invocation, and how many of them you can run at once.

That is exactly why Kourier prices on concurrency, not seats. You pay for how many requests your agents run in parallel, because that is the thing an agent workload actually consumes.

Open models are the engine underneath

Here is the part the white paper implies and we will say plainly: intent-native software runs on a model doing reliable tool calling against typed schemas. The model is the engine under the whole picture. If that engine is a single closed provider, you have moved your lock-in from the application layer down to the inference layer, which is worse, because it is harder to see and harder to leave.

Kourier serves open-weight coding models behind one OpenAI-compatible endpoint:

• One surface agents already speak. Point the base URL at us, set the key, and the same OpenAI-format code runs. No custom schema to learn.
• Open weights, permissive licenses. Every model we serve has public weights. The engine under your agents is never a black box you cannot move.
• Priced for agent workloads. Concurrency, not seats.

The chat box was never the paradigm shift. The intent is. If you build for typed, addressable, permissioned actions as the primary surface of your software, then whatever caller arrives next finds an interface it can already use. We are building the open inference layer that sits underneath it.