You built it.
We’ll put it online.

Apply for private beta → See the deployment flow
Private beta

A coding agent should not stop when the code works locally. It should stop when the application works on a real domain.

The problem

AI can write the app.
Shipping it is still fragmented.

A generated application is not a deployed product. Someone still has to configure infrastructure, manage secrets, build a container, route a domain, issue TLS, read logs, repair failures — and check that the public application actually works.

Coding agents stop at one of three false finish lines:

  1. The code compiles.No runtime, no dependencies resolved against a real image, no port bound.
  2. The app works on localhost.No TLS, no domain, no second user.
  3. A deploy command returned success.Exit code zero is not a working URL. Nobody opened the page.

Everywhere else, this is your job.
Here, it is one sentence.

Same app. Same result. The only thing that changes is how much of it lands on you.

Everywhere else

11 stepsall yours

  1. 1Make an account
  2. 2Install their command-line tool
  3. 3Write a config file
  4. 4Tell it how to build your app
  5. 5Add your passwords and keys
  6. 6Set up a health check
  7. 7Point a web address at it
  8. 8Push, and wait
  9. 9It fails
  10. 10Read the log and work out why
  11. 11Change something and try again

Here

1 sentencethen nothing

put my app online

nothing for you to do

Live. your-app.rightside.host

How it works

From repository to real URL,
through the agent you already use.

Five stages. The agent drives all of them; you approve the ones that matter.

1.0 — Connect

Authorize the device once

Install the CLI with curl -fsSL https://get.rightside.host/install | sh. It downloads a checksum-pinned build, registers the RightSide MCP server for Claude Code or Codex, and asks you to approve the device in your browser. Credentials land in a protected local file — never pasted into the conversation, never returned in tool output.

The installer supports Linux x64, WSL2 x64 and Apple-silicon Mac. See supported systems and limits.

2.0 — Ask

Say it in the conversation

No new syntax to learn and no console to switch to. The agent already has the repository open; it now also has somewhere to put it.

“Deploy this application. Fix any deployment errors and do not stop until the HTTPS URL works.”
3.0 — Provision

Foundations, as one workflow

RightSide creates the project, builds an immutable release, runs it in an isolated container on a separate runtime host, and gives it a generated domain, routing and an HTTPS endpoint. Database-free by default.

Not six dashboards. One call, one release, one URL.

4.0 — Repair

Failures the agent can act on

Every failure carries the stage it failed at, a stable error code, redacted context and a suggested fix. The agent changes the application and retries — instead of handing you an opaque log dump.

code  DOCKERFILE_MISSING
stage validate
fix   Create a Dockerfile in the project root. It must make the app listen on 0.0.0.0:$PORT.
5.0 — Verify

Open the URL before calling it done

A successful deployment returns the version, the status and the real HTTPS address. The release goes live only after its health check passes, and the agent probes the public endpoint before it reports completion — because a returned URL string is not the same thing as a working application.

Features

What a project gets.

Agent-native operations

MCP tools and a CLI designed for Claude Code and Codex — stable exit codes, machine-readable output, retry-safe operations, so a retrying agent cannot create a second project or build a second release.

Database-free by default

No database is created unless you ask for one, so a deploy never quietly provisions storage you did not plan for. The private beta suits sites, APIs and tools that keep no data of their own.

An Apps Console in the browser

See every app, its live URL, its releases and its deployment status at app.rightside.host. The work still happens through the agent; the console is where you check on it.

Immutable, versioned releases

Every deployment is a numbered release. Roll back to any retained healthy release (the active one plus the 4 before it); the active release only changes once the new one passes its health check.

Structured, repairable failures

Every failure carries the stage it failed at, a stable error code, redacted context and a suggested fix the agent can act on.

Redacted build and runtime logs

Tokens, passwords and connection strings are stripped before a log reaches the agent — debugging never leaks a secret into a model context window.

A generated HTTPS domain

Routing and TLS provisioned with the project. The deployment is not reported complete until that address answers.

Verified go-live

The agent probes the public endpoint before it reports completion — a returned URL string is not the same thing as a working application.

Generated code is untrusted by design

The control plane and the runtime are separate machines. Containers run non-root with dropped capabilities on internal networks, every project gets its own credentials, and secrets are stripped from every log and error before they leave the platform.

0109
FAQ

Questions worth answering plainly.

Is this another AI coding agent?
No. You keep using Claude Code or Codex. RightSide is the deployment and runtime layer that the agent operates — it writes no code and makes no product decisions.
Does the agent get my infrastructure credentials?
No. Login is a browser device-code flow, and the token lives in protected local storage. It is never pasted into the conversation and never returned in tool output.
What can it deploy?
The first version targets Dockerfile-based web applications that listen on the injected port and expose an HTTP health endpoint. If a project has no Dockerfile, the deploy fails at the validate stage with a fix the agent can act on.
Does it host databases?
Not in the private beta. Projects are database-free by default, so the private beta suits sites, APIs and tools that keep no data of their own. Persistent per-project data is a later milestone.
Can I use my own domain?
Generated HTTPS domains are the initial path. Custom-domain onboarding comes after the private-beta deployment flow is stable.
Is there a dashboard?
Yes. The Apps Console at https://app.rightside.host shows your apps, their live URLs, releases and deployment status. Deployment work itself still happens through the agent.
Is it ready for public production workloads?
Not as a blanket claim. RightSide is running for approved internal and invited use. Public signup and external beta access are not open. Production requirements are reviewed per workload during access.

Stop at the URL that works.

Join the private beta →
Private beta

Bring one application.
Let the agent take it live.

A small private beta for founders and developers already building with Claude Code or Codex. Workload fit is reviewed together during access.

No payment details. We reply by hand.