WebRobot
App Builder · pages

Documentation · App Builder

Publishing

Drafts and published versions

An app has two manifests:

DraftPublished version
Made bySave draftPublish
Can contain problemsYes. It is saved anyway, so work is never lost.No. Publishing refuses a manifest with problems.
AgentsInline: each agent carries its own profile (profile.inline).Each agent points to an agent profile of your organization (profile.ref).
Served atpreview-<slug>.webrobot.eu<slug>.webrobot.eu and your custom domains
Seen byAdmins of the appEveryone the app lets in

Saving a draft never changes the live app. The live app changes only when you publish.

Saving a draft

Save draft stores the manifest and the canvas positions (the positions are kept next to the manifest, not in it). The platform checks only that the manifest is a VerticalApp with apiVersion: webrobot.eu/v1alpha1 and that metadata.slug is the app's slug. Problems found by the full validation are shown in App Studio but do not stop the save.

The first save creates the app for your organization. From then on the slug is yours. If another organization already uses the slug, the save fails with slug already taken.

The preview

The first save also sets up the preview address, https://preview-<slug>.webrobot.eu. It always shows the saved draft: save again to see your latest changes. A bar at the top reads Preview — draft not yet published.

The preview is not public. A visitor who is not allowed is sent to the sign-in page, which says Draft preview: sign in as an admin of the app, or open it from App Studio.

What differs from the live app:

  • Agents do not run. A run answers agent <key> has an inline profile: publish the app first.
  • Payments are off: the pages say Payments are off in the preview.
  • Webhook triggers do not answer.
  • User instances of agent templates cannot be created.
  • Data is kept apart: records, users and credits created in the preview never mix with the live app's.

What Publish does

Press Publish in App Studio. If you have unsaved changes, they are saved first. Publishing always starts from the saved draft. Then these steps run in order, with your own account, in the app's organization. The name of each step is what an error message starts with.

StepWhat happens
validateThe draft is validated. Publishing stops at the first problems (up to 5 are listed).
app toolsOnly if an agent uses the app's own tools (collections, Python slots): the platform issues the token that lets the app's agents call the app's MCP endpoint, https://<slug>.webrobot.eu/api/mcp.
agent <key>Each agent with an inline profile becomes an agent profile of your organization named <slug>-<agent key>. It is created on the first publish and updated on the next ones. Its tools are wired in: the app's MCP endpoint (each agent gets only its own tools) and the external MCP servers you declared. An agent behind a chat view is set to answer with its last message only.
team <key>Each team becomes one agent profile named <slug>-team-<team key>, built from its members.
pipelines, job <key>Data jobs with an inline pipeline are applied as a project named <slug>, a pipeline <slug>-<job key> and a job <slug>-<job key>-job. Applying again updates them by name.
api keyFirst publish only: the app gets its own API key, labelled vertical app <slug>.
credentialFirst publish only: the key is stored encrypted as a cloud credential of your organization named vertical-app-<slug>. The runtime uses it to act for this app, and for nothing else.
validate publishedThe manifest with the profile and job references is validated again.

Then the platform stores the published manifest:

  1. It checks that the app's addresses are free. If another app already answers on one of your domains, publishing fails with host <domain> is already used by another app.
  2. It increases the version number by one.
  3. It routes <slug>.webrobot.eu, preview-<slug>.webrobot.eu and your custom domains to the runtime.

The published manifest has profile: { ref: <id> } where the draft had profile: { inline: … }:

# draft
spec:
  agents:
    - key: intake
      role: main
      profile:
        inline:
          crews:
            - id: intake
              engine: agent_sdk
              model: claude-sonnet-5-5
              system_prompt: You write a pre-visit summary…
# published
spec:
  agents:
    - key: intake
      role: main
      profile: { ref: 1234 }

The draft keeps the inline profiles: that is what App Studio edits.

What you see

  • Success: Published v<N> — live on https://<slug>.webrobot.eu. The status changes to published v<N>.
  • Published, but the address could not be set up: Published v<N>, but its address <url> could not be set up: tell support. The version is stored; only the routing failed.
  • Failure: the message starts with the step, for example api key: … or agent intake: …. Nothing is published, and the version number does not change. Profiles already created or updated in earlier steps stay, and the next publish reuses them.

Other errors: save a draft first (there is no saved draft), stored draft is not valid JSON.

The runtime keeps the manifest it resolved for an address for up to 30 seconds. A new version can take that long to appear on the live address.

Who can publish

ActionRoles
Save a draft, publish an updatedeveloper, admin
First publish of an appadmin (it creates the app's API key and stores it as a credential)
Delete an appadmin
Move an app to another organizationWebRobot platform administrators only

A developer who tries the first publish gets an error that starts with api key:. Ask an admin of the organization to publish once; after that, developers can publish updates.

The app's address

A published app answers on https://<slug>.webrobot.eu. The slug is fixed when the app is first saved:

  • 3 to 40 characters;
  • lower-case letters, digits and hyphens;
  • starts with a letter and does not end with a hyphen.

Applying a co-pilot proposal to an existing app never changes its slug.

Custom domains

You can serve the app on your own domains as well.

  1. In App Studio, open All settings › App (or click the Users box) and type the domains in Customer domains, comma separated. They are stored in spec.domains.
  2. At your DNS provider, create a CNAME record for each domain pointing to <slug>.webrobot.eu.
  3. Publish.
spec:
  domains:
    - booking.example-clinic.com

At publish the domain is routed to the runtime and WebRobot requests a TLS certificate for it. The certificate is requested only when the domain already resolves to the app's address, so a missing DNS record does not use up the certificate authority's limits. If the CNAME was not in place when you published, publish again once it works.

Rules:

  • each domain must be a valid host name (see the reference);
  • domains under webrobot.eu are not custom domains and are ignored;
  • a domain can belong to only one app;
  • removing a domain from the manifest and publishing removes its route and certificate.

The panel on the right of App Studio lists each domain with the CNAME it needs.

Republishing

To change a live app, edit the draft, save it, and publish again.

WhatOn republish
Version numberGoes up by one.
Agent profilesThe same profiles are updated, nothing is duplicated. If you deleted a profile by hand, it is created again.
Agents removed from the manifestTheir profiles stay in your organization; the app stops using them.
Data jobsUpdated by name.
The app's API key and credentialKept. They are created on the first publish only.
Users, credits, records, runsKept. The app's data belongs to the slug, not to a version.
Address and custom domainsRe-applied from the new manifest.

Unpublishing and deleting

There is no separate unpublish. To take an app offline, an admin deletes it from the apps list with Delete. After confirmation:

  • the app stops being served at once, on its address, its preview and its custom domains;
  • the draft and the published manifest are removed;
  • the app's API key is revoked and its credential deleted;
  • the custom domains' routes and certificates are removed;
  • the agent profiles and pipelines it created stay in your organization.

Moving an app to another organization

WebRobot platform administrators can transfer an app to another organization. The new organization owns it from then on: it edits and publishes it, and its customers' payments go to it.

  • The old organization's app key is revoked.
  • If the app was published, it is republished at once from its draft in the new organization: new agent profiles, pipelines and API key are created there. Unpublished changes in the draft go live at that moment.
  • The agent profiles and jobs created before stay with the old organization.
  • If that republish fails, the app stays offline until someone publishes it again in App Studio.