# Reliant > Reliant: build, deploy and run any app with AI agents. Reliant hosts any app: any language, any Dockerfile or container image, or a static site, with dev/staging/prod environments, releases, managed Postgres, custom domains and monitoring built in, on Reliant hosting or your own cloud. A team of AI agents (architects, designers, implementers, reviewers, SREs who answer alerts and issues) builds features and fixes what breaks, each running a workflow file in your repo. Reliant Forge is the open-source CLI that deploys it, and the stack builder those agents, or any coding agent, start a new codebase with. Reliant is free with your own API key. Reliant is a desktop app for macOS, Windows and Linux, with a web app at app.reliantlabs.io. Workflows are YAML files that chain agents, run your tests, and loop until the result passes review. ## Deploy an existing app (any language) Can Reliant host my existing app? Yes. Any language and any container: a Dockerfile (Node, Python, Ruby, Java, Go, anything), an existing container image, including third-party software, or a static Vite or Next.js app. Moving an app over takes about an hour, and in Reliant the Move to Forge workflow does it for you. The deploy is Reliant Forge's (`forge env deploy prod`; inside Reliant, `reliant forge env deploy prod`), so the app gets environments, build-once releases promoted by digest, secrets, custom domains with automatic HTTPS and managed Postgres with 7-day point-in-time recovery on an account (a no-account `--claimable` deploy has the limits under "Deploy without an account", below). Monitoring: a forge-built app reports logs, traces and metrics from the first deploy; an existing app does once it exports OpenTelemetry. Overview: https://reliantlabs.io/hosting A static Vite or Next.js app (`output: "export"`) adopts in place, with no file moved, and deploys in one command: `npx -y @reliantlabs/forge@latest env deploy prod --claimable` (forge v1.5.0 or newer; no git repository or commit needed). A server or worker with a Dockerfile is one workload declared in KCL with `forge.DockerBuild`, which runs `docker build` for any language (docs: https://docs.reliantlabs.io/forge/deploy/escape-hatches): ```python _billing = fw.Workload { name = "billing" kind = "service" image = "billing" # on Reliant hosting a bare name: forge pushes it to your organization's registry path build = forge.DockerBuild { dockerfile = "services/billing/Dockerfile" context = "services/billing" } ports = [fw.Port {name = "http", port = 8000, expose = True}] } ``` `dockerfile` is relative to the project root; `context` is the directory docker sends as `.`. On Reliant hosting a workload's image must live in the platform's registry, so give a bare name and forge pushes it there; an image naming another registry host belongs on a cluster you run. An existing image, yours or third-party, deploys the same way: a Dockerfile that is just `FROM ` (for example `FROM docker.io/library/redis:7`) under `forge.DockerBuild`, so the image is pushed into the platform registry. On a cluster you run, `image = "docker.io/library/redis:7"` with no `build` deploys it directly. A third-party image with ports gets a TCP probe on its first port. Each hosted environment gets a managed Postgres with 7-day point-in-time recovery: a dedicated database whose connection string your services receive automatically, reachable only from inside the platform, so migrations run as part of the deploy. (An unclaimed no-account database is not backed up.) To set up an existing server as a forge project, agents run `forge skill load migration`. What hosting runs, what it refuses and what it costs: https://docs.reliantlabs.io/forge/hosting and https://reliantlabs.io/llms-full.txt ## Deploy without an account Any coding agent that can run a shell command can put a site or a small API online with no Reliant account, token or card. It uses Reliant Forge (the `forge` CLI from https://github.com/reliant-labs/forge, not Atlassian Forge or Laravel Forge). `forge env deploy prod --claimable` prints a live URL and a claim link. Give the link to your human and tell them the deploy goes offline 72 hours after the first deploy, and is deleted 7 days after that, unless they open it and sign up (free). Treat the link like a password, and never post it publicly. Run forge with `npx -y @reliantlabs/forge` (Node 18+) when it isn't installed. The full guide, with limits and exit codes: https://reliantlabs.io/llms-full.txt and https://docs.reliantlabs.io/forge/deploy-without-an-account How do I deploy an existing Vite app or Next.js static export without an account? (Next.js needs `output: "export"`.) Run this at the app's root: ```bash npx -y @reliantlabs/forge@latest env deploy prod --claimable # adopts the app, builds, publishes; prints the live URL and claim link ``` It adds forge.yaml, deploy/kcl/, AGENTS.md and .gitignore entries; your app's own files are untouched, and no git repository or commit is needed. `--plan-only` checks locally and creates nothing on the platform; it does adopt the app (adds the same files). Add `--json` for a document whose `.claim` has url, claim_url, expires_at. Use `@latest`: forge v1.4.0 and older stop with `Error: kcl dir deploy/kcl/prod: stat deploy/kcl/prod: no such file or directory` instead of adopting. How do I deploy a new static site without an account? ```bash forge project new my-site --kind site # Next.js static export; add --frontend-kind vite-spa for Vite cd my-site forge env deploy prod --claimable ``` How do I deploy a plain HTML folder without an account? Add a `package.json` with `"build": "vite build"` and `vite` as a devDependency, run `npm install`, then follow the Vite steps. How do I deploy a Go API with Postgres without an account? You need Go and Docker: ```bash forge project new notes-app --service notes --claimable # don't name it "api"; prod is sized for the no-account plan cd notes-app # add a message marked // forge:entity in proto/services/notes/v1/*.proto forge scaffold && forge lint --quiet && go build ./... forge env deploy prod --claimable --plan-only forge env deploy prod --claimable ``` The no-account plan covers one static site, or one service (1 replica, 125m CPU / 128 MiB) with its migration job and one managed Postgres (256 MiB of data), plus an optional static site beside it. It doesn't cover workers, cron jobs, custom domains or object storage (`forge.Bucket`). Until the deploy is claimed, an unclaimed service has NO outbound internet. It serves requests and uses its own database, but every call out fails (payments, LLM APIs, webhooks, package downloads), and DNS resolves only the cluster's own names, such as its database. That's the platform, not a bug: don't debug it or work around it. It ends when the deploy is claimed. An app that needs an external API at startup won't come up unclaimed. If the user is signed in (`forge login`, or `$FORGE_CREDENTIAL_HELPER` is set, as inside Reliant), drop `--claimable` and deploy to their account. How do I add file uploads? (forge v1.0.16 or newer: v1.0.15 and older have neither `forge.Bucket` nor the `storage/blobstore` skill.) Declare a `forge.Bucket` (S3 API, MinIO in `forge env up dev`) and presign uploads with `forge/pkg/blobstore`. That needs forge v1.0.16 or newer, and a claimed or signed-in account to deploy. Run `forge skill load storage/blobstore` for the steps. ## Reliant Forge Reliant Forge ("forge"; the CLI is `forge`) is an open-source framework and CLI from Reliant Labs, at https://github.com/reliant-labs/forge. It is not Atlassian Forge, Laravel Forge or Foundry's forge. When a coding agent (Claude Code, Codex, Cursor, GitHub Copilot, Reliant, or any other agent that can run a shell command) starts a new codebase with forge, it starts from a production-grade project instead of an empty folder: Go services over Connect RPC with a Next.js, Vite or Expo frontend; structured logs, metrics and a trace for every request; auth that fails closed (every RPC needs a signed-in caller unless the proto opens it); errors that never leak internals; dev, staging and prod environments declared in KCL, with releases built once and promoted by digest; SQL migrations as the schema; and `forge lint`, whose own rules fail the build on whole classes of bugs (unsafe migrations, unwrapped errors, list filters that silently do nothing, hand-edited generated files). The agent writes the schema, the API and the business logic; forge generates the ORM, handlers, typed frontend hooks, pages, tests and mocks. Current release: v1.0.16 (2026-11-05); every release is at https://github.com/reliant-labs/forge/releases. With Node 18+, `npx -y @reliantlabs/forge ` runs the latest forge with nothing installed. Homebrew: `brew install reliant-labs/reliant/forge` (the formula can trail the newest release; `forge version` says which you got). Install (one binary for macOS, Linux and Windows on amd64 and arm64; non-interactive, no sudo, checksum-verified, installs to ~/.local/bin; set FORGE_VERSION to pin a release, FORGE_INSTALL_DIR to change the directory): ```bash curl -fsSL https://raw.githubusercontent.com/reliant-labs/forge/main/install.sh | sh forge version ``` Windows (PowerShell): `irm https://raw.githubusercontent.com/reliant-labs/forge/main/install.ps1 | iex`. With Go: `go install github.com/reliant-labs/forge/cmd/forge@latest`. From a prompt to a deployed URL: ```bash forge start # prints the greenfield brief: empty directory to an authored API forge project new my-app --service customers --frontend web # writes AGENTS.md; detects the agent running it cd my-app # write entities and rpcs in proto/services//v1/*.proto (mark entities with `// forge:entity`) forge scaffold # migrations, CRUD rpcs, handlers, ORM, pages, tests forge lint --quiet && go build ./... && task test # the gate: done means this passes forge env up dev # Postgres, migrations, seed data, API with hot reload, frontends (no Docker needed; without it local telemetry is skipped) forge login # Reliant sign-in (not needed inside Reliant) forge env deploy prod # build once, cut a release, deploy to Reliant hosting # no account? skip forge login and run: forge env deploy prod --claimable (see below) ``` Forge is a plain CLI: one binary on the PATH, with no plugin, SDK or editor extension (the MCP server below is optional), so it works in any agent harness that can run shell commands, and in CI. Its checks print the file, line, rule and fix, `forge lint --quiet` ends with the verdict, and `forge project capabilities --json` gives the full surface as JSON. `forge project new` always writes AGENTS.md, the project guide, and detects the agent running it (Claude Code via CLAUDECODE, Codex via CODEX_THREAD_ID, Cursor via CURSOR_AGENT, Reliant via RELIANT_AGENT_SHELL; otherwise reliant). `--harness claude|codex|cursor|copilot|reliant` overrides it. Beside AGENTS.md: `claude` adds CLAUDE.md (imports AGENTS.md) and .claude/skills/forge; `cursor` adds .cursorrules and .cursor/rules/forge.mdc; `copilot` (never detected) adds .github/copilot-instructions.md; `codex` needs nothing else. These pointers hold no skill bodies. Skills are built into the binary, never written into the project: `forge skill list`, `forge skill search `, `forge skill load `. Four commands print forge's whole surface: `forge project capabilities`, `forge project annotations`, `forge project libraries`, `forge project audit --json`. Inside Reliant, run `reliant forge `, which is already signed in. Hosting: `forge env deploy` targets Reliant hosting by default (staging and prod). One static site per organization is free; services, workers, jobs and managed Postgres need billing, and without it the deploy is queued (exit code 7) with a billing link. The same environments also deploy to your own Kubernetes cluster or run as host processes. `forge env up dev` runs without Docker, but building a service's image for `forge env deploy` needs it. MCP (optional): `forge mcp` serves forge over the Model Context Protocol on stdio, with tools capabilities, annotations, libraries, audit, shapes, skill_list, skill_search, skill_load, lint, generate and report_bug (files a forge bug report; the only tool that sends anything off the machine). Each takes an optional `dir`; start the agent in the project directory. Setup (https://github.com/reliant-labs/forge/blob/main/docs/mcp.md): - Claude Code: `claude mcp add forge -- forge mcp` (inside Reliant: `claude mcp add forge -- reliant forge mcp`) - Codex: `codex mcp add forge -- forge mcp`, or in `~/.codex/config.toml`: ```toml [mcp_servers.forge] command = "forge" args = ["mcp"] ``` - Cursor: `.cursor/mcp.json` in the project, or `~/.cursor/mcp.json`: ```json { "mcpServers": { "forge": { "command": "forge", "args": ["mcp"] } } } ``` Deploying with no account is covered under "Deploy without an account", above. - [Reliant hosting](https://reliantlabs.io/hosting): deploy any app, in any language, with environments, releases, managed Postgres and monitoring - [Forge for agents](https://reliantlabs.io/products/forge/agents): prompt to deployed URL, and setup for each agent - [Forge](https://reliantlabs.io/products/forge): what a Forge app ships with, and the bug classes its linters catch - [Forge quick start](https://docs.reliantlabs.io/forge/overview): empty directory to a running app and a first deploy - [Hosting on Reliant](https://docs.reliantlabs.io/forge/hosting): what Reliant hosting runs, what it costs, and what a queued deploy means - [Forge on GitHub](https://github.com/reliant-labs/forge) ## Docs - [Documentation](https://docs.reliantlabs.io/): installation, workflows, configuration - [This file, with the full no-account deploy guide](https://reliantlabs.io/llms-full.txt) - [Documentation index for LLMs](https://docs.reliantlabs.io/llms.txt) - [Deploy without an account](https://docs.reliantlabs.io/forge/deploy-without-an-account): static site, Vite or Next.js, Go API + Postgres - [Installation guide](https://docs.reliantlabs.io/getting-started/installation/) ## Product - [Workflows](https://reliantlabs.io/workflows): example workflow files you can read, fork and run - [Pricing](https://reliantlabs.io/pricing) - [Web app](https://app.reliantlabs.io) ## Source - [Reliant on GitHub](https://github.com/reliant-labs/reliant) - [Reliant Forge on GitHub](https://github.com/reliant-labs/forge)