Agents & workflows
Put agents to work on your repository: run the built-in workflows, write your own, and start them from schedules, webhooks and GitHub events. The workflows overview is the reference.Autopilot
Five built-in workflows that review pull requests, work issues, answer review feedback and triage alerts. None merge.
Get It Right
An implement, check and review loop for changes in a complex existing codebase.
Best of Three
Three agents implement the same task in separate workspaces, and a reviewer picks or combines the best.
Create a Workflow
Describe what you want to automate, and Reliant scopes, builds and tests the workflow with you.
Review every pull request with an AI agent
Get an AI code review on every GitHub pull request: turn on Autopilot PR review for your repositories, then read, skip or re-run the review the bot posts.
Turn labelled GitHub issues into pull requests with AI
Label a GitHub issue agent:ready and an AI agent writes a failing test and the fix, runs your checks and opens a pull request for a person to review and merge.
Turn production alerts into GitHub issues with an on-call agent
Get one investigated GitHub issue per new production alert or error: turn on Autopilot on-call, which deduplicates, reads the code and writes up a likely cause.
Go from a production error to a reviewed fix
Take a production error to a merged, deployed fix: an on-call agent files an investigated issue, you approve it, and an agent opens a pull request you review.
Add an AI security code review to every pull request
Get a security review on each GitHub pull request: turn on Autopilot security review for a repository, then read the findings it posts by severity, with evidence and a fix.
Have an agent address pull request review comments
Let an agent act on review feedback: it changes the code, runs your checks, pushes to the pull request’s own branch and replies in each review thread.
Write your first multi-agent workflow in YAML
Build a multi-agent coding workflow in YAML: a planner, an implementer and a reviewer that sends work back, checked locally, then run on your machine.
Loop an AI agent until your tests pass
Have an AI agent fix code, run your test command and try again until the tests pass, with a cap on attempts so a run that cannot succeed stops on its own.
Require human approval before an AI agent acts
Pause an agent workflow until a person approves. Gate the change on an approval node, handle approve, deny and timeout, and ask questions mid-run.
Run parallel coding agents in separate git worktrees
Run two AI coding agents at once, each in its own git worktree and branch, wait for both with a join, and have a reviewer agent pick the change to keep.
Delegate work to parallel AI sub-agents
Have one agent split a task across parallel AI sub-agents: a shared plan, a briefing file, spawn in one turn, then steer, stop and combine the results.
Use a different AI model for each workflow step
Route each workflow step to its own model: a fast tier for quick reads, a flagship that thinks hard for the step that must be right, and an exact model id.
Test AI agent workflows with scenarios before you ship
Test every path of an AI agent workflow before it runs for real: mock agents and commands in scenarios, run them locally, and read the mismatch when one fails.
Give your AI agents a new tool with an MCP server
Add an MCP server to a Reliant project, hand its tools to agents through a preset, and use that preset in a workflow node that calls the new tool.
Lint AI workflows that run when nobody is watching
Find the steps in an AI agent workflow that hang, loop forever or fail silently when it runs unattended: run reliant workflow lint, then fix each finding.
Pause, steer and resume a running AI agent workflow
Pause a running agent workflow from the terminal, change its mode or send it new instructions, then resume it from the same point and check how it ended.
Run an AI agent on a schedule with cron
Run an AI agent on a cron schedule: create a schedule trigger with reliant trigger create, or declare one in a workflow, then check each firing and its run.
Run an automated vulnerability scan that files GitHub issues
Scan your dependencies for known vulnerabilities every night and file a GitHub issue when the scan fails, with a workflow you write that needs no AI model.
Post an AI Slack digest every morning with an agent
Post an AI-written digest of yesterday’s merged pull requests to a Slack channel every weekday, from a scheduled workflow that runs with no machine.
Build an AI Slack bot that answers in threads
Build an AI Slack bot: when someone mentions it, an agent researches the question on the web and replies in the same thread, with no machine of yours running.
Start an AI agent run from any webhook
Start an AI agent run whenever your CI or any tool POSTs to a URL: declare a webhook trigger, enable it, send a test with curl and open the run it started.
Call any API from a workflow without exposing the key
Call an API that needs a key from a Reliant workflow while no step, model or log ever holds the value: store it, declare it, allow the workflow, and run it.
Run a Reliant workflow from GitHub Actions
Start a Reliant workflow from a GitHub Actions job, stream its progress into the job log, and fail the job when the run fails, using an API token secret.
Run one workflow when another finishes or fails
Chain Reliant workflows with a workflow_event trigger: start a follow-up run whenever another workflow’s run fails, finishes or waits for a person.
Triage incoming Gmail with an AI agent
Have an agent classify every new Gmail message, email you a summary of urgent ones and acknowledge the ones that need a reply, with no machine running.
Answer SMS and WhatsApp messages with an AI agent
Build an AI agent that answers text messages: when one of your Twilio numbers gets an SMS or WhatsApp message, it replies from your FAQ, with no machine running.
Start and follow agent runs from a Go service
Start a Reliant workflow from Go code, follow it to a pass or fail verdict, put its question to a person, and fire an automation, with the Go SDK.
Stream a live agent chat with the TypeScript SDK
Follow a Reliant run’s chat live from TypeScript: messages, questions and workflow status as they happen, resumed from a saved cursor after a disconnect.
How Reliant workflows run: nodes, edges, CEL, durable execution
How a Reliant workflow runs: nodes as steps, CEL edges that choose the next one, loops and joins, approvals that wait idle, and runs that survive restarts.
How sub-agents and threads isolate context
How Reliant sub-agents keep their own threads: two levels of nesting, concurrency caps, a shared plan, queued messages, and worktrees for parallel edits.
How Reliant automations fire: schedules, webhooks, events
How a schedule, webhook, app event or finished run becomes an unattended agent run: dedupe, filters, overlap, concurrency, AI funding and machine wake-up.
How integrations act for you without exposing credentials
How Reliant’s integrations call GitHub, Slack, Gmail, Twilio and any API for your agents while the token stays on the server and out of every prompt.
How AI agents operate production safely on Reliant
How Reliant lets AI agents investigate alerts, read production data and open fixes: read-only access, rate limits, an audit trail and a person at every gate.
Machines & daemons
Choose where agents run: your own computer, a server or a Reliant cloud machine, connected by a daemon. The machines overview is the reference.Connect your computer to Reliant to run AI agents on it
Run AI agents in a repo on your own computer: start the Reliant daemon, approve its pairing code in the app, and check that its stream is connected.
Run the Reliant daemon headless on a server or Raspberry Pi
Turn a Linux server or 64-bit Raspberry Pi into an always-on machine for AI coding agents: connect it with an access token and keep it up with systemd.
Choose which machine runs each workflow step
Send a whole workflow, or one step of it, to a machine you choose with daemon:, by name, by kind or by label, and check where each step actually ran.
Start, stop and resize cloud machines from the CLI
Control your Reliant cloud dev environment from a terminal: list machines, stop one to save hours, resize it while suspended, start it, and rename it.
Share a localhost URL from a dev server on your machine
Turn a dev server on a Reliant cloud machine into a link: get its URL with reliant preview-url, open it yourself, then make the port public or token-only.
Run AI agent commands without access to your credentials
Sandbox an AI agent’s shell: set credentials: none so commands that read untrusted issues or PRs can’t reach your git, GitHub, SSH or cloud logins.
Fix a Reliant machine that is offline or won't connect
Get an offline Reliant machine working again: read what the chat says, check the daemon’s stream, fix its credentials, and let the paused run resume.
Run several daemons and accounts on one computer
Run one Reliant daemon per checkout or per account on the same computer, see which instance each directory maps to, and check, read or stop any of them by name.
Reclaim worktree disk space and restore reclaimed work
Free the disk idle git worktrees hold on a Reliant machine, decide on the ones with unsaved work, and restore a reclaimed worktree from its capture.
Run a local LLM coding agent with Ollama, LM Studio or vLLM
Serve a model with Ollama, LM Studio, llama.cpp or vLLM on your own machine, then run a workflow where a local model drafts and a cloud model reviews.
Use your Claude or ChatGPT subscription with Reliant
Sign in with the Claude, ChatGPT, GitHub Copilot or Google plan you already pay for, so Reliant’s coding agents run on it instead of API credit.
How a tool call reaches your machine
How an agent’s tool call travels from the cloud worker through NATS and the gateway to the daemon on your machine, and what happens when the link drops.
How the Reliant daemon keeps credentials on your machine
How a machine proves who it is to Reliant, what an agent’s commands can reach on it, what credentials: none hides, and what leaves the machine.
How chats, workspaces and machines fit together
Which machine a chat runs on, why a branched chat stays on the machine that holds its workspace, and what switching, sleeping and removing a machine do.
Forge
Build a Go and React app with Forge: start a project, add features from the schema and the API, and keep it tested and secure. The Forge overview is the reference.Build a Go and React app with Connect RPC and Postgres
Create a Go Connect RPC service, a Postgres table and a React frontend with Forge, then run the whole stack on your machine with no account.
Build a production app from one prompt with AI agents
Describe an app in one message, and the Build an App workflow scopes, scaffolds, tests and reviews a Forge project you own, then serves it on your machine.
Deploy a Vite or Next.js static site with a CDN
Put a Vite or Next.js static site on Reliant’s free static hosting behind a CDN: build one release, deploy it to prod, check the live URL, then clean up.
Deploy an existing app from its Dockerfile, in any language
Adopt an Express, Django or Rails app where it stands: Forge reads its Dockerfile and compose file, writes the deploy config, and ships it to Reliant hosting.
Adopt an existing Vite or Next.js app with Forge, in place
Turn the Vite or Next.js app you already have into a Forge static site without moving a file, check its static export, and mirror browser logs to disk.
Migrate an existing Go app to Forge with Move to Forge
Port a Go codebase into a new Forge project with the Move to Forge workflow: approve a plan, then agents port it one component at a time behind green gates.
Add an Expo mobile app to a Forge backend
Scaffold an Expo React Native app beside your Forge API, call it through the same generated React Query hooks the web frontend uses, and bundle it.
Add a database table with a CRUD API and pages
Generate a Postgres table, five CRUD RPCs, typed React hooks and list, detail and edit pages from one proto message marked // forge:entity.
Add a custom Connect RPC Go handler with typed React hooks
Declare a Connect RPC in proto, scaffold its Go handler, return errors with svcerr.Wrap, and call it from React through the generated, typed mutation hook.
Add a Go cron job or background worker to a Forge service
Scaffold a Go cron job worker that fires each tick on one replica, run it locally, and ship it hosted inside your API workload with no extra infrastructure.
Add sign-in with passkeys, magic links or social login
Turn on passkeys, magic links and Google or GitHub sign-in by declaring them in KCL, then choose which RPCs and pages stay public and read the caller in Go.
Scope rows to their owner in a multi-tenant API
Make each signed-in user see and change only their own rows: declare a forge:owner column, finish the scaffolded owner filter and prove it with a two-user test.
Call an LLM from your deployed app without managing API keys
Give a hosted Forge API a capped, per-environment model key: declare forge.LLM, add forge.llm_env(), and call the official Anthropic or OpenAI SDK unmodified.
Expose REST endpoints and an OpenAPI spec from a Connect API
Serve plain REST URLs such as GET /v1/products from your existing Connect RPC handlers, and generate an OpenAPI 3 spec from the same proto, with no second API.
Build the UI before the backend with mock mode
Run your Forge frontend with no API: every RPC answers from generated fixtures, and named scenarios stub the states you design for, such as an empty list.
Write zero-downtime Postgres migrations and lint them
Change a live Postgres schema without breaking the release that is still serving: declare compatibility, expand then contract, and lint each migration.
Measure migration locks and table rewrites before production
See which Postgres locks, table rewrites and full scans each pending migration causes, on a disposable database, before the migration reaches production.
Let AI agents query production data read-only
Give an AI agent audited, read-only SQL access to production with forge db query: Postgres withholds secret columns, refuses writes and every query is recorded.
Seed realistic Postgres development data from your schema
Fill your dev Postgres with foreign-key-consistent rows that read like your product: auto-seed on env up, your domain words in vocab.yaml, then db seed reset.
Gate pull requests on lint, tests and generated-code drift
Run one CI gate on your machine and in GitHub Actions that fails a pull request on lint errors, failing tests or stale generated code, one table row per check.
Test a Go API against a real Postgres database
Write table-driven Go tests that call your Connect handlers against a real Postgres with no Docker, and unit-test business logic with Forge’s generated mocks.
Find API endpoints that never check who is calling
List every signed-in RPC whose handler never reads the caller, then fix each with a role or owner check, or mark it global with a reason a reviewer reads.
Scan Go, npm and container dependencies for vulnerabilities
Fail CI on vulnerable Go and npm dependencies with govulncheck and npm audit, accept one advisory at a time with a reason and expiry date, and scan the image.
Connect Claude Code or Cursor to Forge over MCP
Give Claude Code or Cursor Forge’s lint, generate, skills and shapes as MCP tools, check the server answers, and add the hosted connector for telemetry.
Keep your test suite fast: mark slow tests and enforce budgets
Find the Go tests that slow every edit, mark them with testkit.Slow so they leave the -short tier, and fail CI when a new slow test arrives unmarked.
Debug a running Go service from the terminal or an agent
Stop a Forge Go service on a breakpoint inside a handler, send it a request, and read its arguments and locals with forge debug, one command per step.
Upgrade Forge and apply its migration playbooks
Move a project’s pinned Forge version forward: preview the change with —check, list the migration playbooks, run project upgrade, and review the diff.
How forge generate turns proto and SQL into a whole app
How forge generate projects your proto and SQL migrations into stubs, ORM, handlers, hooks and mocks, and why reruns, parallel runs and failed runs stay safe.
How Forge keeps Postgres migrations safe
How Forge keeps a Postgres schema change from breaking the release still serving: declared compatibility, lint, measured locks, gated rollouts and rollback floors.
How Forge tests work: real Postgres, generated tests and mocks
How Forge tests a Go API against a real embedded Postgres with no Docker, which tests and mocks it generates, and why skipped tests never count as passing.
Reliant security model: fail-closed auth, scoped tokens, secrets
How a forge API refuses unauthenticated calls, finds RPCs that never check the caller, keeps errors and secrets out of responses, and scopes every token.
Hosting
Deploy what you build to Reliant hosting, release it safely across environments, and manage its data and users. The hosting overview is the reference.Deploy a Go API with managed Postgres to Reliant hosting
Ship a Forge Go API, its migrations and a managed Postgres to production as one release, then prove it healthy with forge obs check.
Create a preview environment for every pull request
Give each pull request its own hosted copy of your app on its own URL, created and deleted from GitHub Actions, and cleaned up by itself when it expires.
Add a custom domain with automatic HTTPS
Serve a hosted environment on a hostname you own: claim it, publish the CNAME and TXT records forge prints, bind a workload, and get HTTPS issued for you.
Manage production secrets per environment
Give each environment its own secret values: a gitignored file for dev, the write-only hosted store for prod, set from stdin and rotated without a redeploy.
Deploy a Forge app to your own Kubernetes cluster
Bind a Forge environment to a Kubernetes cluster you run, deploy a release to it with forge env deploy, and optionally hand delivery to an in-cluster Flux.
Keep Helm, Fly.io or Cloud Run and still get releases and gates
Bind a workload to forge.OnExternal so forge builds, releases and checks it while your own Helm chart, Fly.io app or Cloud Run service keeps deploying it.
Call a hosted Forge API from a frontend on Vercel, Netlify or your own host
Keep your frontend where it is and call a Forge API on Reliant hosting, with sign-in that works: a same-site API hostname, credentialed CORS, and the frontend declared as the sign-in origin.
Stop a hosted environment when you're not using it
Suspend a hosted environment’s workloads and database with forge env stop, keep its release and data, and bring it back with forge env start.
Promote a release from staging to production by digest
Move the exact release staging runs to production without a rebuild, approve the plan you read by its digest, and see a stale promotion refused.
Gate a production deploy on release health
Hold production until staging proves a release healthy: declare a health gate in prod’s KCL, judge staging with forge obs check, then promote the release.
Recover from a bad deploy by redeploying an earlier release
Put production back on the last good release in one deploy, check that rollback floors allow it, and set a floor so nobody deploys behind a release again.
Deploy from GitHub Actions with an API token
Ship every push to main from GitHub Actions: store a scoped deploy token, cut the release and print its plan in one job, then approve that exact plan in the next.
Detect drift between declared and live environments
Check that an environment runs the release it should, and find what your checkout declares but never deployed, with env status, env diff and env verify.
Restore a managed Postgres database to a point in time
Undo a bad delete on Reliant hosting: declare a new managed Postgres restored from backups to the moment before it, check the rows, and point your app at it.
Invite and manage your app's users from the CLI
Invite people to your hosted app, change their roles, lock them out and end their sessions from the terminal, with forge cloud identity on Reliant hosting.
How Reliant hosting works: what runs where
Where each part of a hosted forge app runs: the CDN edge and static origin, the environment namespace with default-deny networking, managed Postgres, and the limits.
Observability
See how a release behaves in production and find what broke when it does not. The observability page is the reference.Send OpenTelemetry from any app to Reliant
Send traces, logs and metrics from an app in any language to Reliant’s hosted OpenTelemetry backend: mint a token with forge obs init and set the variables.
Find your slowest API endpoints with per-RPC p95 latency
Rank every RPC by p95 latency with forge obs endpoints, open its slowest traces, and see the N+1 query or CPU work behind it, locally or in production.
Route production alerts to Slack, PagerDuty or email
Send Forge’s default alerts to Slack, PagerDuty or email: create receivers in your organization, then route by severity with forge.AlertRoute in KCL.
Write alert rules as code and test them locally
Declare an alert rule in KCL as a SQL query, check it against your local stack’s telemetry, watch it fire on your machine, and ship it with the next release.
Build a dashboard in the UI and keep it as code
Build a dashboard panel by panel in the console or from the terminal, commit it as a file that ships with every release, and check that each panel has data.
Add a custom metric without a cardinality explosion
Declare a business metric with a unit and a closed set of attribute keys, record it from a handler, and query it with forge obs without one series per user.
Count active, new and returning users from product events
Record what signed-in users do with observe.Track, deploy, and read active, new and returning users per environment with forge obs users, no analytics SDK.
Find which release introduced a production error
Trace a production error to the release and commits that introduced it with forge obs issue, then resolve it in the next release so a recurrence reopens it.
Debug production with an AI agent: logs, traces and errors
Let an AI agent find why production fails: read errors, logs and traces with forge obs, follow one request to the failing line, and verify the fix.
Debug frontend errors with session timelines and replay
Go from a browser error to its source-mapped stack and the session it happened in, then choose per environment whether Forge records a masked replay.
Find CPU hotspots with continuous profiling
Find the Go function burning your CPU: turn on continuous profiling, read the flamegraph, export pprof with forge obs profile, and narrow it to one trace.
Read browser and backend logs in one place during development
Find a browser error, its stack and the backend request it failed on with one grep over .forge/logs/dev, then query the same errors with forge obs locally.
How Reliant judges a release: from a span to a verdict
How Reliant turns spans, issues and alerts into a PASS, FAIL or INCONCLUSIVE verdict per release, and why missing telemetry is never read as a pass.