# Writing Agent Relay Workflows > Use when building multi-agent workflows with @relayflows/core. Covers conversation vs pipeline coordination, WorkflowBuilder/DAG steps, agents, {{steps.X.output}} chaining, repairable verification gates, evidence-based completion, mandatory Claude-then-Codex fresh-eyes review/fix loops with test hardening, channels, chat-native recipes, error handling, event listeners, step sizing, lead+workers t… - **Type:** Skill - **Install:** `agentstack add skill-agentworkforce-relay-writing-agent-relay-workflows` - **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior - **Seller:** [AgentWorkforce](https://agentstack.voostack.com/s/agentworkforce) - **Installs:** 0 - **Category:** [Communication](https://agentstack.voostack.com/c/communication) - **Latest version:** 0.1.0 - **License:** Apache-2.0 - **Upstream author:** [AgentWorkforce](https://github.com/AgentWorkforce) - **Source:** https://github.com/AgentWorkforce/relay/tree/main/.claude/skills/writing-agent-relay-workflows - **Website:** https://agentrelay.com ## Install ```sh agentstack add skill-agentworkforce-relay-writing-agent-relay-workflows ``` Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent. ## About # Writing Agent Relay Workflows ## Overview The `@relayflows/core` workflow system orchestrates multiple AI agents (Claude, Codex, Gemini, Aider, Goose) through typed DAG-based workflows. Workflows can be written in **TypeScript** (preferred), **Python**, or **YAML**. **Language preference:** TypeScript > Python > YAML. Use TypeScript unless the project is Python-only or a simple config-driven workflow suits YAML. **Pattern selection:** Do not default to `dag` blindly. If the job needs a different swarm/workflow type, consult the `choosing-swarm-patterns` skill when available and select the pattern that best matches the coordination problem. ## When to Use - Building multi-agent workflows with step dependencies - Orchestrating different AI CLIs (claude, codex, gemini, aider, goose) - Creating DAG, pipeline, fan-out, or other swarm patterns - Needing verification gates, retries, or step output chaining - Designing product-contract workflows where failing checks should route to agents for repair instead of stopping the run - Dynamic channel management: agents joining/leaving/muting channels mid-workflow ## Non-Negotiable Workflow Checklist Every generated workflow should satisfy this checklist before it is considered complete: 1. Start with a deterministic, resumable preflight for repository state, credentials, and declared write scope. 2. Pick the coordination shape deliberately: Conversation for non-trivial coordination, Pipeline only for linear one-shot handoffs. 3. Use repairable validation gates: capture red output with `failOnError: false`, hand it to a repair owner, then rerun the same check. 4. Run the mandatory fresh-eyes loops in order: Claude review/fix/final review/final fix, then Codex review/fix/final review/final fix. 5. Require review fixers to add or update appropriate tests, fixtures, assertions, or deterministic proofs for testable findings. 6. Run final deterministic acceptance after the Codex loop and before commit, PR creation, or handoff. 7. If a real blocker remains, write `BLOCKED_NO_COMMIT` with exact evidence and skip commit/PR creation instead of crashing the workflow. 8. If the workflow owns shipping, model branch, commit, push, PR creation, and PR URL verification as explicit deterministic steps. ## Default Principle: Workflows Repair Before They Fail The point of an agent team workflow is not to discover a red gate and stop. The point is to capture the failure, route it to the right agent, fix it, and continue toward a shippable result. Author non-trivial workflows as repairable systems: 1. Run deterministic checks as evidence-capturing gates with `captureOutput: true`. 2. Prefer `failOnError: false` for intermediate validation gates so the workflow can pass the output to a repair agent. 3. Add a repair step immediately after each red-prone gate. The repair agent reads `{{steps..output}}`, fixes source/tests/config, reruns the same command locally, and exits only after the gate is green or the blocker is external. 4. Keep final acceptance deterministic, but still put an agent repair step before commit/PR creation. If the repair budget is exhausted or a true external blocker remains, write a blocked artifact and skip commit/PR creation; do not let the workflow end as `FAILED`. 5. Use `.reliable()` or `.repairable()` on SDK versions that support it, especially for product-contract workflows. As of AgentWorkforce/relay#827, retry-mode workflows with agents are repair-aware by default, repair agents run before retrying malformed/failed agent steps, and the SDK covers DAG, pipeline, fan-out, worktree-backed, deterministic-only, and agent-plus-gate shapes. Avoid hard-stop gates (`failOnError: true` with no repair step) in workflows that are supposed to be self-healing. Even cheap preconditions such as missing credentials, wrong repository, or an unsafe dirty worktree should normally write a clear `BLOCKED_*` artifact and exit cleanly. For implementation, build, test, lint, schema, artifact, and review failures, model the fix path in the workflow. ## Mandatory Fresh-Eyes Review Loops Every workflow must include two comprehensive fresh-eyes review/fix loops before final acceptance, commit, PR creation, or handoff: first Claude, then Codex. This applies even to small workflows and even when deterministic tests pass. Tests prove commands passed; the fresh-eyes loops make independent agents read the actual resulting files and artifacts as if they did not author them. The required shape is: 1. `claude-review`: Claude reads the spec, repo rules, changed files, artifacts, test evidence, and final diff. It must produce a durable review artifact with either actionable findings or an explicit `NO_ISSUES_FOUND` verdict. 2. `claude-fix`: a fixer repairs every valid Claude finding, adds or updates appropriate tests/proofs for the fix, reruns the relevant checks, and records what changed. If the review found no issues, it records that no fix was needed. 3. `claude-review-final`: Claude reviews the post-fix state from scratch. It must not rely on the first review or the fixer's summary. 4. `claude-fix-final`: if the final Claude review still finds issues, fix them, add or update appropriate tests/proofs, and rerun the checks. If anything cannot be fixed, write a `BLOCKED_NO_COMMIT` artifact with exact evidence. 5. `codex-review`: Codex starts after the Claude loop and reviews the post-Claude-fix state from scratch. 6. `codex-fix`: a fixer repairs every valid Codex finding, adds or updates appropriate tests/proofs for the fix, reruns relevant checks, and records what changed. 7. `codex-review-final`: Codex reviews the post-fix state from scratch. 8. `codex-fix-final`: if the final Codex review still finds issues, fix them, add or update appropriate tests/proofs, and rerun checks. If anything cannot be fixed, write `BLOCKED_NO_COMMIT`. 9. Final acceptance/commit/PR steps depend on the post-Codex-fix review path, not directly on implementation, tests, or the Claude loop. Because WorkflowBuilder DAGs do not provide an unbounded dynamic `while` loop, model this as explicit bounded review/fix loops plus a final signoff gate. Inside each fix step, instruct the agent to keep iterating locally: review the finding, edit, add or update appropriate regression tests/proofs, rerun targeted checks, review its own fix, and repeat until that round has no remaining valid issues. For high-risk workflows, add more unrolled review/fix rounds or split the reviews into focused reviewers by subsystem. Use Claude first and Codex second unless one of those CLIs is unavailable in the target environment. If one is unavailable, write that limitation into the workflow artifact and keep the remaining review loop mandatory. Review artifacts should use a consistent schema so later steps can act on them deterministically: ```text verdict: FINDINGS | NO_ISSUES_FOUND | BLOCKED finding_id: short stable id severity: blocker | high | medium | low file: path/to/file issue: what is wrong fix_required: concrete change needed test_required: test, fixture, assertion, or proof command needed status: open | fixed | wontfix | blocked evidence: commands run, file paths, or blocker details ``` Use `NO_ISSUES_FOUND` only when there are no actionable findings. Use `BLOCKED` only when the blocker is external or unsafe to resolve inside the workflow. ## Choose Your Coordination Style — Conversation vs Pipeline Before writing the workflow, decide _how the agents will coordinate_. The relay primitive supports two very different shapes, and picking the wrong one wastes the most valuable thing the SDK gives you. | Shape | What it is | Use when | | ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Conversation** (chat-native) | Interactive agents share a channel; messages, `@-mentions`, and ambient awareness drive coordination. Lead and workers spawn in parallel and self-organize. The relay is the coordination layer, not just transport. | Multi-file work, peer review loops, cross-agent feedback, dynamic re-planning, multi-PR coordination, anything with a human-in-the-loop escape, swarms where workers pick up each other's output. | | **Pipeline** (one-shot DAG) | Each step runs as a one-shot subprocess (`claude -p`, `codex exec`); steps hand off via `{{steps.X.output}}` text injection. No agents are alive at the same time; no chat happens. | Linear, well-specified transformations; deterministic data passing; no live agent-to-agent coordination during implementation. The mandatory final Claude-then-Codex review/fix loops still apply. | **Default to Conversation for any non-trivial work.** Pipeline DAGs are simpler to reason about but they do not exercise the relay primitive — they are a Unix pipe with extra steps. If you would happily write the same task as a single shell pipeline, pipeline-shape is fine. Otherwise, you almost certainly want a Conversation shape. The two shapes can mix within one workflow: pipeline-style deterministic preflight → conversation in the middle → pipeline-style commit-and-PR at the end. See **Quick Reference (Conversation)** below and **[Common Patterns → Interactive Team](#interactive-team-lead--workers-on-shared-channel)** for the canonical recipe. > **A blunt rule of thumb:** if your workflow only uses `agent` steps with `preset: 'worker'` chained by `{{steps.X.output}}`, you are not using the relay — you are using `claude -p | codex exec`. That may still be the right answer; just make it a deliberate choice. ## Quick Reference (Pipeline shape) > Use this when steps are linear, well-specified, and need no agent-to-agent feedback. For anything with iteration, review, or coordination, jump to **Quick Reference (Conversation shape)** below. > > **Note:** examples use ESM `import` syntax, but workflow execution is always wrapped in an async function. See **Failure Prevention → Do not use raw top-level `await`** before copy-pasting into CJS or executor-generated files. ```typescript import { workflow } from '@relayflows/core'; async function runWorkflow() { const result = await workflow('my-workflow') .description('What this workflow does') .pattern('dag') // or 'pipeline', 'fan-out', etc. .channel('wf-my-workflow') // dedicated channel (auto-generated if omitted) .maxConcurrency(3) .timeout(3_600_000) // global timeout (ms) .repairable() .agent('lead', { cli: 'claude', role: 'Architect', retries: 2 }) .agent('worker', { cli: 'codex', role: 'Implementer', retries: 2 }) .agent('claude-reviewer', { cli: 'claude', role: 'First-pass fresh-eyes reviewer', retries: 1, preset: 'reviewer', }) .agent('claude-fixer', { cli: 'claude', role: 'First-pass review-finding fixer', retries: 2 }) .agent('codex-reviewer', { cli: 'codex', role: 'Second-pass fresh-eyes reviewer', retries: 1, preset: 'reviewer', }) .agent('codex-fixer', { cli: 'codex', role: 'Review-finding fixer', retries: 2 }) .step('preflight', { type: 'deterministic', command: 'git rev-parse --show-toplevel >/dev/null && echo PREFLIGHT_OK', captureOutput: true, failOnError: true, }) .step('plan', { agent: 'lead', dependsOn: ['preflight'], task: `Analyze the codebase and produce a plan.`, retries: 2, verification: { type: 'output_contains', value: 'PLAN_COMPLETE' }, }) .step('implement', { agent: 'worker', task: `Implement based on this plan:\n{{steps.plan.output}}`, dependsOn: ['plan'], verification: { type: 'exit_code' }, }) .step('claude-review', { agent: 'claude-reviewer', dependsOn: ['implement'], task: `Fresh-eyes review the completed workflow output. Read the actual files, diff, repo rules, and available evidence. Write findings to .workflow-artifacts/my-workflow/claude-review.md. If there are no actionable issues, write NO_ISSUES_FOUND.`, verification: { type: 'exit_code' }, }) .step('claude-fix', { agent: 'claude-fixer', dependsOn: ['claude-review'], task: `Read .workflow-artifacts/my-workflow/claude-review.md. Fix every valid issue, add or update appropriate tests/proofs for the fix, rerun relevant checks, and update .workflow-artifacts/my-workflow/claude-fix.md. If the review says NO_ISSUES_FOUND, record that no fix was needed.`, verification: { type: 'exit_code' }, }) .step('claude-review-final', { agent: 'claude-reviewer', dependsOn: ['claude-fix'], task: `Fresh-eyes review the post-fix state from scratch. Do not rely on the prior review or fix summary. Write .workflow-artifacts/my-workflow/claude-review-final.md with either actionable findings or NO_ISSUES_FOUND.`, verification: { type: 'exit_code' }, }) .step('claude-fix-final', { agent: 'claude-fixer', dependsOn: ['claude-review-final'], task: `If .workflow-artifacts/my-workflow/claude-review-final.md contains findings, fix them, add or update appropriate tests/proofs, and rerun relevant checks. If no fix is possible, write .workflow-artifacts/my-workflow/BLOCKED_NO_COMMIT.md with exact evidence. If it says NO_ISSUES_FOUND, record Claude review signoff.`, verification: { type: 'exit_code' }, }) .step('codex-review', { agent: 'codex-reviewer', dependsOn: ['claude-fix-final'], task: `Second-pass fresh-eyes review of the post-Claude-fix state. Read the actual files, diff, repo rules, and available evidence. Write findings to .workflow-artifacts/my-workflow/codex-review.md. If there are no actionable issues, write NO_ISSUES_FOUND.`, verification: { type: 'exit_code' }, }) .step('codex-fix', { agent: 'codex-fixer', dependsOn: ['codex-review'], task: `Read .workflow-artifacts/my-workflow/codex-review.md. Fix every valid issue, add or update appropriate tests/proofs for the fix, rerun relevant checks, and update .workflow-artifacts/my-workflow/codex-fix.md. If the review says NO_ISSUES_FOUND, record that no fix was needed.`, verification: { type: 'exit_code' }, }) .step('codex-review-final', { agent: 'codex-reviewer', dependsOn: ['codex-fix'], task: `Fresh-eyes review the post-Codex-fix state from scratch. Do not rely on the prior review or fix summary. Write .workflow-artifacts/my-workflow/codex-review-final.md with either actionable findings or NO_ISSUES_FOUND.`, verification: { type: 'exit_code' }, }) .step('codex-fix-final', { agent: 'codex-fixer', dependsOn: ['codex-review-final'], task: `If .workflow-artifacts/my-workflow/codex-review-final.md contains findings, fix them, add or update appropriate tests/proofs, and rerun relevant checks. If no fix is possible, write .workflow-artifacts/my-workflow/BLOCKED_NO_COMMIT.md with exact evidence. If it says NO_ISSUES_FOUND, record final review signoff.`, verification: { type: 'exit_code' }, }) .step('acceptance-after-review', { type: 'deterministic', dependsOn: ['codex-fix-final'], command: 'test ! -f .workflow-artifacts … ## Source & license This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code. - **Author:** [AgentWorkforce](https://github.com/AgentWorkforce) - **Source:** [AgentWorkforce/relay](https://github.com/AgentWorkforce/relay) - **License:** Apache-2.0 - **Homepage:** https://agentrelay.com Install and usage instructions live in the source repository linked above. ## Pricing - **Free** — Free ## Security capabilities Automated source analysis of v0.1.0 — what this tool can access: - **Network access:** no - **Filesystem access:** no - **Shell / process execution:** yes - **Environment & secrets:** no - **Dynamic code execution:** no *"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.* ## Versions - **0.1.0** — security scan: passed — Imported from the upstream source. ## Links - Listing page: https://agentstack.voostack.com/l/skill-agentworkforce-relay-writing-agent-relay-workflows - Seller: https://agentstack.voostack.com/s/agentworkforce - Browse the marketplace: https://agentstack.voostack.com/browse --- Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.