The connected surface

Letting something else read and draft

The last module in the editing application is the one that lets another program work with the publication.

Studio exposes a small, deliberately-scoped interface that a compatible client can connect to. Through it, a connected assistant can read the publication and draft into it — list what exists, read an article, create a draft, revise one.

The thing I use it with is Arin OS, my own personal AI environment — the subject of two other books in this library. The value is straightforward: research and drafting happen where the material already is, and the result lands in the publication as a draft rather than being copied through three applications and losing its formatting on the way.

What it deliberately cannot do

The scope is the interesting part, and it is drawn tightly.

It cannot publish. Nothing reached through this interface can put anything on the live site. Drafting is delegated; publishing is not. A connected program can write as much as it likes and every word of it lands as a draft that the public site refuses to serve.

It cannot reach the editing application’s own controls. It is a separate listener with a separate credential. Holding a token for this interface does not give access to Studio’s settings, its lock, or its publish path.

It is not on the internet. It binds to the local machine. Reachable from another program on the same machine, or from a container on it — not from the network.

Credentials

Access requires a token, and tokens are created only from inside an unlocked Studio session. A connected program cannot mint another one — holding a token gets you the interface, not the ability to issue more.

Each token has a name, a chosen validity period, and can be revoked instantly. Revocation takes effect immediately and permanently.

The panel shows each token’s name, its state, when it expires, how many calls it has made and when it was last used — and every call is logged, successes and failures, with a timestamp. That log is the part I would keep if I had to drop everything else: an unfamiliar entry is the first sign that something is connected that should not be.

Two addresses

The panel shows two endpoints, which is a small detail with a long history of confusion behind it.

A program running directly on this machine uses one address. A program running inside a container uses a different one — because inside a container, “this machine” means the container, not the host, and a client that uses the local address there reaches itself and finds nothing.

Both addresses are shown, each labelled with which case it is for, with the explanation underneath. It is the kind of thing that costs an hour the first time and nothing ever again once the interface simply tells you.

Why this is in the book at all

Because it is the clearest example of the principle the whole system is built on. The publication is mine: the content, the addresses, the history. What assists with it — a model, an assistant, a program on the other end of an interface — is interchangeable, scoped, logged, and revocable in one click.

Own the context. Rent the intelligence.