Skip to main content
Reliant

The opinionated software factory

Turn any coding agent into a software factory.

Forge gives Claude Code, Codex, Cursor or your own harness a single pipeline to write, review, ship and monitor code, without lowering the bar.

Deploy free, no account

Want an agent to build it? Try Reliant

Apache-2.0No account to tryFirst static site free

Sample app · real console
Forge console, Overview for the sample app "shop": its hosted website, the release live in prod, dev and staging with each environment's health, request, error-rate, latency and alert charts, and the recent releases with where each one runs.
Every environment’s health and every release, from the first deploy. A sample app in the live demo.

One change through the factory

Code is cheap to write now. Confidence isn’t.

Forge puts every change through the same review, test and release pipeline, then watches it in production, so you can ship agent-speed code you’d actually stand behind.

Commands and output quoted from Forge’s docs; the issue id is their example.

  1. Write

    Any coding agent writes the code: Claude Code, Codex, Cursor, a harness of your own, or Reliant’s agents on your computer or a cloud machine.

    claude mcp add forge -- npx -y @reliantlabs/forge mcp

  2. Review

    Forge’s linters catch whole classes of agent bugs and name the file, the line and the fix, before a person reviews the change.

    ✗ internal/handlers/order/rpc_list.go:9 [forge-tracing-log-without-ctx] slog.Info logs without the context in scope, so the line carries no trace_id and cannot be joined to its request; use slog.InfoContext(ctx, …)

  3. Ship

    Forge builds a release once and promotes the same digest from staging to prod, then proves it healthy before calling it done.

    forge env deploy prod --from staging
forge obs check prod --wait --json

  4. Monitor

    Errors, traces and product events from day one. A new error becomes an issue, and an on-call agent investigates and proposes a fix.

    forge obs issue ISS-7f3a prod

The app you have. Or a new one.

Yes, any language: Node, Python, Ruby, Java or Go. If it has a Dockerfile, a container image or a static site, it runs. Or start new on Go + React: agents write the schema, the API and the features, and Forge generates the rest.

What runs on Reliant hosting How Forge builds an app

Reliant workflows

Want the agents too? Reliant runs them.

The pipeline your team already runs, with agents doing the steps. Reliant workflows run on any repo, with or without forge.

They run on your own computer, or a cloud machine that keeps going after you close the laptop.

Explore workflows Try Reliant

  1. Implement

    Label an issue and an agent writes a failing test and the fix, runs your checks and opens a pull request. For harder changes, Get It Right loops until the checks pass and a reviewer agrees, or Best of Three races three attempts in separate git worktrees and a judge picks one.

  2. Review

    A code review on every pull request, and an agent that changes the code to answer the review comments.

  3. Security

    A security review of every pull request: the diff threat-modelled, changed dependencies checked against public advisories.

  4. Merge

    Stays yours: no built-in workflow merges. To automate it, set up a workflow that merges with the GitHub CLI once checks pass, under your branch rules.

  5. Release

    Set up a workflow that runs when a deploy finishes, by webhook or workflow event, and checks the release with forge’s health check.

  6. Production

    An on-call agent takes your alerts and new or spiking errors, investigates and proposes a fix.

  7. Sweeps

    Set up a workflow on a schedule for refactor sweeps, or on a GitHub, Slack or Gmail event.

  8. Escalate

    When the call is yours, agents stop and say so: a blocked or triage label, a failed run in your Inbox, or an approval in a run you started.

Built in A workflow you set up

See it running

Production, from the first deploy.

Every app gets one place for its releases, requests and errors.

  • Sample app
    Forge console, Releases for the sample app "shop": deployments to prod in the last 30 days, the release running in dev, staging and prod, and a matrix of each release across the three environments with its checks.

    Releases across environments

    One build, promoted from dev to staging to prod. See what runs where, and redeploy any earlier release.

  • Sample app
    Forge console, one failed CreateOrder request in the sample app as a trace waterfall: 14 spans, 2 errors, the order's database queries and the failing payments call on one timeline.

    One failed request, followed

    In a Forge app, every request is traced across services, with the logs it wrote. Nothing to wire up.

  • Sample app
    Forge console, "Ask an agent" on an error issue in the sample app: a prompt to paste into Claude Code, Codex or Cursor carrying the issue and trace ids and the forge commands to fetch the details, not the telemetry itself.

    An error, handed to an agent

    Errors are grouped, each with the release it first appeared in. Hand one to an agent with the ids it needs to look.

