acme/shopfront, triage it.” “When the nightly workflow fails, open a follow-up.” The run is an ordinary chat you can open afterwards, with the full transcript, so you can see exactly what the agent did.

Workflows → Automations. Example data.
Just describe it in a chat
You do not need to write the YAML or know the trigger syntax. Open a chat in your project and describe the job the way you would to a colleague:
Every weekday at 10am, check the open pull requests on acme/shopfront and post a summary to #eng in Slack.
The agent loads the workflow-builder skill and the workflow tools, asks about anything it cannot guess (which Slack channel, what counts as stale), writes a workflow with a triggers: block, and tests it. It does not turn the automation on: when the workflow is ready it hands it to you to enable, and that is where you choose the project and machine its runs use, or No machine if the job only needs the web and your integrations. The same works for events (“when someone opens an issue on acme/shopfront, label and triage it”) and for bots and monitors that are really an agent on a clock. For a longer or more involved job, start the built-in Create a Workflow workflow, which scopes, builds and tests it in phases.
You can then open the result in the workflow builder, change the cron or the filter, and the automation follows the edit. The rest of this page explains what the agent wrote.
Declare in YAML, enable in the app
Automations have two halves, and keeping them apart is what makes a workflow shareable. A workflow declares when it should run in atriggers: block of its YAML. The declaration says the source (a schedule, a webhook, an integration event, another workflow’s outcome), an optional filter, and how the event’s data becomes the workflow’s inputs. Declaring a trigger fires nothing, and an agent that writes the YAML for you cannot change that: only you turn a workflow on.
You enable it in the app. Open Workflows → Library, open the workflow and choose Enable. One dialog turns on every trigger the workflow declares, and asks once for what belongs to you:
- the project and workspace its runs use;
- the machine whose tools they use, or No machine;
- for an integration event, which connected account it listens through, once per integration;
- the workflow’s own inputs, set on every run;
- a prompt, for any trigger whose author wrote none;
- whether to notify you when a run succeeds. Off by default: successful runs land quietly in Workflows → Runs. On, a successful run is marked unread and raises a desktop notification. It never puts the run in the Inbox, which lists only what needs you. A failed run always notifies you, once per failure streak, and stays in the Inbox until a later run of the automation succeeds.
triggers: block changes the automation. If you rename or remove the declaration, the automation is marked broken and fires nothing until you restore it.
name and exactly one source. The fields around the source are the same for every kind:
Inside templates and filters,
trigger.payload is the event’s data and trigger.kind says what fired. Unknown keys in a triggers: block are errors, not ignored: a mistyped filtr: would otherwise mean a trigger that fires on everything.
For an integration trigger, validation also checks the filter, inputs and prompt against the payload the integration declares for its events, so a read that payload can never satisfy is an error before the trigger fires. For example, GitHub’s issue.labels is a list of label names: write !('wontfix' in trigger.payload.data.issue.labels), not l.name.
One declaration, many activations: trigger.activation
A filter, an inputs mapping and a prompt can also read the activation they fire for, so each activation carries its own settings and the declaration does not need them pasted in:
A pack that watches a list of repositories declares a typed input for it and scopes the trigger by that input with
match. Each activation then names its own repositories:
params: {repos: [acme/web, acme/docs], team: frontend} and again with params: {repos: [acme/api]}; an issue in acme/api fires only the second. An event for a repository outside an activation’s list is dropped before it is recorded, so it leaves no skipped row on that activation. match: {repository: {input: repos}} is the declarative scope: the repository attribute and the input must have the same type (github.repository), and a filter is still available for what a scope cannot say.
An input marked required: true (or declared with no default) must have a value before an activation can be turned on. Turning one on without it is refused with the missing input named, and an activation that already exists but is missing one (the workflow gained a required input, or it was created before the input was required) shows Needs setup instead of a health status, with Finish setup opening the dialog where you supply it. An activation in that state does not run.
trigger.activation.paramsholds the workflow’s declared inputs except the ones the trigger’sinputsmapping sets from the event (the event’s value always wins, so an activation may not set them).- It is what the run will receive: the input’s default is applied when the activation does not set it, and each value has its declared type. An optional list with no default is
[]; a required input is never read unset, because an activation missing one does not run. - Validation types it from the workflow’s inputs: a
github.repositoryinput withmulti: trueis alist<string>.trigger.activation.params.repofor areposinput, or a read of a field of a string param, is an error when the workflow is saved. - Creating an activation checks its params the same way: a param that names no input (with a “did you mean”), or has the wrong type, is refused.
- It exists only in a trigger’s
filter,inputs,promptanddedupe_key. A run’s own nodes readinputs.*, where the same values arrive, and the rest oftrigger.*. - Try it before activating:
reliant workflow validate --trigger-payload '{...}' --activation-params '{"repos": ["acme/web"]}'runs every declared trigger against a sample event and sample params, and thecel_evaltool andreliant workflow eval --scope triggertakeactivation_paramstoo.--owner-github-idsuppliestrigger.activation.owner.github_id.
Who may start a run
Trust is a CEL filter over data the trigger already has; there is no table of trusted people to maintain.trigger.sender is who the source says sent the event, and trigger.activation.owner.github_id is you, by the GitHub connection the activation listens through, or, when it names none, by the GitHub account linked to yours (read at every event, so reconnecting a different account takes effect at once). Both are strings, so a list of trusted people is a github.user input, which stores numeric ids as strings ("583231", quoted: CEL does not match the number 583231 against the string) and is picked by login in the dialog.
trusted_ids set, only you can start it. If you have no GitHub identity at all, github_id is empty, which never equals a verified sender’s id, so only trusted_ids admit anyone; the skipped event says “owner has no linked GitHub identity”, and enabling the workflow warns about it. Comparing a sender id with a number is an error when the workflow is saved.
Telling your own writes apart
An automation that writes to the thing it watches hears itself. A reviewer posts a review on a pull request and the review comes back as anissue_comment.created; a responder pushes a fix and the push comes back as pull_request.synchronize. Without a guard, a workflow that reacts to either would run forever.
Reliant records every change an integration action makes on a run’s behalf (a comment, review, label, pull request) before it makes it, and when a webhook arrives it checks whether one of those writes caused it. The answer is trigger.origin, available in filter, inputs and prompt:
Every field is always present. An event nothing attributed reads
caused_by_reliant: false, confidence: 'none', empty strings and lineage_depth: 0, so a filter never fails with “no such key”. The run’s own details (run_id, workflow, trigger_name) are filled only when the run is yours: a different user’s trigger on the same repository learns that Reliant caused the event and nothing about whose run.
origin_filter
origin_filter is a CEL bool, evaluated before filter. A false skips the event. When you do not write one, this is what runs:
app or claimed origin says Reliant did it but not which run, so it is not treated as this workflow’s. To change that, write your own:
origin_filter and checks it against the same typed trigger the filter sees, so a misspelled field (trigger.origin.same_workfow) is an error when you save the workflow, not a trigger that quietly never matches.
Skipped events say why
An event theorigin_filter rejects is recorded as skipped with the reason, so the automation’s history explains it:
The loop cap
Whateverorigin_filter says, a chain of event-driven launches stops at 5 hops. A run launched by an event that one of its ancestors’ writes caused inherits that ancestor’s chain plus one; a launch that would be the sixth is skipped with loop guard: launch chain is already 5 hops deep (max 5). No expression can override it, so two workflows that deliberately re-trigger each other with origin_filter: "true" still stop. The cap counts other users’ runs too.
What can and cannot be attributed
Only writes Reliant makes itself are attributed: atype: action node, or an integration tool an agent calls. Those are recorded exactly. What an agent does through a shell is not:
If an agent in a shell can write to GitHub as you, give the writing to an action node, and keep the shell for work on the checkout.
The four kinds
Unattended by design
Nobody is watching an automation’s run. The agent is told to decide and proceed rather than ask, questions and approvals resolve immediately with no answer instead of waiting, and a run that pauses on a failure (a rate limit, a machine that went away) resumes itself with a growing wait instead of waiting for someone to resume it. Only a failure that outlasts about half an hour of retries leaves it paused, in Workflows → Runs, for a person to look at. Design workflows for this: give them everything they need in the prompt and inputs, and assume nothing can be clarified mid-run.Declare what a run needs: requires:
A run that needs something from outside its definition says so, and checks it before its first node:
git ls-remote, which writes nothing), and has no local tag that differs from origin’s (the cause of git fetch failing with “would clobber existing tag”). If anything is missing the run fails at once, before any side effect, with every missing item and its fix in the run’s error, rather than an hour in. A check that cannot run (the machine dropped the probe) is retried, and reported as such if it still cannot. Workflow lint warns when a triggered workflow’s command calls a tool its requires.tools does not list.
A workflow that should only ever start from its triggers, never from a chat, can set automation_only: true: chat pickers stop offering it and a chat start of it is refused. A deliberate start by hand (Run now, reliant workflow run, an agent’s start_run, a builder test run) still works. A helper that other workflows only ref: also sets hidden: true, which keeps it out of every picker and listing.
Where runs go
An automation’s runs stay out of your chat list. Each one is listed under Workflows → Runs, named by the automation that fired it, with its status. A run that finishes successfully archives itself: it stays in Runs, marked Archived, and out of the sidebar’s Archived tab, which holds only chats you put away. A run that fails, completes into a declaredoutcome: failure, is cancelled, or is waiting on you stays unarchived, so it surfaces in Runs and the Inbox. Route a blocked path to a terminal node with outcome: failure when you want to look at it.
An automation with Notify me when a run succeeds keeps its successful runs unarchived, since the notification points at them. Open as chat on a run moves it into your chat list, out of the archive if it was there.
Who an automation acts as
An automation’s GitHub writes (comments, reviews, labels, pull requests, issues, workflow dispatches andgit_publish pushes, from a node’s action and an agent’s integration tools alike) are made as the identity chosen in the automation’s settings. Every new automation defaults to Reliant bot, whatever starts it: a GitHub event, a schedule, a webhook, another integration or a workflow event, including triggers declared in a workflow, reliant trigger activate and activations an agent creates. Writing as You is an explicit choice. Existing activations keep their stored identity, and an explicit You choice is never replaced. To change one, open it in Workflows → Automations and choose Edit, or run reliant trigger activate --acting-as owner. Only GitHub has a bot: Slack, Gmail, Twilio and HTTP writes always go through your own connection.
Everything a bot writes ends with a footer naming the automation and its owner, so nobody has to guess whose it is:
Posted by Reliant for pr-review, an automation of @alice.The bot is not a way around your own permissions. Before it writes, Reliant checks that your own GitHub account can push to that repository. The token it uses is scoped to that one repository and to what the action needs (issues, pull requests or contents), and lasts an hour. If you cannot push, if the Reliant GitHub App is not installed on the repository, if the App has not been granted a permission, if Reliant has no App key to mint the token from, or if minting fails for any other reason, the write fails with the reason. It is never made as you instead. The same holds for a
git_publish push: a bot automation pushes with the bot’s token for that one repository, or the push is refused and nothing is pushed.
Three things stay as they are:
- Reads use your own access. Only writes carry the bot’s name. A write that names a saved connection (
connection:) cannot also be made as the bot, so it fails instead of using that connection; a read may still name one. - A person typing in the run’s chat acts as themselves. The bot identity belongs to the automation’s own run, not to the chat.
- A deployment with no control plane to provide the Reliant GitHub App has no bot. A new GitHub trigger’s default bot identity is refused when you save: configure the App or explicitly choose You; it never silently selects the owner. Other new automations there default to You. A hosted deployment whose App key is missing refuses each bot write with an error telling an administrator to configure the App, or you to set the automation to write as you.
issue_comment.created or pull_request_review_comment.created, so a run that comments cannot start itself. Another bot’s comments (Dependabot, a CI app) do reach your filters.
Watching your automations
Workflows → Automations lists every automation across your projects, grouped by workflow, with each group’s state (enabled, disabled, partly enabled or broken), a “coming up” timeline of the next 24 hours of scheduled runs, and each automation’s health, computed from its last ten firings. Workflows that declare triggers nothing runs yet are listed above, each with an Enable:
A run that launched and then failed counts as a failure, not just a launch that errored. Opening an automation shows its history: each firing, what it did (launched, skipped, failed) and a link to the run it started.

