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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
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 --waitWho 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 truthSchema 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 rulesGenerated code you own
Handlers, stores, hooks, pages and mocks are generated. Your handlers and wiring are never overwritten.
Generated vs yoursBug-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 featuresDev, 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.
EnvironmentsReleases built once, promoted by digest
The deploy plan is shown first, and a failed deploy never replaces what is serving.
Release featuresComing
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 statusMonitoring 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 featuresHosting 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.