Sample app, real console, no sign-in.

Agents keep it running

Most hosts stop at the alert. Our agents start there.

Reliant’s on-call agent reads the evidence Forge collected, finds the cause and proposes a fix. Label it agent:ready and an agent opens the pull request for you to review. You decide when it merges.

Autopilot’s on-call run investigates a slow checkout, identifies the handler and last release, and files an issue with evidence and a proposed fix. Sample data.
The on-call investigation of a slow checkout: cause, evidence, proposed fix. Sample data.

One stack, not a stack of subscriptions

Everything included.

A new app wires up 30+ tools to get here. Forge and Reliant ship them together, and the agents work every stage.

The Reliant mark drawn as a figure-eight lifecycle. One ring: develop, test, build. The other: release, promote, monitor. Debug sits where the rings cross.
Build, ship, watch, fix. Then again.
  1. Develop
  2. Test
  3. Build
  4. Release
  5. Promote
  6. Monitor
  7. Debug

Build

Reliant + Forge

An app your agents know how to work on.

  • Agent harness: desktop + web
  • Any model, your own key
  • Multi-agent workflows
  • Cloud dev machines
  • Go APIs + React frontends
  • Typed hooks + ORM
  • Migrations + safety checks
  • Seeded dev data
  • Sign-in + identity
  • One-command dev environment
  • Parallel dev stacks per worktree
  • Real-Postgres tests
  • Custom linters + generated CI
  • AI code + security review

Ship

Forge

The path from a tested change to live software.

  • Any Dockerfile or image
  • Multiple environments
  • Secrets management
  • Build once, promote the same release
  • Release history + timeline
  • Hosting: services, workers + jobs
  • Managed Postgres + 7-day point-in-time recovery
  • Static hosting + CDN
  • Custom domains
  • Your own Kubernetes

Run

Forge + Reliant

What happened, and an agent to act on it.

  • Logs
  • Traces
  • Metrics
  • Continuous profiling
  • Error tracking
  • Session replay
  • Generated dashboards
  • Default alerts
  • Release markers
  • On-call agent
  • Scheduled + webhook automations
  • GitHub / Slack / Gmail / Twilio

Proof, and no lock-in

We run Reliant on Forge.

A dozen-plus services, workers and jobs, including third-party software we didn’t write, ship with Forge to our own clusters.

  • Open source

    Forge is Apache-2.0. Read the code, and own the code it generates.

    Read the source

  • Your cloud or ours

    Deploy to Reliant hosting, your own Kubernetes cluster, Docker Compose or plain hosts. Move a workload and the same releases deploy there.

Pricing

Free to start. Pay for what runs.

Forge hosting

$0to start

Deploy with Forge to Reliant hosting. Try it with no account, then claim it free to keep it.

  • Deploy with no account; it stays live for 72 hours
  • Your first static site is free, with no billing set up
  • Backends pay as you go: about $8.34/mo for a small service, $20.14/mo for Postgres

Reliant

$0

Bring your own API key, or use your ChatGPT plan. Not a trial.

  • Desktop app for macOS, Windows and Linux, plus the web app
  • Every built-in workflow, and your own in .reliant/
  • Any provider with your own API key, or your ChatGPT plan — no token markup

Cloud machine

from $21.48/month

A dedicated machine in our cloud for runs that shouldn’t depend on your laptop.

  • Guaranteed CPU and memory, isolated in its own Kata VM
  • 160 hours included each month, then from $0.1005 an hour
  • Scheduled runs, webhooks, and long jobs

Hosting your app is pay as you go, with no base fee: about $8.34/mo for a small always-on service, and your first static site is free. What hosting includes

Machine sizes, hosting rates and FAQs

Your app, live and looked after.

Open it in your browser or download it. It’s free: bring your own API key, or use your ChatGPT plan. Dedicated cloud machines are from $21.48/month.

Try on the web

Running it for a team? Talk to us