Actions
Repeatable scripts, forms and workflows that run on your workspace's runner without an AI conversation, built and changed by agents, checked by people, and callable by agents in any project.
Actions
An action is work your workspace does again and again, written down once as a script: turn photographed menus into vector PDFs, export a game build, resize captures for a store page, publish a release. It runs on the workspace's runner the same way every time, without starting a new AI conversation. A workflow is an action whose steps are other actions, scripts, approvals, waits and agent steps: export → check → ask before uploading → upload.
Open Actions under Workspace in the sidebar. It unfolds to list the actions, and each row shows its trigger, whether it is Script only or has an Agent step, and its last run.
Make an action
- Describe it. Type what you do again and again in the box at the top of the Actions page, with the files, repositories, folders and docs it needs. The agent writes the scripts, tries them on your files, and shows you a draft. Nothing runs from a draft until you press Save action.
- From a chat. When an agent did the same task in a chat two or three times, it offers to save it as an action, already tried on the earlier inputs.
- By hand. New script opens an empty action in the editor.
Every action is a folder actions/<slug>/ in the workspace: an action.yaml and its scripts.
kind: action
title: Vectorize menu
description: Turns photographed menu pages into vector PDFs.
inputs:
- { name: name, type: text, required: true }
- { name: pages, type: files, required: true, accept: [png, jpg] }
- { name: paper, type: choice, options: [A4, Letter], default: A4 }
- { name: check_text, type: bool, default: true }
steps:
- { id: trace, name: Trace the shapes, kind: script, run: trace.py, tools: [python] }
- { id: check, name: Check the text, kind: agent, prompt: Compare the text with the picture, optional: true, optionalInput: check_text }
- { id: pdf, name: Write the PDF, kind: script, run: run.py, writes: ["files/menus/out/"] }
outputs: ["files/menus/out/{{inputs.name}}/*.pdf"]
An action that works with a repository of the workspace names it, and every run fetches it first, so it always uses the newest commit:
repos:
- { repo: godot-game, ref: main } # ref: a branch (newest commit each run), a tag or a commit; default the branch the workspace reads
steps:
- { id: export, name: Export Godot build, kind: script, run: export.sh, repo: godot-game }
Each repository is a copy at $YARD_REPO_<NAME> ($YARD_REPO_GODOT_GAME); a step with repo: also gets it as
$YARD_REPO. The run page says which commit a run used. When the agent builds an action from a description, a
repository you attach as context becomes one of its repos.
A script gets the form's values as INPUT_<NAME> variables and as a JSON file at $YARD_INPUTS; file inputs are copied
into the run first. It works from the workspace's folder, so it reads and writes shared files under files/. A line
::yard-summary <text> sets what the step's card says.
| Step kind | What it does |
|---|---|
script |
Runs a file of the action (.sh, .py, .js, .ts) or a command line on the runner. |
action |
Runs another action with inputs (with:), and waits for it. |
approval |
Waits until a person approves it, in Yard or from the phone. |
wait |
A step that waits for a person outside Yard (see below). |
agent |
Asks an agent, in the action's own chat. Marked Agent everywhere; optional lets the form switch it off. |
if |
Ends the workflow here unless its condition ({{inputs.branch}} equals default) holds. |
notify |
Tells the people who are told about runs. |
Run an action
- From its form: open the action, fill in the fields, press Run.
- By itself: a
schedule(cron, in a timezone), atagpushed to a repository of the workspace (the run getsversionfrom the tag), orfilesadded to afiles/folder (one run for the batch). Pause triggers stops them; running by hand still works. - From an agent in any project or chat, as a tool (below), or with
yard action runin a terminal.
The run page shows each step's status and duration, the files the run made with their sizes, and the failing step's log. Secret values never appear in it. Run again from here starts a new run from a step, with the files of the steps before it. When a run fails, the agent reads it and says what went wrong; Let the agent fix it asks it for a new version, which it tries on that run's files first.
Steps that wait for a person
Some programs ask a person on every sign-in, such as Steam Guard. Give the step a wait:
- id: upload
name: Upload to Steam
kind: script
run: upload.sh
secrets: [STEAM_USER, STEAM_PASSWORD]
wait: { match: "Steam Guard", label: Steam Guard, timeoutMs: 900000, keep: [Steam] }
When its log shows the match (or the script prints ::yard-wait <label>), the run shows Waiting for Steam Guard
and the people chosen in the settings get a notification. It goes on as soon as the program does, and fails with
"Nobody confirmed Steam Guard within 15 min" otherwise. keep keeps those folders of the step's home on the runner
between runs, so a sign-in asks less often.
Versions
Every save, yours or an agent's, is a commit in the workspace's actions/ git repository. An agent's change is a
proposal on a branch: its card in the chat lists the files and lines it changed, with Apply and View diff.
Applying it makes the next version (v1, v2, …); runs already started keep the version they started on. An
action.yaml with a problem cannot be applied, and the error names the field.
In Workspace settings › Actions you can keep the repository on GitHub: every applied version is pushed to the branch you choose, and commits pushed there from elsewhere come back as proposals (or are applied, or ignored).
Agents call actions as tools
Turn on Agents can call this action as a tool on the action's As a tool tab. Its parameters come from the
form; file parameters take paths in the caller's project or under files/. Who may call it limits it to every
project and chat, chosen projects, or people only. Dropping an action into a chat's composer gives that chat's agent
the action as a tool.
An agent calls it with yard action run <name> --param k=v --file k=<path>. It gets the files the run made and a link
to the run. Approval steps still wait for a person: an agent can never approve them, and never sees the secrets.
Secrets, toolbox and files
- Secrets (the Secrets tab): values are sealed to your organization's vault and given only to the steps that list
them and that the secret's scope reaches (all actions, chosen actions, or one step). An agent can name a secret it
needs (
yard action secret NAME); it shows as Needs a value until a person sets it. - Toolbox (Tools & files): programs every action can call, each with its install script, installed into
.yard/toolbox/on the runner (bin/is on every step'sPATH). - Files: named folders under
files/that projects, people, agents and actions share, with how long their files are kept.
Settings
Workspace settings › Actions: git versioning (remote, branch, what happens to changes made in the repository), the runner runs start on, how many run at the same time, how long run files and logs are kept, whether agents may create and change actions, and who is told when a run waits for a person.