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.
Issue to pull request
Label an issue ready and an agent works it and opens a tested pull request for review.
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 workflowvalidates, tests, runs and schedules the workflows in your repository.ShippedAgents & WorkflowsDocs ↗
Forge68
One marker, a whole entity
Mark a proto message
// forge:entityand oneforge scaffoldwrites 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 scaffoldbirths 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 disownpermanently hands any generated file to you.ShippedForgeDetails ↗
Exclude paths from codegen
scaffold.excludein 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 generatelists the files it left behind andforge project prune --orphansdeletes the ones still exactly as forge wrote them, never an edited one.ShippedForgeDetails ↗
Guided forge upgrades
forge project upgrademoves a project to a newer forge and applies every mechanical fix for the version range, andforge project upgrade list|applytracks 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 onlyforge.yamlanddeploy/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-runprints 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 persrc/gen, with an opt-in pnpm workspace for sharing code between web and mobile.ShippedForgeDetails ↗
REST and OpenAPI, free
api.openapi: trueemits OpenAPI 3 from the proto in the buf pipeline andconnectrpc.com/vanguardtranscodes 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 inforge project audit --json; nothing is generated from it yet.ShippedForgeDetails ↗
Browsable API inventory
forge generatewritesgen/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.validaterules 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-runtimegives a frontend typed errors with a total.reasonvocabulary, auth and always-ontraceparentinterceptors, 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.tsread at runtime from a per-envconfig.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 workerwrites a supervised component sharing the server's typed Deps and graceful shutdown, with a lifecycle test.ShippedForgeDetails ↗
Coordinated cron and singletons
pkg/cronkitruns 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, andpkg/leasegives a named singleton over Postgres advisory locks with hot standby.ShippedForgeDetails ↗
Operators and CRDs scaffolded
forge scaffold operatorandforge scaffold crdgive a reconciler withpkg/controllerruntime 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 cligives a cobra binary onpkg/cmdkitwith per-binary typed config loadable from a file, and--kind librarygives a Go module with no server.ShippedForgeDetails ↗
Vendor-neutral outbound adapters
forge scaffold adapterwrites one narrow boundary per third-party system, and lint keeps it outbound-only.ShippedForgeDetails ↗
Mobile apps with Expo
forge scaffold frontend --kind mobileproduces an Expo React Native app on the same generated Connect hooks, with an optionalui-nativeworkspace package.ShippedForgeDetails ↗
Correct money type
forge/pkg/moneyrepresents 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_atandupdated_atcolumns give managed timestamps, a time-typeddeleted_atgives 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) andforge:append-onlydeclare who may write a column, and lint makes a field nothing writes a build failure.ShippedForgeDetails ↗
Append-only ledgers, enforced twice
forge:append-onlyremoves Update/Delete from the store and installs a trigger rejecting every UPDATE and DELETE.ShippedForgeDetails ↗
Transactions state their correctness
RunTxhas no default isolation — SERIALIZABLE with retry or a lock under READ COMMITTED, never both — andorm.AfterCommitholds side effects until commit.ShippedForgeDetails ↗
Migration lifecycle commands
forge db migration newallocates a timestamp version,forge db migration rebasere-versions a branch's migrations after everything merged, andforge db migrateandforge db squashapply, inspect and compact them.ShippedForgeDetails ↗
Realistic seed data
forge db seed applymaterializes deterministic, foreign-key-coherent rows from the applied schema, satisfying CHECKs, UNIQUEs, composite keys and status lifecycles, and learns your nouns fromdb/seeds/vocab.yaml.ShippedForgeDetails ↗
Dev database reset and repair
forge db migrate forcerepairs and clears dirty migration state, andforge db resetdrops, recreates, migrates and seeds a dev database (dev only).ShippedForgeDetails ↗
The whole stack, one command
forge env up devbuilds, 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 scaffoldeddevneeds 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_apianswers 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-runor a binary runner, and--targetscopes a whole run to one workload.ShippedForgeDetails ↗
Every dev boot measured
Each
forge env upprints 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 downwalks 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 configprints what an environment hands each workload,forge env execruns a command with it,forge env optionslists the render options andforge doctor paritydiffs host mode against cluster mode.ShippedForgeDetails ↗
Fast, concurrency-safe codegen
forge generatenever overwrites hand-written logic, finishes in seconds withnothing to doon 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 storagereports 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 debugdrives Delve against a running service (breakpoints, stepping, locals, goroutines) from a terminal or an agent.ShippedForgeDetails ↗
Call any rpc from the CLI
forge api curlprints a copy-pasteable curl for any rpc of the project.ShippedForgeDetails ↗
Local Kubernetes when you need it
forge cluster upgives 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 doctorchecks the toolchain, payload caps, probes, resource requests and limits of every declared env with nothing running, andforge doctor paritychecks host mode against cluster mode.ShippedForgeDetails ↗
Pinned toolchain, auto-installed
forge tools installinstalls exactly the tool versions the project pins, so "works on my machine" stops being a variable.ShippedForgeDetails ↗
A 70+ component library
forge component searchandforge component installadd 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 upconverges 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 pullturns the CPU profiles your env collects into each Go binary'scmd/<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,loadandsearchserve 180+ skills built into the forge you run, so an agent never reads guidance written for another version.ShippedForgeDetails ↗
Built-in MCP server
forge mcpexposes 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 --jsonenumerates every command, lint analyzer and marker from the binary itself, andforge project annotationsthe entity-authoring vocabulary, so neither can drift from the code.ShippedForgeDetails ↗
Find any symbol instantly
forge project shapeslocates every rpc, message, table, handler, hook and store with file:line, andproject mapannotates ownership.ShippedForgeDetails ↗
Library API without source diving
forge project libraries <pkg>prints every signature of aforge/pkgpackage, whichgo docrenders asstruct{ ... }, so an agent adopts an existing utility instead of re-implementing it.ShippedForgeDetails ↗
Project state snapshot
forge project audit --jsonreports services, rpcs, entities, drift, unwired stubs and ownership in one document.ShippedForgeDetails ↗
JSON everywhere, with next steps
--jsonon lint, obs, deploy plans and status emits documented schemas with the shared exit codes andsuggested[]next commands an agent runs instead of paraphrasing.ShippedForgeDetails ↗
Bug reports from agents
forge report-bugsends a redacted defect report with evidence, deduplicated, and sends nothing unless invoked;--dry-runprints exactly what would go.ShippedForgeDetails ↗
Agent memory file generated
forge project memoryrenders 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/designskill 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
llmskill 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 forgeis 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 theServicederived from a//forge:contractstruct) gets a recording mock inmock_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.Slowand skips under-short, andforge lint --slow-testsfails 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
-shortor 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-budgetreads ago test -jsonrun and flags unmarked tests that blew the fast-tier budget.ShippedForgeDetails ↗
Skipped-test detection in CI
forge ci verify-test-runreports packages that skipped so much that their pass proves nothing.ShippedForgeDetails ↗
Table-driven tests, batteries included
pkg/tddgives table-driven helpers for rpcs, the database, mocks and e2e, every scaffolded rpc gets a test row to start from, andforge project migrate tddconverts 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.SeedGraphseeds 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/kclevallets 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.
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-safetyrefuses 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 analyzeruns 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 lintruns 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.workflowsin 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-generatedregenerates in a scratch copy and fails when the committed output differs, andforge lint --generated-driftfails 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-suppressedlists 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
--strictescalates advisory findings to errors.ShippedForgeDetails ↗
Switch a lint lane off
lint.lanesin forge.yaml switches wholeforge lintlanes 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 --fixapplies the mechanical fixes (formatting, traced logging, prettier, eslint) and takes back any Go rewrite that breaks its package, and--checkor--no-fixprint each pending fix's diff and fail.ShippedForgeDetails ↗
Codemods for convention moves
forge fixrewrites 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.yamlpins, 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:guardscolumn 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
optionalhas 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-setmust 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_truncover aTIMESTAMPTZ, 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-driftruns 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.goor a//forge:contracttype) 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 --graphfails 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.Getenvor a frontend readingprocess.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.protothat drifted from the binary's copy fails lint instead of compiling annotations nothing reads.ShippedForgeDetails ↗
Breaking API changes gated
A generated
proto-breaking.ymlrunsbuf breaking, so a change that would break existing clients fails CI, and theproto-breakingskill carries the reserved-tag discipline.ShippedForgeDetails ↗
Open signup is deliberate
A bare
forge lintflags 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 --secretschecks 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-exportnames each route, server action,cookies()call ornext/imageuse 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 --tracingnames 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--fixrewrites 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-scanruns 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.ymlsigns 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 auditincludes anunscoped_authlist 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:audiencenames each authenticator's trust domain andforge lint --graphfails 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:ownercolumn 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 gateruns 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_timeout5s, five attempts with backoff,statement_timeout30m, overridable per file), andCREATE INDEX CONCURRENTLYcleans up an invalid index, so one slow reader plus oneALTER TABLEis not an outage.ShippedForgeDetails ↗
Signed, verified forge installs
Every forge release ships checksums and a Sigstore attestation over its archives, and
install.shverifies them (with gh or cosign) before installing.ShippedForgeDetails ↗
Build once, promote by digest
forge env build --releaserecords an immutable set of artifact digests, andforge env deploy prod --from stagingdeploys exactly the bytes that passed staging.ShippedForgeDetails ↗
Deploy anywhere, declare once
A
fw.Workloadis declared once inworkloads.kand 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.OnExternalis 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 newscaffolds 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-kclproves 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 newscaffolds an environment from an existing one, andforge env optionslists the render options it takes.ShippedForgeDetails ↗
Diff your code against deployed
forge env diffrenders this checkout and shows how each environment would change.ShippedForgeDetails ↗
Release lists every declared env
A released bundle carries one
declared_envsentry perdeploy/kcl/<env>/main.k, so the console lists environments that never recorded anything, andforge env status --jsonwith no env prints the whole project's topology.ShippedForgeDetails ↗
Release timeline per environment
Every promotion is an append-only ledger entry, so
forge env releasesanswers 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 recordstep 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 deployprints its plan and writes nothing until confirmed,--plan-onlythen--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
--supersedeis 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
pinnedrefuses every promote with exit 4environment_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|importsays which backend holds an env's ledger and moves history between backends,forge release verifyproves every artifact a release names exists and matches, andforge release bundlediffs 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 previousdeploys 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 aforge:breaks-rollbackmigration or adeploy/rollback-floors/<id>.yamldeclaration 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 byforge env gcon 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.ReleaseHealthon 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.DeliveryPolicydeclares per env what a release must prove, each controloff,auditorenforce:health_gate,signingandflux_verifyare enforced on a control plane,required_gatesandapproval_hookwherever the env's ledger lives, whileprovenance_sbom,trusted_builder,admission_verify,signed_promotions,vuln_gate,bundle_kindsandapprovalsare recorded and refuse nothing yet.BetaForgeDetails ↗
Check results attached to releases
forge gate recordattaches a lint, test, smoke or manual sign-off result to the promotion it is about, with who and when, andforge env deploy --gatereads them; nothing refuses a promotion on a gate's status.BetaForgeDetails ↗
Deploys wait, then smoke-test
forge env deployrecords, applies and waits for health, andforge env smokeprobes every declared ingress route for TLS, routing and CORS.ShippedForgeDetails ↗
Config errors caught before push
forge env build --push,--releaseandforge env deployboot each workload with its rendered env underFORGE_CONFIG_CHECK=1before 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 lintcatches them earlier across every env.ShippedForgeDetails ↗
Override any field, bring any YAML
Bundle.overrides, keyed byKind/name, changes one field of a rendered object without forking the template (a conflict fails the render), andforge.Manifestsbrings your own YAML or Helm chart.ShippedForgeDetails ↗
Connect a cluster you run
forge cluster connectregisters 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-envdeploy.yml,e2e.ymlandpre-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 summarizerenders any--jsonverdict as a job summary, andforge ci runshows 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
HealthGatemakes 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_dashrole granted exactly their columns by migration, with row cap, timeout and concurrency limit.ShippedForgeDetails ↗
Object storage per env
Declare a
forge.Bucketper env (MinIO in dev, any S3-compatible bucket elsewhere) andpkg/blobstorepresigns 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 setrequires 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/accesstokengives 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), andforge cloud tokenmanages 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_issuerandoidc_client_idin 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 doctorchecks 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/netguardrefuses 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.ExternalSecretsand theforge.ExternalSecretsOperatorcomponent for a cluster, a self-runforge.OpenBaowith JWT-only client auth, andforge.ControlPlaneSecretfor a value the control plane renews with no restart.ShippedForgeDetails ↗
No .env files
A bare
forge lintfails on a.envfile, 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 verifycompares a live Secret with its store copy per key — match or no-match, never a value or hash — andadopthands a verified one to ESO.ShippedForgeDetails ↗
Generated keys and certificates
forge generatemints random keys, passwords that meet a complexity policy, and key pairs and certificates into the file secret store.ShippedForgeDetails ↗
Encryption with key rotation
pkg/cryptoseals values with AES-256-GCM under a versioned keyring, so keys rotate without making data unreadable.ShippedForgeDetails ↗
Credentials redacted on the way out
pkg/redactstrips credential shapes and personal paths from text leaving the process, andforge report-bug --dry-runshows exactly what would be sent.ShippedForgeDetails ↗
Probes and zero-drop shutdown
A service gets
/readyzand/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
ManagedDatabasewithrestore = {sourceDatabase, pointInTime}boots from the source's backups replayed to that moment.ShippedHostingDetails ↗
Managed object storage
A declared
forge.Bucketbecomes 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 identitylists, 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> --claimablepublishes 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,startanddeleteoperate a hosted env (delete shows what goes and refuses while a custom domain is bound), andforge env list --orphanedfinds hosted envs the project no longer declares.ShippedHostingDetails ↗
LLM access without a key
Declare
forge.LLM { runtime = forge.OnHosted {} }and give a workloadforge.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 upbrings 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, andtrace_idandspan_idbecome each line's trace link.ShippedObservabilityDetails ↗
Proves telemetry actually arrives
forge env statusreads 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 traceprints 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 profileexports 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 auditreplays 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, andforge obs sessionprints what one user did as a text timeline; replay is opt-in and always masked.ShippedObservabilityDetails ↗
Send telemetry anywhere
forge.Observabilitynames 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
initNodeTelemetryfrom@reliantlabs/forge-web-runtime/nodeships 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, andforge obsreads 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 obsverbs 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/auditpersists 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.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.
Forge1
Audited read-only prod queries
forge db queryruns one statement in a READ ONLY transaction as a role that cannot readforge:secretcolumns, demands--confirm-envand a reason, and on a hosted env needs the org'sdb:querygrant 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,queryand the rest answer against the local ClickStack or a hosted env through one query compiler, as JSON with runnablesuggested[]next commands.ShippedObservabilityDetails ↗
Env status and change log
forge obs statussummarizes services, open issues, firing alerts and the release in force;forge obs changeslists 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 nextties 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.AlertRouteandforge.AlertDefaultare KCL validated at render and recorded in the release, andforge obs alerts check|runevaluates 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
ReleaseRegressednaming 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 ReliantComing from Vercel? See what each includes, what needs setup, and when Vercel is the better choice.
Reliant vs VercelProducts
- 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
- Start a new app
A production-shaped app from the first commit, deployed by your agent.
- 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.