Why Reliant
One platform. Every seam known.
Most stacks are stitched together: a framework from one vendor, CI from another, then hosting, logs, alerts, secrets and an AI assistant from five more. None of them knows what the others know, so every integration is glue you write and every agent works blind.
Reliant owns the whole path, so it knows your services, RPCs, schema, config, secrets, releases, metrics and alerts. Those standardized seams let us, and your agents, do what a stitched stack can’t.
The seams
A stitched stack vs one platform.
The seams are where one part of your software meets another: services, RPCs, schema, config, secrets, releases, metrics and alerts. In a stitched stack each vendor sees its own side of a seam. In Reliant every layer reads the same declarations.
A stitched stack
- Framework
- CI
- Hosting
- Logs
- Alerts
- Secrets
- AI assistant
Seven vendors, seven data models. The glue between them is yours to write and keep working.
Reliant
- Services
- RPCs
- Schema
- Config
- Secrets
- Releases
- Metrics
- Alerts
One data model, read by the framework, the release pipeline, hosting, telemetry and every agent.
Services
In a stitched stack: The framework defines them, the host sees containers, and the tracer sees whatever you remembered to instrument.
In Reliant: Discovered from the code that declares them. Hosting, dashboards and lint read the same list.
RPCs
In a stitched stack: Your monitoring sees URLs. It doesn’t know which ones are your API or what they return.
In Reliant: Each RPC in the proto is one span, one metric and one log record, with no tracing code to write.
Schema
In a stitched stack: Migrations live in one tool. The deploy tool doesn’t know they exist until pods crash.
In Reliant: Migrations are the schema. A release records the ones it carries, and the deploy refuses them out of order.
Config
In a stitched stack: Environment variables copied between dashboards, drifting quietly.
In Reliant: Typed per-environment config in the repo, diffed between environments before a deploy.
Secrets
In a stitched stack: Values pasted into CI, the host and, sooner or later, an agent’s context.
In Reliant: Declared by reference and write-only on hosting. Agents use them in calls without seeing them.
Releases
In a stitched stack: CI builds, the host deploys, and nothing records which bytes run where.
In Reliant: Built once, promoted by digest, recorded in a ledger for every environment.
Metrics
In a stitched stack: Dashboards you build by hand, with no idea a release went out.
In Reliant: Generated dashboards with release markers, and each release judged against the window before it.
Alerts
In a stitched stack: A page to a person, who opens five tabs to find out what changed.
In Reliant: Default alerts that can start an agent workflow with no wiring, tied to the release that was running.
Configured for you
Features you’re paying for but not using.
Your host, your APM and your error tracker all offer these. Each one waits for you to turn it on, wire it up, pay for it separately or instrument your own code, so most of them never get done. Forge writes them into your app instead, so they’re on from the first deploy, and your agents use all of them.
Traces and per-RPC metrics
On a stitched stack: Install an OpenTelemetry SDK, wrap your handlers and clients, and pick a vendor to send it to.
- SDK install
- Code changes
- Separate vendor
On Reliant: Every RPC is a span, a metric and a log record, and every service call and query a child span.
Why it’s on: Forge generated the handlers, so it generated the instrumentation with them.
Dashboards
On a stitched stack: Build them by hand in your APM, then rebuild them each time your API changes.
- Separate vendor
- Config by hand
On Reliant: A dashboard per service with a row for every RPC, with each release marked on it.
Why it’s on: Generated from the services you deployed, and shipped with every release.
Alerts
On a stitched stack: Write rules for error rate, latency, crash loops and certificates, then route each one somewhere.
- Separate vendor
- Config by hand
On Reliant: Default rules for error rate, latency, silent services, frontend errors, crash loops, failed deploys, uptime and expiring certificates, sent to the app, Slack or PagerDuty.
Why it’s on: Forge knows every service and frontend, so it declares the rules as code beside them.
Error tracking
On a stitched stack: Add your error tracker’s SDK to every service and frontend, and upload source maps from CI.
- SDK install
- CI wiring
- Separate vendor
On Reliant: Errors grouped into issues with real stacks, each tied to the release that opened it.
Why it’s on: Forge’s error layer and the release ledger are the same platform.
Release health
On a stitched stack: Eyeball dashboards after each deploy, or wire a canary-analysis tool into your pipeline.
- CI wiring
- Separate vendor
On Reliant: Every promotion is judged against the window before it, per service, and a regression raises an alert naming the release. One declaration gates prod on staging’s verdict.
Why it’s on: Forge knows your RPCs, and hosting knows which release is serving.
Preview environments
On a stitched stack: Script an environment, a database and its teardown per pull request in CI.
- CI wiring
- Config by hand
On Reliant: A full environment per pull request, copied from a template env and deleted when it expires; you add two commands to your CI.
Why it’s on: A preview is an ordinary environment, so every deploy and monitoring feature works on it.
Secrets
On a stitched stack: Copy values between dashboards and .env files, or add a secrets manager and its client.
- Separate vendor
- Config by hand
On Reliant: Declared once as references and bound per environment. Hosted values are write-only, and a workflow you allow with forge secret allow uses a secret in HTTP calls without the agent seeing it.
Why it’s on: The config schema is generated, so every secret has one declared place.
Sign-in
On a stitched stack: Choose an auth vendor, install its SDK and guard each route by hand.
- Separate vendor
- SDK install
- Code changes
On Reliant: Passwords, passkeys, magic links and social sign-in, and every RPC requires a signed-in caller unless its proto says otherwise. Who may do what is still your code.
Why it’s on: Auth is declared per RPC in the proto, so a forgotten check fails closed.
Continuous profiling
On a stitched stack: Add a profiling agent to each service and a vendor to store the profiles.
- SDK install
- Separate vendor
On Reliant: CPU and heap profiles from every process: on in local dev, one line of config for a hosted environment.
Why it’s on: Forge renders the telemetry pipeline, so profiles travel with traces and logs.
Slow-query analysis
On a stitched stack: Turn on query statistics in your database and read EXPLAIN plans in a separate tool.
- Separate vendor
- Config by hand
On Reliant: Capture every query shape your tests run, then EXPLAIN them with one command; pending migrations are measured for locks on a real copy.
Why it’s on: Forge generated the ORM, so it knows every query and the call site behind it.
Product analytics
On a stitched stack: Install an analytics SDK, add it to every page and send events to another vendor.
- SDK install
- Code changes
- Separate vendor
On Reliant: A hosted app gets product analytics dashboards with no code: visitors, channels, sign-ups, active and new users, retention, goals and funnels, counted without cookies.
Why it’s on: Product events ride the same telemetry pipeline as everything else.
Because we know the seams
What a platform that knows your app can do.
Each of these joins layers that live with different vendors in a stitched stack. None of them is a feature you could add to one layer alone.
Because Forge reads your proto and your migrations
Your agent generates the plumbing instead of spending tokens writing it.
One proto definition generates the Connect handlers, CRUD wiring, typed frontend hooks and tests, so the API, server and UI cannot disagree. Mark a message as an entity and one command writes its migration, CRUD RPCs, ORM, lifecycle test and pages. The agent’s effort goes into your product’s logic.
Two sources of truthJoins: Forge
Because Forge generates every RPC and Reliant hosts the telemetry
Every release gets a verdict, and prod can wait for staging’s.
Every RPC is measured at the edge from day one.
forge obs checkcompares the window after a promotion with the equal window before it, per service, and lists what the release opened: new and regressed issues, firing alerts, restarts. On Reliant hosting, an opt-in health gate holds a prod promote until staging’s verdict for that release is a pass.Judging a deploy with forge obsJoins: Forge + Observability + Hosting
Because Forge knows your migrations and the releases that carry them
A migration that would lock prod is caught before it ships.
forge db analyzeruns pending migrations on a disposable copy of a real Postgres database and reports the locks they took and the tables they rewrote. Every migration runs with a lock timeout, so one slow reader cannot wedge prod. We roll forward, and a rollback floor stops anyone rolling an environment back past a breaking migration.Migration rulesJoins: Forge + Hosting
Because Reliant both ships the release and collects its errors
An error arrives tied to the release that caused it.
Errors group into issues with the culprit, frames, trace, events per version and suspect commits. Resolving an issue
--in nextties the fix to a release, so the error coming back counts as a regression. On hosting, a release that fails its verdict raises a ReleaseRegressed alert naming the release and its commit range.Issues and releasesJoins: Observability + Forge
Because the alerts are ours
An alert reaches an agent with no URL or token to set up.
A
webhook: {source: alerting}automation receives your hosted alerts and new, regressed or spiking error issues. Autopilot’s on-call agent turns each into one deduplicated GitHub issue and investigates it read-only. A person approves the fix, an agent opens the pull request, and you decide when it merges.Alerting webhooksJoins: Observability + Agents & Workflows
Because the schema drives the API, the ORM and the pages
Who may write a column is declared once, and lint holds the code to it.
Markers such as
forge:read-only,forge:computed,forge:immutableandforge:versiondeclare who may write a column. Lint holds the code to them: a read-only or computed field that nothing writes fails the build instead of shipping a silent zero in every row.Schema and write rulesJoins: Forge
Because Forge knows which columns hold secrets
Production data, read without reading your secrets.
forge db queryruns one statement in a read-only transaction as a role that Postgres itself refuses onforge:secretcolumns. A column named like a credential that nobody has marked fails lint. On hosting, a query needs the organization’s grant, runs under a person’s sign-in and leaves an audit record.Reading the databaseJoins: Forge + Hosting
Because the secrets and the agents run on one platform
Agents use secrets without ever seeing them.
Integration steps and
http/request@1call an API with a saved credential the agent never sees. Hosted secrets are write-only: set once, never read back, scoped to one environment, and each lists the workflows that may use it (forge secret allow).Calling any APIJoins: Agents & Workflows + Hosting
Because every RPC is declared in one place
Auth fails closed, and lint finds RPCs that ignore the caller.
Every RPC needs a valid credential unless its proto opts it out, so a forgotten annotation never publishes an endpoint. An audit lists signed-in RPCs that never check who is calling, and an owner column scaffolds row scoping for you to build on.
Sign-inJoins: Forge
Because we know what evidence should exist
Missing telemetry is undetermined, never green.
When a service sent no traces, metrics or logs,
forge env statusreports it as undetermined, andforge obs checkanswers “could not tell” with its own exit code. A skipped check is never reported as a pass, to you or to an agent deciding what to do next.Observability for agentsJoins: Forge + Observability
Why Forge
The same argument, from Forge’s own registry.
Forge keeps its reasons next to its benefits, and a test checks every benefit’s evidence against the forge binary, so a reason cannot claim what Forge does not ship. Each one is open-source Forge unless it is tagged.
Forge knows your whole app, so its tools share one model of it
Because forge reads the proto, the applied migrations, the composition graph and the env declarations as its inputs, it can generate the handlers, ORM and hooks, check the wiring as a graph, and print where every symbol lives from the same facts, so none of them can disagree.
See it:
forge project shapesBacked by 7 benefits
- Proto in, full stack out
- SQL migrations are the schema
- Browsable API inventory
- Wiring checked as a graph
- Deploy anywhere, declare once
- Find any symbol instantly
- Capabilities introspection
Every RPC traced, measured and logged with no instrumentation code
Because forge generates the RPC edge and holds a contract for every component, it can wrap each one in telemetry, derive dashboards from the composition graph, and name every place a request's trace is cut.
See it:
forge obs endpoints devBacked by 11 benefits
- Every request traced and measured
- Package contracts enforced
- Broken-trace detection and fixes
- Dashboards derived from code
- Observability stack included
- Query prod from the shell
- Proves telemetry actually arrives
- Trace trees with uninstrumented time
- Continuous CPU and heap profiling
- Profile-guided builds from production
- Real-user sessions and replay
Each release judged by its own telemetry and tied to the errors it causes
Because forge both cuts the release and owns its telemetry, it can mark releases on dashboards, judge each promotion with the env's declared policy, and resolve an issue in the next release so that a later event from an older one counts as a regression.
See it:
forge obs check prod --waitBacked by 8 benefits
- Prove each deploy is good
- Release health policy as code
- Release markers on dashboards
- Error issues tied to releases
- Release timeline per environment
- Production alerts out of the box
- Bad releases flagged automatically· Reliant hosting
- Prod gated on staging's verdict· Reliant hosting
Build once and promote the same bytes from staging to prod
Because forge builds the release, records it on a ledger and renders every env from the same declaration, it can promote by digest, show how each env would change, refuse a promote that raced a hotfix, and refuse a deploy below an env's rollback floor.
See it:
forge env diff prodBacked by 12 benefits
- Build once, promote by digest
- Runtime frontend config per env
- Environments as typed code
- One env base, per-env deltas
- Config errors caught before push
- Pre-deploy parity verification
- Diff your code against deployed
- Deploy plans with binding approval
- Compare-and-set promotions
- Deploys wait, then smoke-test
- Roll-forward recovery
- Rollback floors per environment
Database migrations checked against the running release before they ship
Because the migrations are the schema forge projects its ORM from, and forge cuts the release that carries them, it can lint each one against what a running release survives, apply them before the rollout, and raise a rollback floor when one declares that it breaks rollback.
See it:
forge lint --migration-safetyBacked by 9 benefits
- SQL migrations are the schema
- Migration safety checks
- Measured migration locks and rewrites
- Migration lock and statement timeouts
- Migrations gate every rollout
- Out-of-order migrations refused
- Rollback floors per environment
- Backups and point-in-time restore· Reliant hosting
- Restores are drilled, not assumed· Reliant hosting
Lint that knows your architecture, not just your syntax
Because forge generated the seams (entities, filters, the composition graph, the auth chain, the static export), it can check how your code uses them, and run the whole CI gate locally with one command.
See it:
forge lintBacked by 12 benefits
- Bug-class linters, one verdict
- The whole CI gate, locally
- Unwritten read-only field detection
- List filters that actually filter
- Wiring checked as a graph
- Find rpcs that ignore the caller
- Data-integrity rules
- Static-export breakage caught early
- Breaking API changes gated
- Stale codegen can't merge
- Skipped lint lanes fail the gate
- New rules warn before gating
Secure by default, with auth that fails closed and secrets out of git
Because forge owns the interceptor chain, the env render and the build, it can make the safe path the default one and lint for the rest: unscoped RPCs, secret keys nothing produces, and credential-shaped columns the read-only role could see.
Backed by 12 benefits
- Auth that fails closed
- Errors never leak internals
- Secrets never in git
- No .env files
- Secrets wiring verified per env
- Credential columns need a decision
- Find rpcs that ignore the caller
- Dependency and image scanning
- Signed images, SBOM and provenance
- Rate limits, idempotency, webhook checks
- Outbound SSRF guard
- Audited read-only prod queries
Built for AI agents, with a project that explains itself and gates that check the work
Because forge knows the layout, its own commands and every symbol's file and line, it can tell an agent where code goes and what to run next, over the CLI or MCP, from the same binary that enforces the rules.
See it:
forge project capabilitiesBacked by 12 benefits
- Skills that match your forge
- Built-in MCP server
- Hosted MCP connector· Reliant
- Capabilities introspection
- Find any symbol instantly
- Project state snapshot
- JSON everywhere, with next steps
- Exit codes pipelines can branch on
- Predictable project layout
- One marker, a whole entity
- A generated mock per interface
- Bug-class linters, one verdict
Tests against a real Postgres that still run in the fast tier
Because forge knows each package's contract and the applied schema, it can generate the mocks and the migrated test database, and lint the tests that would make the fast tier slow or its cache unsound.
Backed by 11 benefits
- A generated mock per interface
- Real Postgres in every test
- Unit, integration and e2e tiers
- CRUD tests come free
- Flow tests over real data
- Table-driven tests, batteries included
- Slow-test gating for the fast tier
- Go test cache soundness checks
- Skipped-test detection in CI
- Test-hygiene rules
- Test fixtures checked against schema
Production from the first commit, with the whole stack on your laptop
Because dev is an environment declared like prod, from the same workloads, forge can run it as host processes with the probes, sign-in and telemetry production gets, configured differently.
See it:
forge env up devBacked by 9 benefits
- Production from the first commit
- The whole stack, one command
- A dev stack per worktree
- Browser console logs on disk
- Hot reload per workload
- Real sign-in locally, no setup
- Observability stack included
- Probes and zero-drop shutdown
- Build UI before the backend
Adopt it piece by piece in any repo, and keep the tools you already run
Because every part of forge reads a declaration rather than assuming its own stack, each part can be bound to what you already run: a deploy hook, your migration command, an OIDC issuer, any OTLP endpoint, or a cluster you operate.
See it:
forge project benefitsBacked by 12 benefits
- Adopt an existing app
- Adopt any Vite or Next app
- Exclude paths from codegen
- Keep your migration tool
- Keep your deploy tool
- Record deploys from existing CI
- Bring your own IdP
- Send telemetry anywhere
- Disown any generated file
- Override any field, bring any YAML
- Connect a cluster you run
- Monitoring for any app· Reliant hosting
Reliant hosting wires Postgres, secrets, telemetry and domains from your declarationsReliant hosting
Because the platform reads the same declarations forge renders, it can provision and wire each resource with no keys to copy, and because Reliant's agents use forge's own tools, they act within its plans.
See it:
forge env status prodBacked by 12 benefits
- Staging and prod hosted by default· Reliant hosting
- Managed Postgres· Reliant hosting
- Backups and point-in-time restore· Reliant hosting
- Managed object storage· Reliant hosting
- Write-only hosted secrets· Reliant hosting
- Telemetry wired with no keys· Reliant hosting
- Custom domains with automatic HTTPS· Reliant hosting
- Static hosting with a CDN· Reliant hosting
- A live URL on deploy· Reliant hosting
- An on-call first responder· Reliant
- AI code and security review· Reliant
- Agents deploy with guardrails· Reliant
Opinionated defaults, no walls
Start with any piece. Leave any time.
The defaults are opinionated because the seams only work when they are standard. None of them is a wall.
Start anywhere, in any repo
Adopt an existing app in any language without a rewrite, send only its telemetry, or record the deploys your own CI already does.
Bring your own pieces
Point at your own database, identity provider or OpenTelemetry backend in config. Every generated file has a file of yours beside it to change what it does.
Deploy where you like
The same declaration deploys to Reliant hosting, your own Kubernetes cluster, Docker Compose or plain host processes.
Leave with everything
Forge is open source, the code it writes is yours, and your schema, config and environments are files in your repo.
The limits, stated plainly
- Hosted frontends are static exports: no server rendering on Reliant hosting.
- Generated backends are Go. Apps in other languages deploy and are monitored, without the codegen.
- Hosting runs in one region, us-central1.
- Hosted backends run the replica count you declare; they do not autoscale.
- Hosted profiling is opt-in: one line in the env turns it on.
- Hosted URLs, previews included, are public: no team sign-in in front of a deployment.
- Hosting runs services, workers and jobs. Cron-kind workloads and operators need a cluster you run.
- A deploy made without an account expires after 72 hours unless you claim it.
The platform
Four products, one data model.
Use one, or all four. Each reads the same seams, so each is better for the others being there.
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.
Start from the job
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.
See the seams at work.
The feature catalog walks the lifecycle from build to fix, with a status on every row.