Vibe/Nexus

Nexus · Vibe

Ship it where your
agents already live.

Vibe is the deploy surface built into Nexus. Create an app, push code, and the platform builds it, runs it, health-checks it and serves it — on your own domain, over HTTPS, with a certificate it issues for you.

nothing → live
nexus apps create checkout-api --public
nexus apps provision-repo <appId>
git push   # builds, deploys, goes live
  • One identity Your Nexus org. No second account, no second login.
  • Blue/green The new version takes traffic only once it answers.
  • Your domain One DNS record, then a certificate issued for you.

How it works

Five steps. Four of them are the platform's.

  1. 01

    Create the app

    One command. The platform stamps the canonical URL and the deploy branch, and decides nothing else for you.

  2. 02

    Get a repo

    Vibe provisions a git project on your org's own git host and hands you the remote plus a push credential scoped to that one project. There is no third-party account in this step.

  3. 03

    It builds

    A push to the deploy branch starts a build from that exact commit — never from "latest". The image is tagged by commit sha and is immutable, so one commit is never built into two different things.

  4. 04

    It deploys

    Blue/green. The platform runs the image and health-probes it on your policy — path, port, delay, interval, thresholds. The version serving now keeps every request until the new one answers. If the probe never passes, the old version simply keeps serving.

  5. 05

    It serves

    your-app.your-org.gpt.nexus from the first healthy deploy. Then your own host, beside it.

New

Your domain. Our certificate. One DNS record.

This is the part that used to mean a ticket.

  1. Attach the host

    apps domains add prints the exact record to create — one CNAME for a subdomain, A records for an apex, because an apex cannot carry a CNAME. Any DNS provider. The name printed is the full host, never @.

  2. Create the record. That is your last step.

    The platform watches DNS and the domain walks itself. If it stalls, it says why — instead of leaving you to guess.

    • PENDING_DNS
    • ISSUING_CERT
    • ACTIVE
  3. The certificate is ours to issue

    Once DNS points at the edge, the platform asks Let's Encrypt and watches the issuance through. Nothing for you to generate, upload or install — and if it cannot be issued, the domain says why rather than sitting there.

  4. Promote it when it is live

    Make the custom host canonical with one command. The platform host keeps working — nothing you have already shared breaks.

a host you own
nexus apps domains add <appId> shop.acme.com
   Type   Name            Value
   CNAME  shop.acme.com   <the edge address>

nexus apps domains verify <appId> shop.acme.com
   ACTIVE

nexus apps domains primary <appId> shop.acme.com

Capabilities

Everything it can do

Public or private, as a setting

A public app is open to anyone holding the URL. A private app demands an identity on every request: agent tool calls carry the app's edge token automatically, and a person is sent to sign in with Nexus. A client with neither gets a 401 — never a silent 404.

Your app becomes a tool your agents can call

Hand a healthy deployment its OpenAPI spec and it registers as a callable tool in the same org. The platform owns the endpoint — it is the app's own public URL, so a tool can never be pointed somewhere else by accident.

Versions, and a rollback that does not rebuild

Every deploy is a numbered version. Restore the previous one, or name an older one, and the platform re-activates the image it already has — atomic, no build, no new version spent, and the live version keeps serving until the restored one is healthy.

A human gate, when you want one

Turn on approvals and a successful build waits for a person between build and deploy. Never the person who triggered it.

A gate on the repository itself

The ship gate reads the commit for the verification artifacts you declared and refuses the deploy if they are missing or red — before a single build minute is spent. Off, warn, or enforce. Warn is the on-ramp: it reads, records and ships anyway, so you can see what enforce would have stopped.

Env vars and org credentials

Per-app environment variables, plus the access cards imported from your org — so a secret lives in one place rather than in two dashboards.

Logs you can actually read

Runtime output, oldest-first. Follow it live, filter it to one deployment slot, or keep only the lines containing a literal string.

An audit feed, append-only

Every transition is a row: deployments, approvals, rollbacks, cost-safety state changes.

A spend ceiling that acts

Cost safety refuses new deploys for an org over its ceiling, and rolls live ones back. The platform enforces it — it is not a dashboard warning.

Your own cluster

An org can provision a dedicated Vibe cluster. EU regions only — that one is deliberate.

A starter that runs on arrival

nexus apps starter my-app downloads the org app skeleton with the component library already vendored. No npm token, no registry setup, no blank page.

One CLI for all of it

Create, deploy, watch, roll back, read logs, attach a domain, set visibility, approve a gated release — one tool, authenticated as your org.

Hard parts

Honest about the things that usually go wrong

Healthy is not the same as served, so we check both

A health probe answers from inside the container; it says nothing about the edge in front of it. deploy --watch exits zero only once the deployment is healthy and the edge confirms the app is being served.

A build that dies gets exactly one retry. A build that fails does not.

If an attempt ends with no verdict — its lease lapsed, its executor faulted — it runs again. If it failed on its own merits, running it again would fail the same way, so it does not.

A deployment judges the commit it was started from

Not the branch head, not the latest push. Every verdict about a deployment reads its own trigger commit, which is why that deployment means the same thing an hour later.

Why inside Nexus

The git host is not the point.

Shipping a small service to an outside host costs you the loop that made Nexus worth using.

Outside Inside Vibe
A second account and a second login Your Nexus org identity
Secrets in two dashboards One secret store
Wire the deployed app up as a tool by hand One command, pointed at its own URL
Traces stop at the boundary One trace, end to end
A second bill One bill

Plenty of git hosts exist. The point is that the thing you just shipped is a first-class citizen of your agent runtime the moment it is healthy.