Skip to main content

Solutions · Start a new app

Build a production app with AI agents, from the first commit.

Describe the app. Your agent scaffolds it with Forge: Go services over Connect RPC, a React frontend, Postgres migrations, tests, environments and monitoring. Then it writes the logic and deploys it. The plumbing is generated, so the tokens go to your product.

The problem

Why AI-built apps stall before production.

An agent can write a working demo in an afternoon. Production is the part it cannot see: auth that fails closed, migrations that do not lock a busy table, a trace on every call, health checks and a graceful drain, secrets kept out of git, a staging environment, and a way to ship one release to prod and know it worked.

On a stitched stack, each of those is another vendor’s config, written by hand, and the agent re-derives it every session. It spends tokens on glue and guesses at conventions nothing enforces. The result looks done and is not: nothing checks that the list filter really filters, or that the new endpoint asks who is calling.

How it works

How it works on Reliant.

Agents do the judgement work. Forge does everything that should come out the same every time. You decide what ships.

  1. You

    Describe what you are building

    In a Reliant chat, or in Claude Code, Codex or Cursor with Forge’s MCP server. Name the things the app stores and the jobs it does. Reliant’s built-in Forge workflow scopes the app with you before any code is written.

  2. Forge · deterministic

    Scaffold the whole stack

    forge project new writes Go services over Connect RPC, a frontend, dev, staging and prod environments, CI, health probes, graceful shutdown and telemetry. Mark a proto message as an entity and one command adds its migration, typed store, CRUD handlers, frontend hooks, pages and a lifecycle test.

  3. Agent

    Write the product logic

    The agent writes SQL migrations, the schema’s single source of truth, the proto for the API, and the logic of each RPC in its own file. Skills built into the Forge binary, matched to your version, tell it where everything goes, so it does not have to guess.

  4. Forge · deterministic

    Check it the same way every time

    forge generate re-projects code from proto and SQL, and forge lint catches whole classes of bugs in one verdict: a list filter that filters nothing, a server-owned field nothing writes, an unsafe migration, an RPC that never checks its caller. Generated tests run against real Postgres.

  5. Forge · deterministic

    Deploy once, promote the same bytes

    One command builds a release, shows the plan and deploys it, and prod gets the exact digest staging ran. Afterwards forge obs check judges the release against the window before it, per RPC, and names what regressed.

  6. You

    Review and decide what ships

    You read the code like any pull request. Configure a release gate and prod promotion is refused until staging holds a pass for that exact release.

terminalExample
forge project new shop --service order \    --frontend web --mod github.com/acme/shopforge generate && forge lint# the whole stack locally, every log in one placeforge env up devforge env deploy prodforge obs check prod --wait

Who does each step

  • You
  • Forge · deterministic
  • Agent

What you get

What you get.

Generated, checked and wired on day one, and every file is yours to change.

  • A Go backend framework over Connect RPC

    Each RPC’s auth, deadline and idempotency declared in the proto. Typed TypeScript clients and hooks generated for the frontend.

    Two sources of truth
  • Schema from SQL migrations

    Entities and the ORM are projected from the applied schema. Each migration declares whether the previous release survives it, and lint holds it to that.

    Migration rules
  • Generated code you own

    Handlers, stores, hooks, pages and mocks are generated. Your handlers and wiring are never overwritten.

    Generated vs yours
  • Bug-class lint and real-Postgres tests

    One verdict across conventions, schema, migrations, tracing and tests. New rules warn for a release before they gate.

    Build and test features
  • Dev, staging and prod from day one

    Environments declared in your repo. Dev runs on your machine with every log, the browser console included, in one directory.

    Environments
  • Releases built once, promoted by digest

    The deploy plan is shown first, and a failed deploy never replaces what is serving.

    Release features
  • Coming

    Release candidates promoted after a soak

    A built-in workflow that cuts a release candidate and promotes it once it has soaked and its verdict is good. Today you promote with Forge’s commands and gates.

    Release status
  • Monitoring wired in

    Logs, traces, metrics, default alerts, and errors grouped into issues tied to the release that caused them. Profiling is on locally; one line turns it on for a hosted environment.

    Run features
  • Hosting when you are ready

    Managed Postgres with 7-day point-in-time recovery, custom domains with HTTPS, encrypted secrets. Your first static site is free.

    Hosting guide

Why one platform

Why this takes one platform.

Because Forge generated every service, the platform already knows its RPCs, schema, config and releases. That is what lets lint check your architecture rather than your formatting, a release be judged RPC by RPC, and a production error later reach an agent along with the release and code it came from, with no integration for you to write. A framework from one vendor and hosting from another cannot share that knowledge, so the agent works blind across the gap.

Honest limits

What it does not do, and what stays yours.

Published so you can decide before you start.

  • Generated backends are Go only. Frontends are React, with Next.js or Vite, and an Expo app can sit beside them.

  • Frontends on Reliant’s static hosting are static exports: no server rendering, server actions or middleware there.

  • Hosting runs in one region, us-central1. Kubernetes operators and cron-kind workloads need a cluster you run; a worker with its own schedule runs hosted.

  • Sign-in is built in, but access rules are your code: who may read which rows is written in your handlers, and lint flags RPCs that never check the caller.

  • The scaffolded screens prove the stack is wired. They are starter code, not a design.

  • A person reviews the code and decides what reaches prod.

Questions

What people ask first.

  • Do I have to use Reliant’s agents?

    No. Forge is open source and ships an MCP server, so Claude Code, Codex, Cursor or any agent with a shell can scaffold, generate, lint and deploy with it. Reliant adds multi-agent workflows, cloud machines and Autopilot on top, on the same project.

  • Why a Go backend framework with Connect RPC?

    One proto file is the single source of the API. Forge generates the Go handlers, typed TypeScript clients and frontend hooks from it, and declares each RPC’s auth, deadline and idempotency beside it. Connect serves Connect, gRPC and gRPC-Web over plain HTTP, so a browser calls it without a proxy, and Go gives agents a compiler and a type checker to lean on.

  • What does it cost to start?

    Forge is free and open source (Apache-2.0). A deploy with no account gives you a live URL and a claim link that lasts 72 hours. Once claimed, your first static site stays free; backends and managed Postgres are pay as you go, with no base fee.

  • Can I leave later?

    Yes. The code is yours and so is the deploy config. Rebind any workload to your own Kubernetes cluster, Docker Compose or hosts, and the same releases deploy there.

Keep reading

Related.

  • Bring an existing app

    Any language, any repo: environments, releases and monitoring without a rewrite.

  • Automate PR review to merge

    Agents review every pull request and answer comments; gates decide what merges.

  • Turn alerts into fixes

    An alert becomes an investigated issue; once a person approves, an agent opens the fix.

  • Forge

    The open-source framework: codegen, checks, environments and releases.

  • Forge for agents

    From one prompt to a deployed URL, in the agent you already use.

  • Why Reliant

    One platform that knows every seam, so your agents can too.

  • All features

    Every capability by stage of the lifecycle, each with its status.

Start with one prompt.

Try it in Reliant, or deploy free from your own agent with no account.

Forge quick start ↗