Blog post
Headless first, and why an agent is an ordinary caller
Every application here is an API before it is a screen, and several of them never grow one.
By Ruben Achterberg · Staff engineer, application runtime · 24 June 2026 · 7 min read
An application here is an HTTP interface with named operations behind it, and that is the whole of what it is required to be. A screen is something some applications additionally have; several of the most useful ones never grow one.
This is stated as a category rather than as a stage. An application is not "headless until we get to the UI" — it is headless, and a console in front of it is a separate thing built somewhere else, on its own release cadence. That separation is why a change to a screen never rebuilds an application, and why an application's contract cannot quietly become "whatever the screen happens to call".
The argument for that order
Three reasons, in increasing order of how much they actually matter.
The valuable runs have nobody watching. The nightly reconciliation at 02:00, the weekly route scoring that fires when the depot feed lands — these are the work. A design that starts from a screen treats the unattended case as an afterthought, and the unattended case is the majority of the value.
A contract you can read is a contract you can trust. GET /operations tells you what an
application can be asked and what each operation expects, from the application itself, at runtime.
That is a discovery mechanism rather than a document that drifts.
A screen is an opinion; an operation is something it can do. Two teams will want different screens over the same analysis and both will be right. Neither of them should be able to change what the analysis does by disagreeing about a layout.
An agent is an ordinary caller
The consequence people find surprising is that an automated caller — a script, a workflow tool, an AI agent acting for somebody — is not a special integration path. It is the same path.
It signs in, asks for a dispatch token, calls an operation, polls a job, reads the result. There is no separate agent API, no reduced surface and no elevated one. An agent can do what a person can do, because what a person does is call the same operations through a screen that calls them on their behalf.
That falls out of the design rather than being built for it. Discovery answers what an application can be asked; the operation contract says what each one takes; the job model gives a long task a handle that survives a dropped connection. Those are exactly the three things a caller that runs on its own needs, and they are there because a nightly scheduler needed them first.
What we do not claim
Two clarifications, because this is the area where vendor pages get loose.
There is no shipped agent protocol adapter. The shape of this platform maps unusually cleanly onto the interoperability protocols being standardised for agent-to-agent work — an application is an agent, an operation is a skill, discovery is a card, a submitted job is a task, a written output is an artifact — and that mapping is genuinely close rather than a marketing analogy. But it is a mapping, not a product feature. Nothing ships today that speaks one of those protocols, and if that changes it will be announced as a thing you can call rather than as a diagram.
And there is nothing that runs on its own on our side. Applications do not decide to run. Nothing here watches your data and acts; the platform has no scheduler and no triggers. Every run in the system happened because something outside it made a call.
What this asks of you
Design your integration as an integration. Whatever calls the application — a scheduler, a workflow tool, a person's console, an agent — is a client holding a short-lived token, submitting operations and reading results out of your own store.
If you build that first, a screen later is additive. If you build a screen first and reach for the API afterwards, you will discover which parts of the analysis only exist inside a click handler, which is a discovery best made early.
The figures in this piece — including the ones in the panels — are illustrative. They show what a result of this shape looks like, not a measurement of anything that happened.