Skip to main content

All features

Everything Reliant does, from build to fix.

Every capability across Agents & Workflows, Forge, Hosting and Observability, grouped by the job it does in the life of your software. Each row says whether it ships today. Forge’s rows come straight from its benefits registry, where every claim is tied to the command, check or skill that delivers it.

Capabilities listed
323
Shipped
315
Beta
4
Coming
4
  • ShippedOn main and usable today.
  • BetaUsable, but partial, or recorded rather than enforced.
  • ComingIn progress. Not usable yet.

Stage 1 of 6

Build

From an issue or a prompt to working code on a known shape.

103 shipped

Agents & Workflows35

  • Cloud dev machines

    Agents and forge stacks can run on cloud machines that wake on demand and suspend when idle, with docker and k3d available.

    ShippedAgents & WorkflowsDetails ↗

  • Hosted MCP connector

    A remote MCP server with nothing to install, https://api.reliantapi.com/forge/mcp: sign in with OAuth from claude.ai, Claude Desktop, ChatGPT, VS Code or Cursor and ask about monitoring (status, issues, logs, traces, release verdicts), releases and environments, record a deploy or start monitoring an app, with the same tool names and inputs as the local server and a console link on every answer.

    ShippedAgents & WorkflowsDetails ↗

  • Build an App workflow

    A built-in workflow scopes the app with you, scaffolds it with forge, gets it green, fans out the implementation and verifies it in one review loop.

    ShippedAgents & WorkflowsDetails ↗

  • Move to Forge workflow

    A built-in workflow migrates an existing codebase into a forge project, gated on forge's exit codes with approval steps.

    ShippedAgents & WorkflowsDetails ↗

  • Multi-agent workflows in YAML

    Agent steps, shell commands, integration calls, approvals and loops in one YAML workflow, versioned beside your code.

    ShippedAgents & WorkflowsDocs ↗More →

  • Issue to pull request

    Label an issue ready and an agent works it and opens a tested pull request for review.

    ShippedAgents & WorkflowsDocs ↗More →

  • Get It Right loop

    A built-in workflow implements a change, checks it and reviews it, and keeps going until it passes.

    ShippedAgents & WorkflowsDocs ↗

  • Best of Three

    Three agents build the same change in separate worktrees, and a reviewer picks the best or combines them.

    ShippedAgents & WorkflowsDocs ↗

  • Describe it, get a workflow

    Say what you want automated, and Reliant scopes it, builds the workflow and tests it with you.

    ShippedAgents & WorkflowsDocs ↗

  • Sub-agents

    An agent hands work to sub-agents, messages them, checks their status and stops them.

    ShippedAgents & WorkflowsDocs ↗

  • Deterministic routing between AI steps

    CEL conditions decide which step runs next, so a workflow’s control flow is code, not a model’s guess.

    ShippedAgents & WorkflowsDocs ↗

  • Presets

    Bundle parameters, such as models and skills, into presets you reuse across workflows.

    ShippedAgents & WorkflowsDocs ↗

  • A model per step

    Choose the model, and how hard it thinks, for each step of a workflow.

    ShippedAgents & WorkflowsDocs ↗

  • Bring your subscription

    Sign in with Claude, ChatGPT/Codex, GitHub Copilot or Antigravity and use the plan you already pay for.

    ShippedAgents & WorkflowsDocs ↗

  • Your own key, or local models

    Use your own API key, OpenRouter or Vertex, or local models through Ollama, LM Studio, vLLM or llama.cpp on your machine.

    ShippedAgents & WorkflowsDocs ↗

  • Reliant AI credit

    Or run on Reliant’s AI credit, with no provider account of your own.

    ShippedAgents & WorkflowsDocs ↗

  • Parallel agents in worktrees

    Each agent works in its own git worktree, so parallel changes never collide.

    ShippedAgents & WorkflowsDocs ↗

  • Branches and threads

    Branch a conversation to try another approach, and keep each sub-agent’s context in a thread of its own.

    ShippedAgents & WorkflowsDocs ↗

  • Memories and skills

    Memories and skills give every agent your project’s conventions, and you can write your own.

    ShippedAgents & WorkflowsDocs ↗

  • Say it once

    Corrections become memories, skills and workflows, so an agent does not repeat a mistake you fixed.

    ShippedAgents & WorkflowsDocs ↗

  • Plans and tasks

    Agents plan work as tasks with dependencies and hand the ready ones out in parallel.

    ShippedAgents & WorkflowsDocs ↗

  • Code navigation for agents

    Agents get callers, callees and implementations from a language server for Go and TypeScript, plus web search and fetch.

    ShippedAgents & WorkflowsDocs ↗

  • Image and video generation

    Agents generate images and video as part of a run.

    ShippedAgents & WorkflowsDocs ↗

  • Git from the conversation

    Commit, push and open a pull request without leaving the chat.

    ShippedAgents & WorkflowsDocs ↗

  • Attachments

    Hand files and images to an agent or a workflow.

    ShippedAgents & WorkflowsDocs ↗

  • Processes

    Run your package.json, Makefile or Taskfile commands from the app.

    ShippedAgents & WorkflowsDocs ↗

  • GitHub, Slack, Gmail, Twilio and any HTTP API

    Agents act on outside services through integration steps, with a saved credential they never see.

    ShippedAgents & WorkflowsDocs ↗

  • Any MCP server

    Add an MCP server and its tools are available to your agents.

    ShippedAgents & WorkflowsDocs ↗

  • Import from Claude Code, Cursor, Codex and Windsurf

    Bring your instructions, MCP servers, rules and commands across, after you approve each one.

    ShippedAgents & WorkflowsDocs ↗

  • Your own machines

    Run agents on your computer, a server or a Raspberry Pi, pool machines by label, and pin a run to one.

    ShippedAgents & WorkflowsDocs ↗

  • Preview URLs for any dev server

    Share a dev server running on any machine at a preview URL, with access control.

    ShippedAgents & WorkflowsDocs ↗

  • Web and desktop apps

    Use Reliant in the browser, or as a desktop app for macOS, Windows and Linux.

    ShippedAgents & WorkflowsDocs ↗

  • Go and TypeScript SDKs

    Start and follow runs, answer questions, fire triggers, or stream a chat live from your own code, with tokens scoped to what each caller needs.

    ShippedAgents & WorkflowsDocs ↗

  • A CLI for scripts and CI

    JSON output, exit codes and hooks such as “on workflow failure, run this”, for scripts and CI.

    ShippedAgents & WorkflowsDocs ↗

  • Workflows beside your code

    reliant workflow validates, tests, runs and schedules the workflows in your repository.

    ShippedAgents & WorkflowsDocs ↗