An automation's run history. Example data.
The Inbox
The Inbox, in the sidebar, is everything waiting on you across your projects, and its badge counts the items that hold up a live run:
A run that completed successfully is never in the Inbox, whatever its automation’s notify setting: Notify me when a run succeeds is a desktop notification, not an Inbox item. A workflow that has something to tell you after a success says so itself, with a step that messages you (Slack, SMS or email) or an
ask_user question.
Approvals (Approve / Deny) and questions (Answer) can be dealt with from the Inbox itself; the rest Open the run, automation or machine. Every item, or a whole section, can be dismissed, with Undo. It shows the current project by default, with every project one click away. A run started by an automation is unattended and never waits on you, so the approvals and questions here come from chats and runs someone started by hand.
Who can decide an approval
An approval means a person said yes, so only someone signed in to the Reliant app, on the web or desktop, can approve or deny one. The server refuses a decision sent with the credentials software usually holds: the CLI login (reliant auth login, which every agent shell inherits), an ordinary access token from reliant auth token create (reliant:api does not include deciding), a daemon’s credential, or the token of an OAuth client you connected (such as an MCP client). The refusal names the credential and says to open the approval in the app. The one exception is deliberate: an access token granted the approvals:decide scope explicitly, and not bound to a machine, can decide (SDK scopes). Whatever holds such a token can approve, so grant it only where a decision by software is the intent. Questions are not approvals; an agent or the CLI can still answer those.
One deployment cannot tell a person from an agent: a self-hosted server running with AUTH_MODE=apikey. There, every client presents the same shared key, including the web app, the CLI and an agent’s shell. Refusing that key would make approvals impossible rather than human-only, so the key is accepted, and anything holding the key can approve. Treat such a deployment as having a single trusted operator. If approvals there must provably come from a person, run the server with an identity provider instead of a shared key.
From the command line
reliant trigger manages schedule automations: create, list, get, update, enable, disable, fire, events and delete. Webhook, integration and workflow-event automations are enabled from the app. An agent can write and test a workflow but cannot enable one, so create, update and enable refuse to run from an agent’s shell; only you turn an automation on. See Schedules for the commands.
Related topics
- Schedules, Webhooks, Workflow events
- No-machine runs
- Integrations
- Cloud machines & plans, for a machine that is awake at 3 a.m.