Forge

Forge

Forge is an opinionated, open-source Go + React framework and deploy platformthat ships the production system — dev environments, tests, secrets, multipleenvironments, releases, observability and hosting — from the first commit, builtfor AI agents to work in.

Website · Live demo · Docs · Reliant · Slack

Most teams build that system in year two, under deadline, on top of a codebasethat wasn't shaped for it. With Forge the first commit already has it, wiredinto files you own and can change.

Try it in the browser first: the live demo.

Quick start

# Install (macOS / Linux; Windows, Homebrew, npm and go install: see Install below)
curl -fsSL https://raw.githubusercontent.com/reliant-labs/forge/main/install.sh | sh

forge project new my-app && cd my-app
forge scaffold service billing
forge generate
forge env up dev

That last command brings up Postgres, runs your migrations, and starts yourservices and frontends, then prints a table of URLs and a log file for eachprocess, including the HyperDX UI, already receiving the app's traces, metricsand logs. With a frontend (forge project new my-app --frontend web) it alsostarts a local identity provider, so the app's own sign-in page works on thefirst run. No signup, no external accounts, no cloud project, no cluster.

Add tables (a // forge:entity message and forge scaffold) and a freshdatabase is seeded with foreign-key-coherent rows that satisfy every constraintyour schema declares, so the app boots alive instead of empty.

When you want it online, forge env deploy staging builds a release once anddeploys it. A new project's staging and prod are bound to Reliant hosting; thesame environments deploy to a Kubernetes cluster you run, or as host processes,by changing where each workload is bound. Before you call a change done:forge generate && forge lint && go build ./... && task test.

Everything included

What a new app would otherwise stitch together from separate tools:

Every benefit, with how to use it and the code that backs it: docs/benefits.md (234 entries, 123 lint rules)

Add Reliant and the list grows an agent harness,cloud dev machines, AI code and security review, and an on-call agent. Forgedoesn't need any of them.

Built for your agent

When an agent writes most of the code, the bottleneck stops being how fast youcan write it and becomes knowing whether it's right. Forge is one binary onyour PATH with no plugin, editor extension or server, so anything that can runa shell command can drive it: Claude Code, Codex, Cursor, Copilot, Gemini CLI,Aider, a harness you wrote, or a CI job. A person at a terminal uses the samecommands, so there is nothing an agent can do that you can't check by hand.

• Skills live in the binary. forge skill search <topic> andforge skill load <name> print the playbook for an area, about 150 of them,matched to the installed version. Nothing to paste into a prompt, nothing todrift.
• It explains itself. forge start prints the path from an empty directoryto authored protos. forge project capabilities --json lists every verb, lintanalyzer and marker, enumerated from the binary, so it can't go stale.
• Scaffolding and lints are guardrails against AI slop. forge scaffoldlands each service, rpc, worker or entity in the right place, already wired.forge lint rejects what review misses, names the file, line, rule and fix,and forge lint --quiet ends with the verdict, so the agent reads one line toknow whether it is done.
• It debugs from real telemetry. forge obs status, forge obs issues andforge obs trace read a running app's logs, traces, errors and alerts, so afix starts from what happened rather than a guess.
• Checks never fake a pass. A check that cannot obtain its facts reportsUNDETERMINED, never green, never skipped.
• The project tells the agent all of this. forge project new writesAGENTS.md and a pointer for the agent it detects (Claude Code, Cursor,Copilot). Any MCP-capable harness can run forge mcp instead: seeUse as an MCP server.

To use Forge from any agent, put this in the prompt or its instructions file:

Use Forge (github.com/reliant-labs/forge) for this project.
Run `forge start` first and follow it. Load depth with
`forge skill search <topic>` and `forge skill load <name>`.
A change is done when `forge lint`, `go build ./...` and `task test` pass.

Use as an MCP server

forge mcp serves forge over the Model Context Protocol on stdio. It is in theofficial MCP registry as io.github.reliant-labs/forge, and npx runs it withnothing to install, no API key and no config. For Claude Code:

claude mcp add forge -- npx -y @reliantlabs/forge mcp

Or commit a .mcp.json to the project (Cursor reads the same shape from.cursor/mcp.json):

{
  "mcpServers": {
    "forge": {
      "command": "npx",
      "args": ["-y", "@reliantlabs/forge", "mcp"]
    }
  }
}

deploy_claimable puts a Vite app or a Next.js static export live with noaccount and returns its URL plus a claim link that is good for 72 hours. Theother tools introspect the project, read the skill catalog, and run lint andgenerate. Every tool, and the config for Codex: docs/mcp.md.

Opinionated, never a wall

The opinions come from a principal engineer with more than a decade of buildingreliable systems, and several exist because the unsafe version caused a realincident:

• An error message once shipped a database password to an unauthenticatedcaller. Now svcerr.Wrap replaces unrecognized errors withinternal server error and keeps the original server-side.
• Images built on an arm64 laptop once got pushed to amd64 nodes. Now cloudtargets require an explicit platform, and it fails at author time.
• Replicas once half-migrated a schema. Now migrations apply from aninitContainer under a Postgres advisory lock, and a failed one stalls therollout with the old pods still serving.

Every default is overridable and every generated file has an owned seam besideit:

• An ORM you can drop out of to raw SQL.
• A middleware chain in a serve.go you own and can reorder.
• pkg/ as a library you import, not a framework you live inside.
• Each workload binds to a host process, Compose, a cluster you operate orReliant hosting, in the same KCL. It deploys code it never compiled, in anylanguage: our own control plane builds three services out of a separaterepository that Forge never compiles.

More in docs/concepts.md.

Who this isn't for

• You don't want generated code in your repo. Forge writes real files andregenerates them; if you'd rather hand-author everything, the ownership modelis overhead.
• You need a REST-first public API. Connect RPC is the native surface; RESTURLs are available via Vanguard, but a hand-shaped OpenAPI contract worksagainst the grain.
• Postgres isn't your database. MySQL, SQLite and non-relational storesaren't supported.
• Your backend isn't a container. A service deploys as an image (staticsites are the exception: they ship as files).
• You want a framework you'll outgrow and replace. Forge holds structure forthe life of the project; for a one-time scaffold, use a template repo.

Install

All of them give you a single forge binary; none needs a C toolchain.

# macOS / Linux (amd64, arm64): no sudo, no prompts, checks the release's sha256
curl -fsSL https://raw.githubusercontent.com/reliant-labs/forge/main/install.sh | sh

# Windows (amd64, arm64)
irm https://raw.githubusercontent.com/reliant-labs/forge/main/install.ps1 | iex

# Homebrew (macOS and Linux)
brew install reliant-labs/reliant/forge

# npm / npx: downloads the same verified binary on first run
npx @reliantlabs/forge version

# Go toolchain
go install github.com/reliant-labs/forge/cmd/forge@latest

Pinning a version for CI, verifying a release's signature, and building from aclone: docs/install.md.

Learn more

• Forge user guide: quick start, project anatomy, environments and deploys, hosting, secrets, domains, observability, troubleshooting
• docs/getting-started.md: the first journey from a checkout, and which files are yours
• docs/concepts.md: why Forge is shaped this way
• docs/benefits.md: every benefit, how to use it and the code that backs it
• docs/mcp.md: forge mcp for Claude Code, Codex and Cursor
• CONTRIBUTING.md: the dev loop, pre-commit hooks and PR process

License

Copyright 2025-2026 Reliant Labs, Inc. Licensed under theApache License, Version 2.0; see also NOTICE. Thatcovers all of forge: the CLI, the github.com/reliant-labs/forge/pkg/...libraries your services import, the KCL modules, and the@reliantlabs/forge-web-runtime npm package your frontends bundle.

Earlier versions. Forge versions published before this change werereleased under the Business Source License 1.1. Reliant Labs, Inc., as theircopyright holder, also licenses every one of those versions — every commit ofthis repository, tagged or not, and every published version of@reliantlabs/forge-web-runtime — under the Apache License, Version 2.0. Youmay use any of them under either license.

What forge writes into your project is yours. Generated code, scaffoldedfiles, and the components forge copies into your frontends become part ofyour project. Where any of that output reproduces or derives from forge's owntemplates or component library, Reliant Labs, Inc. grants you a perpetual,worldwide, non-exclusive, no-charge, royalty-free, irrevocable license to use,reproduce, modify, sublicense and distribute it under terms of your choice,without any obligation to carry forge's license text, NOTICE or otherattribution. This grant covers that output only. Forge itself, including thelibraries and packages your project depends on, stays under the ApacheLicense 2.0.