Forge68

  • One marker, a whole entity

    Mark a proto message // forge:entity and one forge scaffold writes the create-table migration, the CRUD rpcs, the managed fields, the ORM projection, a lifecycle test, the list, detail, create and edit pages, nav and mock data.

    ShippedForgeDetails ↗

  • Proto in, full stack out

    One proto definition generates Connect handlers, CRUD wiring, typed frontend hooks and tests, so API, server and UI cannot disagree.

    ShippedForgeDetails ↗

  • Scaffold every shape

    forge scaffold births services, rpcs, entities, workers, operators, CRDs, adapters, webhooks, packages, binaries and frontends in the project's conventions, and is a no-op when nothing is missing.

    ShippedForgeDetails ↗

  • Disown any generated file

    Generated code sits beside owned seams you edit freely, and forge project disown permanently hands any generated file to you.

    ShippedForgeDetails ↗

  • Exclude paths from codegen

    scaffold.exclude in forge.yaml names the parts of an existing repo forge must never write, and every generate, scaffold, upgrade and rescaffold leaves them exactly as they are and says which writes it skipped.

    ShippedForgeDetails ↗

  • Prune orphaned generated files

    When a feature is pinned off, forge generate lists the files it left behind and forge project prune --orphans deletes the ones still exactly as forge wrote them, never an edited one.

    ShippedForgeDetails ↗

  • Guided forge upgrades

    forge project upgrade moves a project to a newer forge and applies every mechanical fix for the version range, and forge project upgrade list|apply tracks the one-time playbooks for the rest.

    ShippedForgeDetails ↗

  • Adopt an existing app

    An app that already exists, in any language, keeps its code: one command, forge project new --in-place --kind app, reads its Dockerfile(s) and compose file (ports, Postgres, migration command, credentials) and writes only forge.yaml and deploy/kcl/ (dev, staging and prod envs with a managed Postgres and a pre-rollout migration job), printing what it detected and what it assumed (--dry-run prints the files instead).

    ShippedForgeDetails ↗

  • Adopt any Vite or Next app

    An existing Vite or Next.js app moves under frontends/ (or is named by a KCL path) and forge generates into it with one writer per src/gen, with an opt-in pnpm workspace for sharing code between web and mobile.

    ShippedForgeDetails ↗

  • REST and OpenAPI, free

    api.openapi: true emits OpenAPI 3 from the proto in the buf pipeline and connectrpc.com/vanguard transcodes REST URLs onto the same Connect handlers at runtime, with no parallel codegen.

    ShippedForgeDetails ↗

  • Bring your OpenAPI spec

    An API whose contract is an OpenAPI 3 document is declared as a forge.API, checked as OpenAPI 3 whenever the env loads (a Swagger 2 document is refused with how to convert it) and listed with the project's databases in forge project audit --json; nothing is generated from it yet.

    ShippedForgeDetails ↗

  • Browsable API inventory

    forge generate writes gen/forge_service_catalog.json (forge.dev/service-catalog/v1): processes, the proto services each serves, methods with auth and idempotency, and components with source locations, with no server needed.

    ShippedForgeDetails ↗

  • Request validation at the edge

    buf.validate rules in the proto are enforced on every rpc by an interceptor, so request validation is declared once, beside the field.

    ShippedForgeDetails ↗

  • Typed config from proto

    Configuration is a proto message projected into KCL and into a typed Go struct, so no component parses its own environment.

    ShippedForgeDetails ↗

  • Frontend runtime twin of forge/pkg

    @reliantlabs/forge-web-runtime gives a frontend typed errors with a total .reason vocabulary, auth and always-on traceparent interceptors, the app shell and a <Resource> table with loading, error, empty and data states and cursor pagination.

    ShippedForgeDetails ↗

  • Runtime frontend config per env

    Frontend config is a typed config_gen.ts read at runtime from a per-env config.js, so one bundle promotes unchanged, a key not in the schema gets a did-you-mean, and build-time env inlining is a lint error.

    ShippedForgeDetails ↗

  • Workers with graceful drain

    forge scaffold worker writes a supervised component sharing the server's typed Deps and graceful shutdown, with a lifecycle test.

    ShippedForgeDetails ↗

  • Coordinated cron and singletons

    pkg/cronkit runs each scheduled tick at most once across replicas that share its claim store (a missed tick is not retried), with the same scheduled time on every replica, and pkg/lease gives a named singleton over Postgres advisory locks with hot standby.

    ShippedForgeDetails ↗

  • Operators and CRDs scaffolded

    forge scaffold operator and forge scaffold crd give a reconciler with pkg/controller runtime helpers, and a StatefulSet whose declared volume grew is converged by a pre-rollout resize job.

    ShippedForgeDetails ↗

  • CLIs and libraries too

    forge project new --kind cli gives a cobra binary on pkg/cmdkit with per-binary typed config loadable from a file, and --kind library gives a Go module with no server.

    ShippedForgeDetails ↗

  • Vendor-neutral outbound adapters

    forge scaffold adapter writes one narrow boundary per third-party system, and lint keeps it outbound-only.

    ShippedForgeDetails ↗

  • Mobile apps with Expo

    forge scaffold frontend --kind mobile produces an Expo React Native app on the same generated Connect hooks, with an optional ui-native workspace package.

    ShippedForgeDetails ↗

  • Correct money type

    forge/pkg/money represents amounts as integer minor units plus currency, so no float rounding ever touches a price.

    ShippedForgeDetails ↗

  • SQL migrations are the schema

    You write plain SQL migrations; forge applies them to a real ephemeral Postgres and projects the entity structs, typed ORM, per-entity stores and CRUD wiring from the result, so the code cannot disagree with the database.

    ShippedForgeDetails ↗

  • Keep your own data layer

    A project with a hand-written repository layer keeps forge's migrations and codegen without the generated ORM, by pinning features: {orm: false} in forge.yaml or marking the package //forge:no-orm.

    ShippedForgeDetails ↗

  • Keep your migration tool

    A team on goose, atlas, flyway, dbmate, golang-migrate or its own command keeps it and its migrations directory: forge runs that tool to build the schema it projects the ORM and seeds from, lints every SQL file it applies, and runs it from forge db migrate up — no protos, no conversion.

    ShippedForgeDetails ↗

  • Several databases, declared per database

    Each database declares its own dialect, migrations directory and tool, ORM package and migration-safety dials in the env declaration, so a monorepo with several databases gets every one linted, forge db --db <name> for each, and an ORM projected per database.

    ShippedForgeDetails ↗

  • Behavior from real columns

    created_at and updated_at columns give managed timestamps, a time-typed deleted_at gives soft delete and text columns give generated list search, so behaviour comes from the schema rather than from annotations.

    ShippedForgeDetails ↗

  • Write policy beside the column

    forge:read-only, forge:computed, forge:generated, forge:guards, forge:immutable, forge:version (optimistic concurrency) and forge:append-only declare who may write a column, and lint makes a field nothing writes a build failure.

    ShippedForgeDetails ↗

  • Append-only ledgers, enforced twice

    forge:append-only removes Update/Delete from the store and installs a trigger rejecting every UPDATE and DELETE.

    ShippedForgeDetails ↗

  • Transactions state their correctness

    RunTx has no default isolation — SERIALIZABLE with retry or a lock under READ COMMITTED, never both — and orm.AfterCommit holds side effects until commit.

    ShippedForgeDetails ↗

  • Migration lifecycle commands

    forge db migration new allocates a timestamp version, forge db migration rebase re-versions a branch's migrations after everything merged, and forge db migrate and forge db squash apply, inspect and compact them.

    ShippedForgeDetails ↗

  • Realistic seed data

    forge db seed apply materializes deterministic, foreign-key-coherent rows from the applied schema, satisfying CHECKs, UNIQUEs, composite keys and status lifecycles, and learns your nouns from db/seeds/vocab.yaml.

    ShippedForgeDetails ↗

  • Dev database reset and repair

    forge db migrate force repairs and clears dirty migration state, and forge db reset drops, recreates, migrates and seeds a dev database (dev only).

    ShippedForgeDetails ↗

  • The whole stack, one command

    forge env up dev builds, launches and hot-reloads every service, worker and frontend with Postgres, the IdP, the observability stack and mail ready before anything dials them, and the scaffolded dev needs neither Docker nor a cluster.

    ShippedForgeDetails ↗

  • A dev stack per worktree

    Every checkout gets its own port block and its own data, so ten worktrees (or ten agents) run ten dev stacks side by side without sharing a port or a database.

    ShippedForgeDetails ↗

  • Browser console logs on disk

    Every console.* call, uncaught error and unhandled rejection from a scaffolded frontend lands in .forge/logs/<env>/frontend_<name>.log, prefixed [browser:<level>], beside the backend logs, so what the browser did is a grep.

    ShippedForgeDetails ↗

  • Build UI before the backend

    mock_api answers every rpc from its descriptor with deterministic, schema-valid messages (streams included), named scenarios stub specific calls, and fixtures are checked for freshness, so a UI is built and tested before the backend exists.

    ShippedForgeDetails ↗

  • Hot reload per workload

    A host workload runs under air, go-run or a binary runner, and --target scopes a whole run to one workload.

    ShippedForgeDetails ↗

  • Every dev boot measured

    Each forge env up prints a phase-timing table and appends one JSON line to .forge/logs/<env>/up-timings.jsonl, so a dev-loop speedup is measured before it is claimed.

    ShippedForgeDetails ↗

  • Safe env shutdown for agents

    forge env down walks its own parent chain first, so it can't end the agent or shell that started it.

    ShippedForgeDetails ↗

  • Inspect and exec into envs

    forge env config prints what an environment hands each workload, forge env exec runs a command with it, forge env options lists the render options and forge doctor parity diffs host mode against cluster mode.

    ShippedForgeDetails ↗

  • Fast, concurrency-safe codegen

    forge generate never overwrites hand-written logic, finishes in seconds with nothing to do on an unchanged tree, and queues parallel runs on a project lock the OS releases when the holder exits.

    ShippedForgeDetails ↗

  • Machine-wide heavy-work queue

    Builds, test lanes, codegen and full lints queue for a host-wide slot (default min(CPUs/2, memory GiB/8)), so many agents or terminals on one machine never thrash it, and a crashed holder never strands a slot.

    ShippedForgeDetails ↗

  • Disk space reserve and cleanup

    forge storage reports host capacity, refuses a build below the free-space reserve, trims Go build caches and removes idle, clean, pushed worktrees.

    ShippedForgeDetails ↗

  • Debugger from the command line

    forge debug drives Delve against a running service (breakpoints, stepping, locals, goroutines) from a terminal or an agent.

    ShippedForgeDetails ↗

  • Call any rpc from the CLI

    forge api curl prints a copy-pasteable curl for any rpc of the project.

    ShippedForgeDetails ↗

  • Local Kubernetes when you need it

    forge cluster up gives a local k3d cluster with ingress URLs, logs and reload, and per-worktree namespaces share one cluster behind a kubectl-context pin.

    ShippedForgeDetails ↗

  • Environment doctor

    forge doctor checks the toolchain, payload caps, probes, resource requests and limits of every declared env with nothing running, and forge doctor parity checks host mode against cluster mode.

    ShippedForgeDetails ↗

  • Pinned toolchain, auto-installed

    forge tools install installs exactly the tool versions the project pins, so "works on my machine" stops being a variable.

    ShippedForgeDetails ↗

  • A 70+ component library

    forge component search and forge component install add ready-made frontend components, and scaffolded pages already carry enum-aware status badges and foreign-key pickers.

    ShippedForgeDetails ↗

  • Real sign-in locally, no setup

    forge env up converges a checksum-verified Zitadel as a host process and a local login broker, so the sign-in you test in dev is the one production runs — no throwaway auth shim.

    ShippedForgeDetails ↗

  • Profile-guided builds from production

    forge pgo pull turns the CPU profiles your env collects into each Go binary's cmd/<bin>/default.pgo, which you commit; every build automatically uses the committed profile, so the compiler optimizes (inlining, devirtualization) the call sites production runs hot, and a build never depends on a live profile store.

    ShippedForgeDetails ↗

  • Skills that match your forge

    forge skill list, load and search serve 180+ skills built into the forge you run, so an agent never reads guidance written for another version.

    ShippedForgeDetails ↗

  • Built-in MCP server

    forge mcp exposes forge on stdio to any MCP-capable harness, deploys, bug reports, guarded database reads and monitoring included, with no shell scraping.

    ShippedForgeDetails ↗

  • Capabilities introspection

    forge project capabilities --json enumerates every command, lint analyzer and marker from the binary itself, and forge project annotations the entity-authoring vocabulary, so neither can drift from the code.

    ShippedForgeDetails ↗

  • Find any symbol instantly

    forge project shapes locates every rpc, message, table, handler, hook and store with file:line, and project map annotates ownership.

    ShippedForgeDetails ↗

  • Library API without source diving

    forge project libraries <pkg> prints every signature of a forge/pkg package, which go doc renders as struct{ ... }, so an agent adopts an existing utility instead of re-implementing it.

    ShippedForgeDetails ↗

  • Project state snapshot

    forge project audit --json reports services, rpcs, entities, drift, unwired stubs and ownership in one document.

    ShippedForgeDetails ↗

  • JSON everywhere, with next steps

    --json on lint, obs, deploy plans and status emits documented schemas with the shared exit codes and suggested[] next commands an agent runs instead of paraphrasing.

    ShippedForgeDetails ↗

  • Bug reports from agents

    forge report-bug sends a redacted defect report with evidence, deduplicated, and sends nothing unless invoked; --dry-run prints exactly what would go.

    ShippedForgeDetails ↗

  • Agent memory file generated

    forge project memory renders the framework guide every agent session loads, kept current with the pinned forge, and describes the project as it is: an adopted app gets the forge pieces it uses and its own test commands, never forge's greenfield layout.

    ShippedForgeDetails ↗

  • Works in Claude Code, Cursor

    Forge writes thin pointers for Claude Code and Cursor that route an agent to forge skill, never copies of skill bodies that would go stale.

    ShippedForgeDetails ↗

  • No agent files when unwanted

    harness: none (forge project new --harness none) adopts forge without adding an agent memory file, harness pointer or MCP config to a repository that keeps its own.

    ShippedForgeDetails ↗

  • Predictable project layout

    Every project shares one enforced layout (one service per proto file, a service's files in one directory, contracts beside their packages), so an agent knows where code goes.

    ShippedForgeDetails ↗

  • Design asks for a brief

    The frontend/design skill makes an agent get a product brief before styling and will not invent an aesthetic, and the scaffolded UI is labelled starter code.

    ShippedForgeDetails ↗

  • LLM features as workflows

    The llm skill puts agentic or judgement work in a Reliant workflow that calls the app's API, keeps money, limits and approvals as rules in the app, and never calls a model from the browser.

    ShippedForgeDetails ↗

  • Forge inside the Reliant CLI

    reliant forge is built in and already signed in to your account.

    ShippedForgeDocs ↗

Stage 2 of 6

Test

Real databases, generated mocks and end-to-end tests, from the first commit.

13 shipped

Agents & Workflows1

  • Scenario tests for agent workflows

    Test a workflow with deterministic scenarios before it runs unattended; the built-in workflows ship with their own.

    ShippedAgents & WorkflowsDocs ↗

Forge12

  • Real Postgres in every test

    Database tests run against a real embedded Postgres shared machine-wide, each test on its own copy of a migrated template, with no Docker and no database mocks, so they belong in the fast tier.

    ShippedForgeDetails ↗

  • A generated mock per interface

    Every interface in a package's contract (contract.go, or the Service derived from a //forge:contract struct) gets a recording mock in mock_gen.go, configured per method by field, so unit tests never hand-roll a fake.

    ShippedForgeDetails ↗

  • Unit, integration and e2e tiers

    Unit tests use the real subject plus generated mocks, integration tests a real migrated Postgres and end-to-end tests a running dev stack, so the subject under test stays real at every tier.

    ShippedForgeDetails ↗

  • Slow-test gating for the fast tier

    A test that execs a tool, drives a container or dials the network calls testkit.Slow and skips under -short, and forge lint --slow-tests fails one that does not, so the fast tier stays fast.

    ShippedForgeDetails ↗

  • Go test cache soundness checks

    A test whose child process reads repo files must skip under -short or open those inputs itself, so Go's test cache cannot replay a PASS after the edit that broke it.

    ShippedForgeDetails ↗

  • Test time budgets

    forge ci test-budget reads a go test -json run and flags unmarked tests that blew the fast-tier budget.

    ShippedForgeDetails ↗

  • Skipped-test detection in CI

    forge ci verify-test-run reports packages that skipped so much that their pass proves nothing.

    ShippedForgeDetails ↗

  • Table-driven tests, batteries included

    pkg/tdd gives table-driven helpers for rpcs, the database, mocks and e2e, every scaffolded rpc gets a test row to start from, and forge project migrate tdd converts hand-rolled tables.

    ShippedForgeDetails ↗

  • CRUD tests come free

    Scaffolding an entity also writes its CRUD lifecycle test, so new tables are tested from their first commit.

    ShippedForgeDetails ↗

  • Flow tests over real data

    seedplan.SeedGraph seeds the foreign-key spine so a flow test drives the real service against a migrated database.

    ShippedForgeDetails ↗

  • Generated hooks are tested

    Lint requires a test beside every generated hooks file and fails a hook test whose assertions can never pass, such as a query-shaped test on a mutation hook.

    ShippedForgeDetails ↗

  • Test assertions on KCL declarations

    forge/pkg/kcleval lets a Go test assert against the project's KCL declarations instead of restating them.

    ShippedForgeDetails ↗

Stage 3 of 6

Review

Checks and agent reviews that catch whole classes of bugs before a person reads the diff.

56 shipped1 coming

Agents & Workflows6

  • AI code and security review

    Built-in reviewers comment on every pull request: one finds defects (comment or request-changes, never approves), one threat-models the diff with file:line evidence and exploit sketches.

    ShippedAgents & WorkflowsDetails ↗

  • Answers review comments

    When a reviewer leaves comments on a pull request, an agent answers them and pushes the fixes.

    ShippedAgents & WorkflowsDocs ↗More →

  • Workflow lint

    Catches workflows that validate but misbehave when nobody is watching, such as an ignored timeout or an approval with no one allowed to decide it.

    ShippedAgents & WorkflowsDocs ↗

  • Approvals and questions

    A run pauses for an approval or a question, notifies you over Slack or SMS, and only a token with the right scope can answer.

    ShippedAgents & WorkflowsDocs ↗

  • Agents write as a bot

    Pull requests and reviews come from the Reliant bot, so a person approves and merges them.

    ShippedAgents & WorkflowsDocs ↗

  • Built-in merge workflow

    A built-in workflow that merges a pull request once its review and checks pass.

    ComingAgents & Workflows

Forge51

  • Migration safety checks

    Every migration declares whether the previous release survives it, and forge lint --migration-safety refuses an unsafe column add, a statement that cannot run in a transaction, a colliding version or an undeclared rollback break before it ships.

    ShippedForgeDetails ↗

  • Measured migration locks and rewrites

    forge db analyze runs each pending migration statement by statement, file by file as forge's migrator applies them, on a disposable copy of a real Postgres database (an embedded one, or a snapshot you name and mark, such as an anonymized production snapshot, which is only read and copied), and reports the locks it took, the tables it rewrote or scanned, and how long it ran.

    ShippedForgeDetails ↗

  • Bug-class linters, one verdict

    forge lint runs forge's analyzers, each rule naming the bug class it prevents, beside golangci-lint, buf, eslint and the typecheck, and prints one verdict last.

    ShippedForgeDetails ↗

  • The whole CI gate, locally

    forge ci gate (task ci) runs verify-generated, lint, buf, migration safety, frontend checks, build, vulnerability and license scans, KCL validation, tests and integration tests in one table, and a skipped check fails the gate.

    ShippedForgeDetails ↗

  • Keep your own workflows

    ci.workflows in forge.yaml switches single forge workflows off (deploy, build-images, e2e, ...), and a same-named workflow the repo wrote itself is never overwritten or silently adopted: forge warns until forge.yaml says so.

    ShippedForgeDetails ↗

  • Stale codegen can't merge

    forge ci verify-generated regenerates in a scratch copy and fails when the committed output differs, and forge lint --generated-drift fails a generated file someone edited by hand.

    ShippedForgeDetails ↗

  • New rules warn before gating

    A lint rule new in a forge release warns, with a "new in vX; gates from vY" note, and gates only from the next release, so bumping the forge pin never turns your build red overnight.

    ShippedForgeDetails ↗

  • Every suppression, with its reason

    A suppression is a comment that must give its reason, and forge lint --show-suppressed lists every one the project declares with file, line and stated reason, so waivers stay visible.

    ShippedForgeDetails ↗

  • Skipped lint lanes fail the gate

    A gating lint lane that could not run fails the build unless you accept the skip by name with a reason, and --strict escalates advisory findings to errors.

    ShippedForgeDetails ↗

  • Switch a lint lane off

    lint.lanes in forge.yaml switches whole forge lint lanes off (frontend, migration safety, db grants, ...) for a repo that checks them another way, and the verdict still names every lane that is off.

    ShippedForgeDetails ↗

  • Type-checked auto-fixes

    forge lint --fix applies the mechanical fixes (formatting, traced logging, prettier, eslint) and takes back any Go rewrite that breaks its package, and --check or --no-fix print each pending fix's diff and fail.

    ShippedForgeDetails ↗

  • Codemods for convention moves

    forge fix rewrites a project onto a new convention in one command (Connect errors, narrow Deps, the composition graph, operatorkit, the config proto package), and takes back a rewrite that fails.

    ShippedForgeDetails ↗

  • Pinned forge version enforcement

    Forge refuses to lint or generate with a binary other than the one forge.yaml pins, so every machine and CI produce the same output.

    ShippedForgeDetails ↗

  • Unwritten read-only field detection

    A read-only or computed field that no code populates fails lint, instead of every row shipping a silent zero.

    ShippedForgeDetails ↗

  • Guarded-column write detection

    Lint flags an edit page or handler that writes a forge:guards column directly, bypassing the rpc that owns its state transitions.

    ShippedForgeDetails ↗

  • Optional-field presence checks

    Lint fails when a field's optional label differs between an entity and its Create request, which would silently drop "unset" vs "zero".

    ShippedForgeDetails ↗

  • List filters that actually filter

    A List filter field without optional has no presence, so "no filter" would collapse into "filter by zero"; lint rejects it.

    ShippedForgeDetails ↗

  • Enums and CHECKs agree

    A database CHECK marked forge:closed-set must list exactly the Go set it mirrors, and lint prints the forward migration that fixes a mismatch.

    ShippedForgeDetails ↗

  • Credential columns need a decision

    A token-, password- or key-shaped column must be marked secret or readable with a reason before the read-only database role may see it.

    ShippedForgeDetails ↗

  • Timezone-safe date bucketing

    Lint flags a two-argument date_trunc over a TIMESTAMPTZ, which truncates in the session timezone and moves every daily total with the deploy host.

    ShippedForgeDetails ↗

  • Raw-SQL placeholder bugs caught

    Lint catches $1-style placeholders and literal ? in bun raw SQL, both of which fail at runtime or bind shifted arguments.

    ShippedForgeDetails ↗

  • Test fixtures checked against schema

    forge lint --fixture-drift runs every scaffolded CRUD fixture statement against a shadow Postgres and reports what the current schema rejects.

    ShippedForgeDetails ↗

  • Package contracts enforced

    An internal package with exported methods and no contract (contract.go or a //forge:contract type) is flagged, so every component is visible to wiring, mocks, the observability decorator and the reporters.

    ShippedForgeDetails ↗

  • Dependency injection lint

    Lint keeps Deps interface-typed and narrow, forbids downcasts and container-style deps, and pushes scalars into typed config, so every component unit-tests against mocks.

    ShippedForgeDetails ↗

  • Optional dependency nil checks

    Lint flags an unguarded dereference of a Deps field marked forge:optional-dep, a nil-pointer panic no construction-time check can catch.

    ShippedForgeDetails ↗

  • Wiring checked as a graph

    forge lint --graph fails a composition graph that does not assemble, a component no root reaches, and a listener serving a service of another audience.

    ShippedForgeDetails ↗

  • Config read the typed way

    Lint rejects a component reading os.Getenv or a frontend reading process.env, and flags a config message no binary or frontend ever loads.

    ShippedForgeDetails ↗

  • Unknown marker detection

    A misspelled forge: marker in Go, proto or a SQL comment, or a (forge.v1.*) option this binary does not define, fails lint instead of being silently inert.

    ShippedForgeDetails ↗

  • Vendored proto drift detection

    A vendored forge.proto that drifted from the binary's copy fails lint instead of compiling annotations nothing reads.

    ShippedForgeDetails ↗

  • Breaking API changes gated

    A generated proto-breaking.yml runs buf breaking, so a change that would break existing clients fails CI, and the proto-breaking skill carries the reserved-tag discipline.

    ShippedForgeDetails ↗

  • Open signup is deliberate

    A bare forge lint flags a login broker that mounts open registration unconditionally, so outside development an unverified address never gets a signed-in account by accident.

    ShippedForgeDetails ↗

  • Secrets wiring verified per env

    forge lint --secrets checks every env's secrets model: each key a workload reads is produced by exactly one declaration, and an ExternalSecret never deletes its Secret on a store outage.

    ShippedForgeDetails ↗

  • Static-export breakage caught early

    For a statically hosted Next.js app, forge lint --static-export names each route, server action, cookies() call or next/image use the export would refuse, with file and line.

    ShippedForgeDetails ↗

  • Frontend conventions enforced

    Lint keeps server data out of Zustand stores and forge-owned variables out of committed dotenv files, so React Query stays the one source of truth and a mock build never ships.

    ShippedForgeDetails ↗

  • Data-integrity rules

    A column nothing writes, a filter that no-ops or a CHECK drifting from Go fails lint instead of shipping silent wrong data.

    ShippedForgeDetails ↗

  • Architecture and wiring rules

    Lint keeps Deps interface-typed and narrow, every component reachable and audience-correct, so services stay mockable and wired.

    ShippedForgeDetails ↗

  • API and error-handling rules

    Lint stops internal error text leaking to callers, misspelled markers going inert and holes in activity history.

    ShippedForgeDetails ↗

  • Broken-trace detection and fixes

    forge lint --tracing names every place a request's trace is cut (a log call without its context, a hand-built HTTP client, an untraced database pool, an uninstrumented contract) and --fix rewrites most of them.

    ShippedForgeDetails ↗

  • Test-hygiene rules

    Unmarked slow tests, stale cached passes and hook tests that can never pass are caught before merge.

    ShippedForgeDetails ↗

  • Frontend build rules

    What a static export would refuse, build-time env inlining and lockfile drift fail with file:line.

    ShippedForgeDetails ↗

  • Deploy and secrets rules

    Undrainable PDBs, wrong-arch builds, reconcile-breaking Flux Jobs and missing secret keys are caught from each env's real render.

    ShippedForgeDetails ↗

  • Generated-code tampering checks

    Hand-edited generated files, ignored generated code and committed machine-local state fail lint.

    ShippedForgeDetails ↗

  • Template lint for forge itself

    Forge lints its own templates for the ownership banner each tier must carry and for symbols a regenerated template no longer defines, so a forge release never scaffolds a project that fails to build.

    ShippedForgeDetails ↗

  • Auth that fails closed

    Every rpc needs a valid credential unless its proto says auth_required: false, so a forgotten annotation never publishes an endpoint and there is no second allow-list to drift.

    ShippedForgeDetails ↗

  • Dependency and image scanning

    forge ci vuln-scan runs govulncheck over every Go module and npm audit over every frontend, refuses a pass it did not verify, and takes reviewed, expiring exemptions instead of silent ignores.

    ShippedForgeDetails ↗

  • Signed images, SBOM and provenance

    The generated build-images.yml signs every image it pushes with a keyless cosign signature bound to its digest, generates an SPDX SBOM for it, and attests its build provenance.

    ShippedForgeDetails ↗

  • Find rpcs that ignore the caller

    forge project audit includes an unscoped_auth list of authenticated rpcs that never resolve who is calling, with // forge:auth-unscoped-ok: <reason> as the only acknowledged exception; a marker with no reason is listed as malformed, never silently ignored.

    ShippedForgeDetails ↗

  • One listener per caller type

    // forge:audience names each authenticator's trust domain and forge lint --graph fails a listener serving another audience, so a daemon token cannot reach a user service.

    ShippedForgeDetails ↗

  • Owner scoping at one chokepoint

    Claims are enriched by stable subject (never email) before any handler runs, and a forge:owner column makes forge scaffold the owner-scoping wrapper that lint keeps consistent across siblings, never recommending an email address as the owner.

    ShippedForgeDetails ↗

  • Forbidden licenses fail the gate

    A generated project's forge ci gate runs go-licenses over its Go dependencies and fails on one whose license type is forbidden or restricted; there is no license check for npm dependencies.

    ShippedForgeDetails ↗

  • Dependabot and CODEOWNERS shipped

    New projects get Dependabot updates and a CODEOWNERS file out of the box.

    ShippedForgeDetails ↗

Stage 4 of 6

Release

Build once, promote by digest, and gate each environment on the last one’s health.

44 shipped3 beta2 coming

Agents & Workflows3

  • Agents deploy with guardrails

    Reliant agents get forge read tools plus a deploy tool that plans first, applies asynchronously and waits, the only cluster-mutating path, kept deliberately conservative.

    ShippedAgents & WorkflowsDetails ↗

  • Built-in release-candidate workflow

    A built-in workflow that cuts a release candidate when main has moved.

    ComingAgents & Workflows

  • Built-in promotion with a soak period

    A built-in workflow that promotes a release to the next environment after it has soaked healthy in the last one.

    ComingAgents & Workflows

Forge41

  • Migration lock and statement timeouts

    A migration never waits for a lock without a limit (lock_timeout 5s, five attempts with backoff, statement_timeout 30m, overridable per file), and CREATE INDEX CONCURRENTLY cleans up an invalid index, so one slow reader plus one ALTER TABLE is not an outage.

    ShippedForgeDetails ↗

  • Signed, verified forge installs

    Every forge release ships checksums and a Sigstore attestation over its archives, and install.sh verifies them (with gh or cosign) before installing.

    ShippedForgeDetails ↗

  • Build once, promote by digest

    forge env build --release records an immutable set of artifact digests, and forge env deploy prod --from staging deploys exactly the bytes that passed staging.

    ShippedForgeDetails ↗

  • Deploy anywhere, declare once

    A fw.Workload is declared once in workloads.k and each env binds it to host processes, Docker Compose, a Kubernetes cluster you run, Reliant hosting, your own deploy tooling or build-only, so no env file restates a command or build that could drift.

    ShippedForgeDetails ↗

  • Keep your deploy tool

    A workload bound to forge.OnExternal is built, released and promoted by forge and then shipped by your own Helm, Fly.io, Cloud Run, ECS or Argo CD through four optional argv hooks, so adopting forge does not mean replacing the pipeline that deploys today.

    ShippedForgeDetails ↗

  • Declare an env in YAML

    An environment is declared in KCL or in a plain YAML/JSON env document (deploy/envs/<env>.yaml) that IS what KCL renders to, validated against a generated, versioned JSON Schema with errors that name the path and the field, and every forge command reads either one the same way.

    ShippedForgeDetails ↗

  • Pre-deploy parity verification

    forge env verify <env> compares, per workload, the digest the env's promotion pins against the digest running and runs your tool's own dry run, while building, recording and deploying nothing, so forge's first deploy of an existing project is known to change nothing.

    ShippedForgeDetails ↗

  • Production from the first commit

    What forge project new scaffolds on the first commit is what runs in production, configured differently, so there is no toy mode to replace before shipping.

    ShippedForgeDetails ↗

  • Environments as typed code

    dev, staging and prod are typed KCL from day 0, and forge ci validate-kcl proves every env renders manifests the cluster will accept, so a broken deploy declaration fails CI, not the deploy.

    ShippedForgeDetails ↗

  • New environment in one command

    forge env new scaffolds an environment from an existing one, and forge env options lists the render options it takes.

    ShippedForgeDetails ↗

  • Diff your code against deployed

    forge env diff renders this checkout and shows how each environment would change.

    ShippedForgeDetails ↗

  • Release lists every declared env

    A released bundle carries one declared_envs entry per deploy/kcl/<env>/main.k, so the console lists environments that never recorded anything, and forge env status --json with no env prints the whole project's topology.

    ShippedForgeDetails ↗

  • Release timeline per environment

    Every promotion is an append-only ledger entry, so forge env releases answers what was live at any moment (or for any trace id) and what changed: commits, PRs, shape diff, migrations, gates, health.

    ShippedForgeDetails ↗

  • Record deploys from existing CI

    One forge release record step after the deploy job your pipeline already runs gives monitoring a deploy marker per release, in any repo and any language, with no deploy/kcl and nothing built or applied by forge.

    ShippedForgeDetails ↗

  • Deploy plans with binding approval

    forge env deploy prints its plan and writes nothing until confirmed, --plan-only then --approve <digest> refuses a plan that changed in between, and a data-loss finding needs an explicit acknowledgement even with --yes.

    ShippedForgeDetails ↗

  • Polyrepo, pinned, any language

    Teams outside a monorepo, in any language, share an infra repo's KCL by a git pin in kcl.mod and build other repos' images from a pinned DockerBuild.context, with no go.mod and no CI checkout step; a release records each image's source repo and commit.

    ShippedForgeDetails ↗

  • Compare-and-set promotions

    Every promote is a compare-and-set against the promotion the plan read, so a CI job that waited on approval cannot overwrite a hotfix that landed meanwhile, and a retry that already landed is a no-op.

    ShippedForgeDetails ↗

  • Concurrent rollout protection

    Promoting while the current promotion is still rolling out is refused (exit 4) unless --supersede is given, and the override is recorded on the new entry.

    ShippedForgeDetails ↗

  • Exit codes pipelines can branch on

    Every verb shares one exit-code table (0 success, 1 wrong, 2 could not tell, 3 conflict, 4 refused, 5 plan unconfirmed, 6 superseded, 7 queued on a person, 8 timed out), so a pipeline branches without parsing messages.

    ShippedForgeDetails ↗

  • Freeze an environment declaratively

    An env whose reconcile policy is pinned refuses every promote with exit 4 environment_pinned, so a freeze is declared state, not a convention.

    ShippedForgeDetails ↗

  • Migrations gate every rollout

    Deployed envs apply migrations from a rendered initContainer under a Postgres advisory lock before any new pod starts, so replicas never race to apply one and no pod runs on an unmigrated schema.

    ShippedForgeDetails ↗

  • Out-of-order migrations refused

    A release records the migrations it embeds, and the cut and deploy refuse one whose migrations the env's schema already passed, instead of discovering it as crash-looping pods.

    ShippedForgeDetails ↗

  • Resumable release builds

    A cut that died after pushing images is resumed from its journal by re-running the same build, rebuilding nothing.

    ShippedForgeDetails ↗

  • Portable, verifiable release ledgers

    forge ledger where|show|export|import says which backend holds an env's ledger and moves history between backends, forge release verify proves every artifact a release names exists and matches, and forge release bundle diffs a recorded bundle against the live clusters.

    ShippedForgeDetails ↗

  • Break-glass deploy without control plane

    When the control plane is down, forge env deploy <env> --offline-ledger --to previous deploys a cached release by its recorded digests and replays the promotion on the next contact.

    ShippedForgeDetails ↗

  • Roll-forward recovery

    A failed deploy leaves the previous ReplicaSet serving and a bad migration is stopped before any workload changes, so recovery is a new release, and binding an older release is an ordinary promote labelled BEHIND in the plan and the ledger.

    ShippedForgeDetails ↗

  • Rollback floors per environment

    A rollback floor refuses every deploy of a release older than it to one environment before anything is built: set one by hand or with forge env deploy --floor, and promoting a release that carries a forge:breaks-rollback migration or a deploy/rollback-floors/<id>.yaml declaration raises one on its own.

    ShippedForgeDetails ↗

  • Per-PR preview environments

    forge env preview create --pr <n> --ttl <d> makes a pull request its own environment, a copy of a committed template env named for the PR, which your CI creates, deploys and deletes on close; an expired one is deleted by the control plane when hosted, or by forge env gc on a cluster you run.

    ShippedForgeDetails ↗

  • Required checks and your approvals

    An env refuses a promotion that does not carry its required checks as passed, or that your own approval system did not approve, enforced where the env's ledger lives so no client can skip it.

    ShippedForgeDetails ↗

  • One env base, per-env deltas

    Every deployed env binds its workloads through one shared base, so an env file holds only what is its own and a new env starts as its deltas.

    ShippedForgeDetails ↗

  • Release health policy as code

    Thresholds and the failing set are forge.ReleaseHealth on each env, recorded in the release, so the CLI, the console and alerting judge a release the same way.

    ShippedForgeDetails ↗

  • Per-env delivery policy controls

    forge.DeliveryPolicy declares per env what a release must prove, each control off, audit or enforce: health_gate, signing and flux_verify are enforced on a control plane, required_gates and approval_hook wherever the env's ledger lives, while provenance_sbom, trusted_builder, admission_verify, signed_promotions, vuln_gate, bundle_kinds and approvals are recorded and refuse nothing yet.

    BetaForgeDetails ↗

  • Check results attached to releases

    forge gate record attaches a lint, test, smoke or manual sign-off result to the promotion it is about, with who and when, and forge env deploy --gate reads them; nothing refuses a promotion on a gate's status.

    BetaForgeDetails ↗

  • Deploys wait, then smoke-test

    forge env deploy records, applies and waits for health, and forge env smoke probes every declared ingress route for TLS, routing and CORS.

    ShippedForgeDetails ↗

  • Config errors caught before push

    forge env build --push, --release and forge env deploy boot each workload with its rendered env under FORGE_CONFIG_CHECK=1 before pushing, so a missing required config value is found before the image is public.

    ShippedForgeDetails ↗

  • GitOps-safe manifests

    Forge refuses a Job that a GitOps reconciler would re-run or wedge (a TTL, an unhashed name) and a force-recreate on a kind that holds data at bundle build, and a bare forge lint catches them earlier across every env.

    ShippedForgeDetails ↗

  • Override any field, bring any YAML

    Bundle.overrides, keyed by Kind/name, changes one field of a rendered object without forking the template (a conflict fails the render), and forge.Manifests brings your own YAML or Helm chart.

    ShippedForgeDetails ↗

  • Connect a cluster you run

    forge cluster connect registers a Kubernetes cluster you run as one env's binding, with a ServiceAccount token scoped to exactly what the hub applies.

    ShippedForgeDetails ↗

  • Static sites are full projects

    A landing page, docs site, SPA or PWA gets dev, staging and prod, build-once releases promoted by digest and per-env runtime config without a rebuild, and an existing Vite or Next.js app is adopted in place.

    ShippedForgeDetails ↗

  • Generated CI and deploy workflows

    A new project gets ci.yml, proto-breaking.yml, build-images.yml, a per-env deploy.yml, e2e.yml and pre-commit.yml, each labelled regenerated or yours, and each a thin wrapper around the local tasks.

    ShippedForgeDetails ↗

  • CI runs you can read back

    forge ci summarize renders any --json verdict as a job summary, and forge ci run shows one run's timeline across the cut, checks, promotes and rollouts.

    ShippedForgeDetails ↗

Hosting3

  • Signed release delivery

    Delivery bundles are signed with the org's key and the cluster applies a digest only if the signature verifies.

    ShippedHostingDetails ↗

  • Server-side deploy plan

    On Reliant hosting the plan is computed from the bundle last applied, not from the declared shape, with unknown fields refused, so the diff you approve is the change that happens.

    ShippedHostingDetails ↗

  • Prod gated on staging's verdict

    A declared HealthGate makes the control plane refuse a prod promote until staging holds a PASS for that release, inside the promotion's transaction, with an audited override for incidents.

    ShippedHostingDetails ↗

Observability2

  • Prove each deploy is good

    forge obs check <env> compares the window after a promotion with the equal window before it, per service, lists what the release opened, and exits pass, fail, could not tell or timed out.

    ShippedObservabilityDetails ↗

  • DORA metrics from the ledger

    Change-failure rate and time to restore are computed from the release ledger and alert history, not hand-reported.

    BetaObservabilityDetails ↗

Stage 5 of 6

Run

Hosting, data, secrets and telemetry for what you shipped.

82 shipped1 coming

Agents & Workflows8

  • Schedules

    Run any workflow on a cron or an interval; a suspended cloud machine wakes for it.

    ShippedAgents & WorkflowsDocs ↗

  • Webhooks

    Any HTTP POST to a workflow’s webhook starts a run.

    ShippedAgents & WorkflowsDocs ↗

  • GitHub, Slack, Gmail and Twilio events

    A pull request, an issue label, a Slack mention, a new email or an inbound SMS starts a run.

    ShippedAgents & WorkflowsDocs ↗

  • Workflow events

    Chain a run on another one finishing, failing or blocking.

    ShippedAgents & WorkflowsDocs ↗

  • Runs with no machine

    Automations that need only the web and integrations run on Reliant’s servers, with no computer of yours.

    ShippedAgents & WorkflowsDocs ↗

  • Unattended runs can’t pile up

    Concurrency limits cap how many runs execute at once, and workflow lint catches unbounded waits.

    ShippedAgents & WorkflowsDocs ↗

  • Pause, steer, resume

    Pause a run, change its parameters or steer it mid-run, and have it pause on failure.

    ShippedAgents & WorkflowsDocs ↗

  • Secrets agents use without seeing

    A hosted secret lists the workflows that may use it (forge secret allow), and their HTTP calls use it without the agent ever seeing its value.

    ShippedAgents & WorkflowsDocs ↗

Forge20

  • Dashboards bounded by DB privileges

    Dashboard panels read through a forge_dash role granted exactly their columns by migration, with row cap, timeout and concurrency limit.

    ShippedForgeDetails ↗

  • Object storage per env

    Declare a forge.Bucket per env (MinIO in dev, any S3-compatible bucket elsewhere) and pkg/blobstore presigns uploads that go from the browser straight to the bucket, so file bytes never pass through your API.

    ShippedForgeDetails ↗

  • Errors never leak internals

    A handler returns svcerr.Wrap(err) and the caller gets a classified Connect code while a driver's SQL, a DSN or an internal host stays in the server's log, and the fault class (server, user, canceled) sets the log level.

    ShippedForgeDetails ↗

  • Secrets never in git

    A secret is declared once as a reference and bound per env to a provider, so rendered KCL only ever carries references, and forge secret set requires the env so a value cannot land in the wrong one.

    ShippedForgeDetails ↗

  • Managed identity, declared once

    Users, roles, owners, signup mode and sign-in methods are declared once in deploy/kcl/identity.k, and forge fills the issuer, audience and broker credentials per env: a dev IdP locally, the control plane's identity instance in staging and prod.

    ShippedForgeDetails ↗

  • Passwords, passkeys, magic links, social

    The scaffolded login broker serves passwords (with a complexity policy), passkeys, magic links and social sign-in as declared in KCL, and lint fails a method the broker does not serve.

    ShippedForgeDetails ↗

  • API keys never pass as tokens

    API keys are routed by shape to your own table, hashed and compared in constant time, and the credential kind is stamped by the authenticator so a token can't impersonate a key.

    ShippedForgeDetails ↗

  • Scoped machine access tokens

    pkg/accesstoken gives one machine credential with a closed scope vocabulary that can never grant authority its holder lacks; a person mints the CI token in the web app (Settings → API tokens), and forge cloud token manages them where the control plane admits a CLI login.

    ShippedForgeDetails ↗

  • Cached JWKS for IdP outages

    A JWKS snapshot lets a service restart and keep validating tokens while its issuer is down.

    ShippedForgeDetails ↗

  • Bring your own IdP

    Declare no identity in an env and set jwt_issuer and oidc_client_id in its config, and Auth0, Okta, Keycloak or any OIDC issuer plugs in.

    ShippedForgeDetails ↗

  • Security headers and request limits

    Security headers, CORS, Connect payload caps and request-id middleware ship in the chain, and forge doctor checks caps, probes and resource limits of every env with nothing running.

    ShippedForgeDetails ↗

  • Rate limits, idempotency, webhook checks

    Ready-made middleware for rate limits, idempotency keys, webhook signature checks, log redaction and per-request audit records ships in pkg/middleware.

    ShippedForgeDetails ↗

  • Outbound SSRF guard

    pkg/netguard refuses outbound connections to loopback, private, link-local, cloud-metadata and in-cluster destinations, removing the SSRF review from every fetch-by-URL.

    ShippedForgeDetails ↗

  • Pluggable secret providers per env

    forge.FileSecrets (a gitignored file store) for dev, forge.HostedSecrets (write-only) for hosted envs, forge.ExternalSecrets and the forge.ExternalSecretsOperator component for a cluster, a self-run forge.OpenBao with JWT-only client auth, and forge.ControlPlaneSecret for a value the control plane renews with no restart.

    ShippedForgeDetails ↗

  • No .env files

    A bare forge lint fails on a .env file, because a dotenv is injected wholesale into every host service and its values never have to be declared in KCL.

    ShippedForgeDetails ↗

  • Verify live secrets without seeing them

    forge env secrets verify compares a live Secret with its store copy per key — match or no-match, never a value or hash — and adopt hands a verified one to ESO.

    ShippedForgeDetails ↗

  • Generated keys and certificates

    forge generate mints random keys, passwords that meet a complexity policy, and key pairs and certificates into the file secret store.

    ShippedForgeDetails ↗

  • Encryption with key rotation

    pkg/crypto seals values with AES-256-GCM under a versioned keyring, so keys rotate without making data unreadable.

    ShippedForgeDetails ↗

  • Credentials redacted on the way out

    pkg/redact strips credential shapes and personal paths from text leaving the process, and forge report-bug --dry-run shows exactly what would be sent.

    ShippedForgeDetails ↗

  • Probes and zero-drop shutdown

    A service gets /readyz and /healthz, and the pod's grace period is derived from the drain settings, so a rollout never kills a pod mid-drain and a draining replica reports its in-flight calls as canceled, not as errors.

    ShippedForgeDetails ↗

Hosting31

  • Backups and point-in-time restore

    A hosted database is built for continuous WAL archiving and a daily base backup to object storage, and restoring is a declaration: a new ManagedDatabase with restore = {sourceDatabase, pointInTime} boots from the source's backups replayed to that moment.

    ShippedHostingDetails ↗

  • Managed object storage

    A declared forge.Bucket becomes a platform-owned bucket in hosted envs (MinIO in dev), with credentials and CORS origins managed for you.

    ShippedHostingDetails ↗

  • Restores are drilled, not assumed

    An automated drill takes a real backup, destroys the cluster and volumes, restores to a timestamp, and asserts rows before it came back and rows after it did not.

    ShippedHostingDetails ↗

  • User admin from the CLI

    forge cloud identity lists, invites, resets, locks, re-roles, signs out, exports and deletes a hosted environment's users, and shows the state of its identity instance.

    ShippedHostingDetails ↗

  • Write-only hosted secrets

    Hosted secrets are stored in an OpenBao-backed store, write-only (set once, never read back), scoped to one (org, env), with per-workflow access grants.

    ShippedHostingDetails ↗

  • Tenant workloads sandboxed

    Hosted workloads run on an isolated-pool runtime with per-(org, env) namespaces, and a cross-tenant acceptance suite proves no query, secret or network path crosses tenants.

    ShippedHostingDetails ↗

  • Databases fenced off by default

    A hosted database gets a namespace default-deny, ingress only from your own workloads, and no internet egress (only its backup store and the API server), so a data-only environment is never left open.

    ShippedHostingDetails ↗

  • Credentials the platform never holds

    The database owner credential is generated in-cluster and published to your workloads; the control plane holds no credential that can open a tenant database.

    ShippedHostingDetails ↗

  • Managed Postgres

    An environment on Reliant hosting gets Postgres the platform provisions and operates, each database its own server in your (org, environment) namespace, so no other tenant shares it and staging can never get a credential for prod's data.

    ShippedHostingDetails ↗

  • Static hosting with a CDN

    A static site is served from a platform-owned bucket behind a CDN, invalidated on release, with per-env runtime config without a rebuild and old releases retained.

    ShippedHostingDetails ↗

  • Custom domains with automatic HTTPS

    Claim a hostname, publish the DNS records forge prints, and the platform verifies it, issues and renews the certificate and serves it, with bind and rebind between envs and no spec edit.

    ShippedHostingDetails ↗

  • Staging and prod hosted by default

    A new project's staging and prod are bound to Reliant hosting (managed Postgres, the API as a workload, the frontend on a CDN, per-env secrets and custom domains) and rebinding to your own cluster is a one-line change.

    ShippedHostingDetails ↗

  • Deploy with no account

    forge env deploy <env> --claimable publishes one static site, or one service with one database, with no signup and prints a live URL plus a claim link valid 72 hours.

    ShippedHostingDetails ↗

  • One static site free

    One hosted static site is free per owning person, counted across every env and every org they own without a plan, with metered egress above the free tier.

    ShippedHostingDetails ↗

  • Posted pay-as-you-go hosting rates

    Reliant hosting's posted rates are $0.0455 per vCPU-hour, $0.01375 per GiB-hour of memory and $0.18 per GiB-month of storage, on what each pod requests.

    ShippedHostingDetails ↗

  • A live URL on deploy

    Every hosted app and site gets its own platform hostname the moment it deploys.

    ShippedHostingDetails ↗

  • Services, workers and jobs hosted

    Services, workers and gating jobs run hosted under a restricted profile (read-only root filesystem, no service-account token, restricted pod security, quota and egress containment); cron-kind workloads and operators need a cluster you run.

    ShippedHostingDetails ↗

  • A private registry included

    Hosted envs push to a per-org registry subtree authenticated by your Reliant token, so there is no registry account to create and the platform admits only your own images.

    ShippedHostingDetails ↗

  • Broken workloads stop billing

    A workload with no ready replica past its limit is scaled to zero and marked failed instead of crash-looping forever.

    ShippedHostingDetails ↗

  • Deploys queued on billing holds

    A deploy that needs billing is recorded and queued (exit 7) with the link to fix it, and proceeds on its own when the hold clears.

    ShippedHostingDetails ↗

  • Env lifecycle from the CLI

    forge env stop, start and delete operate a hosted env (delete shows what goes and refuses while a custom domain is bound), and forge env list --orphaned finds hosted envs the project no longer declares.

    ShippedHostingDetails ↗

  • LLM access without a key

    Declare forge.LLM { runtime = forge.OnHosted {} } and give a workload forge.llm_env(), and the platform puts a per-env, capped, billed key in the pod for the official OpenAI and Anthropic SDKs, unmodified, so the app never holds a provider key.

    ShippedHostingDetails ↗

  • Databases on stable nodes

    Database instances are placed on non-scale-to-zero nodes so the autoscaler never reclaims a node holding your data.

    ShippedHostingDetails ↗

  • A console for every project

    The Forge console (forge.reliantlabs.io, also inside the Reliant web app) covers every project: workloads, releases, observability and dashboards, data, storage, environments, secrets, domains, monitoring and activity.

    ShippedHostingDetails ↗

  • Data and storage browsers

    The web console browses an environment's database and its buckets read-only, scoped to owned, ready resources of your org.

    ShippedHostingDetails ↗

  • Databases outlive their environment

    Deleting a hosted environment keeps its database until you delete that too.

    ShippedHostingDocs ↗

  • Versioned secrets

    Hosted secrets keep their versions and are soft-deleted, so a deletion can be undone.

    ShippedHostingDocs ↗

  • Unclaimed deploys are scanned

    What a deploy with no account uploads is scanned for malware and phishing before it goes live.

    ShippedHostingDocs ↗

  • Org policy and spend caps

    Admins set org policy, including spend caps, and preview a change before it applies.

    ShippedHostingDocs ↗

  • One bill

    Compute, AI, hosting and observability on one bill, broken down per org and per project.

    ShippedHostingDocs ↗

  • Members, roles and scoped tokens

    Invite your team, give each member a role, and mint API tokens scoped to what each caller needs.

    ShippedHostingDocs ↗

Observability24

  • 10 GiB of telemetry included

    The posted observability allowance is 10 GiB of stored logs, traces, metrics and profiles per organization a month, with or without a plan, and the posted rate above it is $0.10 per GiB.

    ShippedObservabilityDetails ↗

  • Observability stack included

    forge env up brings up ClickHouse, HyperDX and an OTLP collector in one container on loopback ports, with logs, traces and metrics sources pre-created and no sign-in, so you can debug from the first boot.

    ShippedObservabilityDetails ↗

  • Every request traced and measured

    Each RPC is one span, one metric sample and one log record at the edge with a W3C trace and request id, and every component call and ORM query is a child span — no hand-written tracing.

    ShippedObservabilityDetails ↗

  • One log path, never double-counted

    The server writes JSON lines to stdout with its process resource; locally a collector tails .forge/logs/<env>/*.log, on a cluster a node agent reads container logs, and trace_id and span_id become each line's trace link.

    ShippedObservabilityDetails ↗

  • Proves telemetry actually arrives

    forge env status reads the store itself and reports which services sent traces, metrics, logs and profiles in the last 15 minutes, and missing evidence is UNDETERMINED, never PASS.

    ShippedObservabilityDetails ↗

  • Trace trees with uninstrumented time

    forge obs trace prints a capped tree with errors and the critical path expanded, linked logs, and how much time went to uninstrumented code.

    ShippedObservabilityDetails ↗

  • Cardinality-safe declared metrics

    Each metric is declared with its unit and attribute keys, and an undeclared attribute panics in development and is dropped and counted in production, so cardinality never silently explodes.

    ShippedObservabilityDetails ↗

  • Continuous CPU and heap profiling

    With profiling on, every process samples a CPU profile every five minutes and a heap snapshot every two hours over OTLP, and forge obs profile exports pprof, speedscope or collapsed stacks; it is on by default with the local ClickStack, and one line turns it on for a hosted or cluster env.

    ShippedObservabilityDetails ↗

  • Uptime and certificate probes

    The platform probes a hosted env's public frontends and routes from outside on a schedule with no declaration, and alerts on failing checks and on certificates expiring within 14 and 3 days.

    ShippedObservabilityDetails ↗

  • Dashboards derived from code

    Process and role dashboards are generated from the deployed commands and the composition graph, and forge obs dashboards audit replays an empty panel to say why it is empty.

    ShippedObservabilityDetails ↗

  • Built-in product analytics dashboards

    A hosted app gets Product overview, Users, Product and Acquisition dashboards and the Overview's Traffic and Users sections with no code: visitors, channels, sign-ups and their attribution, active and new users, retention, goals and funnels.

    ShippedObservabilityDetails ↗

  • Built-in LLM and workflow monitoring

    A hosted app's model calls, agent turns, tool calls and workflow runs get dashboards with no code: runs and their success and duration, tokens, latency, errors and retries by workflow, node, agent, model, provider, user and tool, read from OpenTelemetry GenAI spans.

    ComingObservabilityDetails ↗

  • Release markers on dashboards

    Releases are marked on generated dashboards so a regression lines up with the deploy that caused it.

    ShippedObservabilityDetails ↗

  • Real-user sessions and replay

    The browser SDK reports through a same-origin relay that never forwards cookies or authorization, and forge obs session prints what one user did as a text timeline; replay is opt-in and always masked.

    ShippedObservabilityDetails ↗

  • Send telemetry anywhere

    forge.Observability names any OTLP endpoint, a headers secret reference, the signals and the sampling, and forge renders the collector for the runtime.

    ShippedObservabilityDetails ↗

  • Telemetry for any Node process

    initNodeTelemetry from @reliantlabs/forge-web-runtime/node ships a Node or Electron-main process's logs, uncaught errors and spans to any OTLP/HTTP endpoint, batched, with credential shapes redacted and no OpenTelemetry SDK to configure.

    ShippedObservabilityDetails ↗

  • Telemetry opt-out at the source

    Turning telemetry off for an env, or for one category (traces, metrics, logs, profiles, metadata, browser), means it is never collected or stored, so never billed, and session replay is opt-in.

    ShippedObservabilityDetails ↗

  • Telemetry wired with no keys

    The platform injects the OTLP endpoint and a per-env telemetry token into every hosted pod, so logs, traces and metrics flow with nothing to configure.

    ShippedObservabilityDetails ↗

  • Monitoring for any app

    An app forge never built — any language, any CI, any infrastructure — sends its traces, logs and metrics to Reliant with the standard OTEL_* variables, and forge obs reads its issues, logs and release health.

    ShippedObservabilityDetails ↗

  • Hosted observability store

    Hosted envs store logs, traces, metrics and profiles in the org's own ClickHouse scope, queried by the same forge obs verbs and console as local ClickStack, with quota and opt-out enforced at the source.

    ShippedObservabilityDetails ↗

  • Live panels over your data

    Opt a managed database into dashboards and the console runs live panels as a read-only role that sees only what your migrations GRANT it.

    ShippedObservabilityDetails ↗

  • Audit trail and activity stream

    Every rpc writes a structured audit record, pkg/audit persists a queryable trail, and the activity stream is declared on the rpc and written by one interceptor, never by hand.

    ShippedObservabilityDetails ↗

  • Dashboards edited in the console, kept as code

    Edit a dashboard in the console, restore an earlier version, then promote it into your repository as code.

    ShippedObservabilityDocs ↗

  • Your own observability limits

    Set storage and usage limits for your telemetry, and see what it costs.

    ShippedObservabilityDocs ↗

Stage 6 of 6

Fix

Alerts and errors that reach an agent with the evidence to find the cause.

17 shipped1 beta

Agents & Workflows3

  • An on-call first responder

    Every paging alert and new, regressed or spiking error becomes a GitHub issue investigated read-only, with severity, evidence, suspected cause and a proposed fix.

    ShippedAgents & WorkflowsDetails ↗

  • Alerts reach agents with no wiring

    A webhook: {source: alerting} trigger receives your hosted alerts and new, regressed or spiking errors, with no URL or token to set up.

    ShippedAgents & WorkflowsDocs ↗More →

  • Alert to fix, with a person in between

    On-call files an investigated issue; when a person labels it ready, the issue worker opens the fix as a pull request.

    ShippedAgents & WorkflowsDocs ↗More →

Forge1

  • Audited read-only prod queries

    forge db query runs one statement in a READ ONLY transaction as a role that cannot read forge:secret columns, demands --confirm-env and a reason, and on a hosted env needs the org's db:query grant and records an audit row and an activity event.

    ShippedForgeDetails ↗

Observability14

  • Production alerts out of the box

    Every env gets default alert rules for error rate, latency, silent services, frontend errors and LCP, new, regressed and spiking issues, regressed releases, anomalies, uptime, certificates, crash loops, OOM kills, memory, image pulls, evictions, failed deploys and observability quota, evaluated locally and delivered in-app, to Slack or to PagerDuty when hosted.

    ShippedObservabilityDetails ↗

  • Query prod from the shell

    forge obs logs, traces, trace, metrics, query and the rest answer against the local ClickStack or a hosted env through one query compiler, as JSON with runnable suggested[] next commands.

    ShippedObservabilityDetails ↗

  • Env status and change log

    forge obs status summarizes services, open issues, firing alerts and the release in force; forge obs changes lists promotions, rollbacks, failed deploys and activity.

    ShippedObservabilityDetails ↗

  • Stacks and stable error fingerprints

    Server faults carry a bounded stack and a fingerprint folding in the normalized cause, so one outage is one issue, not six.

    ShippedObservabilityDetails ↗

  • Error issues tied to releases

    Errors group into issues with culprit, frames, trace, events per version and suspect commits, and resolve --in next ties a fix to the next release: events from what is live stay quiet, and an event from a release promoted after the resolve reopens the issue as a regression.

    ShippedObservabilityDetails ↗

  • Grouped errors with real stacks

    Browser and server errors are grouped into issues with triage verbs, and minified browser stacks are symbolicated from source maps that are never served publicly.

    ShippedObservabilityDetails ↗

  • Alerts as code, run locally

    forge.AlertRule, forge.AlertRoute and forge.AlertDefault are KCL validated at render and recorded in the release, and forge obs alerts check|run evaluates them locally through a real Alertmanager.

    ShippedObservabilityDetails ↗

  • Bad releases flagged automatically

    For an env on a control plane, every promotion is judged when its window closes, with the env's declared policy and no client overrides, and a FAIL raises ReleaseRegressed naming the findings, the release and its commit range.

    ShippedObservabilityDetails ↗

  • Backup health you can see

    Deploy status reports base-backup age, WAL archiving and the oldest restorable point separately, and a built-in alert pages when a database's backups are on and failing.

    ShippedObservabilityDetails ↗

  • Alert routing, silences and history

    Route alerts to receivers you can test, silence them during work, and read back what fired.

    ShippedObservabilityDocs ↗

  • From a metric spike to its trace

    Exemplars link a spike on a metric to the exact trace behind it.

    ShippedObservabilityDocs ↗

  • One user’s activity

    Look up what one signed-in user did across your telemetry.

    ShippedObservabilityDocs ↗

  • Agents can loop on telemetry

    Agent queries against your telemetry are rate-limited, so an investigation cannot exhaust your quota.

    ShippedObservabilityDocs ↗

  • Error issues linked to agent chats

    Link an error issue to the agent chat working on it, so the fix and its evidence stay together.

    BetaObservabilityDocs ↗

Limits

What it does not do, stated plainly.

So you can rule it in or out before you start.

  • Hosted frontends are static exports

    Reliant hosting serves a frontend only as a static export: no server-side rendering, server actions, middleware or request-time cookies. A Vite SPA or a statically exportable Next.js app fits as it is; one that needs a server runs as a container on a cluster you run.

    Docs ↗
  • Generated backends are Go

    The API, ORM, handlers and tests Forge generates are Go over Connect RPC, with TypeScript clients. A backend in another language deploys from its Dockerfile with environments, releases, hosting and monitoring, but none of the generated code.

    Docs ↗
  • One hosted region

    Hosted services and managed databases run in one region, GCP us-central1, with no region choice. Static sites are served through the CDN edge.

    Docs ↗
  • Hosted backends do not autoscale

    A hosted service or worker runs the replica count its env declares; it does not scale with traffic, and a managed database does not grow on its own. Raise the replicas or the shape in the env and deploy, or run the workload on a cluster you run with your own autoscaler.

    Docs ↗
  • Hosted profiling is opt-in

    Continuous CPU and heap profiling is on by default only in local dev. A hosted env collects profiles once its env file turns profiles on, which is one line.

    Docs ↗
  • No sign-in gate on deployments

    Hosted URLs, previews included, are public: there is no team sign-in or password in front of a whole deployment. Your app’s sign-in still guards every RPC that does not opt out, but its pages are served to anyone; a private preview can run on a cluster you run behind your own access proxy.

    Docs ↗
  • No hosted cron jobs or operators

    Hosting runs services, workers and jobs. A worker that runs its own schedule runs hosted; a cron job or a Kubernetes operator needs a cluster you run.

    Docs ↗
  • Unclaimed deploys are temporary

    A deploy made with no account goes offline after 72 hours unless its claim link is opened, and an unclaimed service has no outbound internet.

    Docs ↗

Go deeper

Why it fits together, and where to start.

Why one platform

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

Why Reliant

Coming from Vercel? See what each includes, what needs setup, and when Vercel is the better choice.

Reliant vs Vercel

Products

  • Agents & Workflows

    Multi-agent workflows in YAML, Autopilot and triggers, on any model.

  • Forge

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

  • Hosting

    Managed Postgres, static hosting, domains, previews and secrets.

  • Observability

    Traces, logs, metrics, alerts and release verdicts, wired from day one.

Solutions