Skip to main content
Most software stacks are stitched together. A framework comes from one vendor, CI from another, then hosting, logs, alerts, secrets and an AI assistant from five more. None of them knows what the others know. Every integration between them is glue someone writes and maintains, and an agent working in that stack works blind: it can edit code, but it cannot tell which RPC a release broke, whether a migration will lock a table, or what the user saw when the error fired. Reliant owns the whole path: the agents and workflows that write and review the code (Reliant), the framework the code is built on (Forge), and the platform it ships to and runs on (hosting and observability). Because one system declares, builds, deploys and watches your app, it knows your services, RPCs, schema, config, secrets, releases, metrics and alerts. Those are standard seams, the same in every project, and they are what let Reliant and your agents do things a stitched stack can’t.

The seams, and what each one makes possible

Code shape: generate the plumbing instead of writing it

A forge project has two sources of truth: protobuf for the API and SQL migrations for the schema. forge generate projects them into handlers, the ORM, typed frontend hooks, pages and tests, so an agent spends its tokens on your logic rather than on wiring it. The layout is fixed, so an agent asks the project where things are (forge project shapes) instead of grepping for them.

Architecture: lint for whole classes of bugs

Because forge knows what every RPC, table and boundary is, forge lint can check things a generic linter can’t: a list filter that silently filters nothing, a server-owned field nothing writes, a trace cut by a missing context, a migration that rewrites a table under an exclusive lock. Every migration also declares whether the previous release survives it, and lint holds it to that. New rules warn for a release before they gate, so upgrading forge never turns your build red overnight.

Releases: gate on measured health, never past a breaking migration

A release is built once and promoted by digest, so prod runs exactly the bytes staging ran. After every deploy, forge obs check judges the release against the window before it, per service, and answers with an exit code a script or an agent can branch on. Missing telemetry is reported as undetermined, never as a pass. With the opt-in health gate, prod promotion is refused until staging holds a passing verdict, and a rollback floor stops anyone deploying a release older than a breaking migration. There is no automatic rollback: a failed deploy never replaces what is serving, and you recover by deploying an earlier release or rolling forward.

Runtime: tie an error to the release that caused it

Every boundary of a forge app records logs, traces and metrics from the first commit: inbound RPCs, component calls, database queries, outbound HTTP and the browser. Errors are grouped into issues and tied to the release that opened them. Your agents read all of it through plain commands (forge obs status, obs issue, obs trace, obs logs) with JSON output, and read your database through one audited, read-only command that never shows secret columns.

Operations: hand an alert to an agent with the evidence attached

On Reliant hosting, a workflow trigger declared as webhook: {source: alerting} receives your organization’s critical alerts and new or regressed error issues with no URL, token or alert route to set up. The built-in Autopilot on-call workflow uses it: each alert becomes one deduplicated GitHub issue, investigated read-only with the traces, logs and data the agent can reach. When a person labels the issue ready, the issue worker writes the fix and opens a pull request. Autopilot never merges; you do.

Secrets: used by agents, never seen by them

Hosted secrets are write-only: you can set and rotate one, but never read it back. Integration steps in a workflow use saved credentials for GitHub, Gmail, Slack, Twilio and any HTTP API without the agent ever seeing the value.

Opinionated defaults, no walls

Every default is a starting point, not a lock-in:
  • Start anywhere. Use any piece on its own, in any repo and any language. An existing app deploys from its own Dockerfile, and monitoring or release recording works without forge deploying anything. See adopt an app that already exists.
  • Bring your own. Point an environment at your own database, identity provider or OpenTelemetry backend in its config. See bring your own.
  • Deploy where you want. Reliant hosting, your own Kubernetes cluster, Docker Compose or plain host processes. See self-hosted delivery.
  • Any model. Use your Claude, ChatGPT or Copilot subscription, your own API key, or local models, and mix them per workflow step. See API keys and subscriptions.
  • Try it without an account. Deploy a Vite or Next.js app with no signup and claim it later.

Where to go next

Reliant quick start

Run your first agent and workflow

Forge quick start

A prompt to a deployed URL

Hosting

What Reliant hosting runs
The product overview is on the Reliant website.