Publishing a version you can point to

A design on the canvas is a draft. It can be changed at any time, and it is not running anywhere. The moment it becomes something the site can rely on is the moment an operator publishes it. Publishing turns a draft into a version, and a version is a thing you can point to.

What publishing does

Publishing freezes the design. Everything on the canvas and in the file at that moment, the step sequence, the bounds, the material the agent may read, the tools it may call, the placement of each waiting step, becomes a version that cannot be edited. The version has an identity. It is written down who published it and when.

From that point, the version is fixed. If the operator wants to change the agent, they change the draft and publish again, producing a new version. The earlier version does not go away. It remains available, and the site can point back to it.

A version is not live by virtue of existing. Publishing does not put the agent in front of the site's applications. It only produces the frozen thing. This separation is deliberate. An operator can publish a version in the morning, have a colleague review it, and deploy it in the afternoon. The published version waited, unchanged, in between.

Drafts, meanwhile, stay drafts. Nothing on the canvas that has not been published is reachable by any application. Work in progress is never live by accident.

What deploying does

Deploying points a stable address at a version. The address is what the site's own applications call. It does not change when the version behind it changes. An application that was built to call the claims agent at its address keeps calling that address through every version the operator publishes.

Exactly one version is live behind an address at a time. When the operator deploys a new version, the address moves from the old version to the new one. When a version turns out to be wrong, the operator points the address back at an earlier published version. The applications never notice the difference, because the address did not move. The article One live version at a time covers this rule, and Pointing the address back at an earlier version covers the recovery.

Why the two acts are separate

If publishing and deploying were one act, every change would go live the instant it was finished. There would be no way to prepare a version and hold it. There would be no clean way to go back, because going back would mean re-publishing an old design and hoping it came out the same.

Separating them gives the site three things. A published version can be inspected before it is live. The address can move between versions without anyone editing anything. And the history of what was live when is a history of where the address pointed, which is simple to record and simple to read.

Canvas and file publish together

Whether the design was last touched on the canvas by an operator or in the file by a developer, publishing produces one version. There is no separate publication for the file. The version is the one design at that moment, and both views can open it afterwards. Canvas and file are one design explains why there is never a second definition to publish.

Who may publish

Publishing is an operator act. The admin decides which operators may publish, and for which agents. This is one of the governance decisions the admin makes at the site level. A developer who prepares a change in the file does not publish it on their own authority unless the admin has given them the operator role for that agent.

Each publication is recorded with who did it. So is each deployment. A site can later answer which versions existed, who published each one, which was live at any moment, and who pointed the address there.

An operator finishes a change on the canvas. They publish, producing a new version. They or a colleague open the version and confirm the bounds and the waiting steps are right. They deploy, pointing the stable address at the new version. The site's applications keep calling the same address and now reach the new version. If something is wrong, the operator points the address back. None of this requires anyone to touch the applications that call the agent. The platform page describes how publishing and deploying sit within the appliance.