跳到主内容
智客 ZICQ

技能库 智客分类:Agent 工作流 fabro-workflow-factory

Fabro Workflow Factory

使用 Fabro 的技巧,开源 AI 编码工作流程管弦乐器,可以将代理管线定义为 Graphviz DOT 图形与人门,多型路由,和云沙盒.

1230 安装量

官方网址:skills.sh

技能介绍

先看中文介绍;官方 description 原文单独保留,不改写 SKILL.md。

做什么

使用 Fabro 的技巧,开源 AI 编码工作流程管弦乐器,可以将代理管线定义为 Graphviz DOT 图形与人门,多型路由,和云沙盒.

何时用

官方 description 未单独写出 Use when。按规范,代理会在用户任务与这段 description 的关键词匹配时激活本技能。

代理如何加载

按 Agent Skills 渐进披露:启动时只加载 name 与 description(约 100 token);任务匹配后才读入整份 SKILL.md 正文;scripts/、references/、assets/ 仅在需要时再读。 本文件正文结构:Fabro Workflow Factory、Installation、Via Claude Code (recommended)、Via Codex、Via Bash、Key CLI Commands。 其中含规范建议的小节:分步指令。

文件分析

文件分析:这是一份仅含 SKILL.md 的指令型技能,代理激活后整份正文进入上下文。 正文约 506 行,超过规范建议的 500 行,激活时仍会整份载入。

官方 description(原文)

Skill for using Fabro, the open source AI coding workflow orchestrator that lets you define agent pipelines as Graphviz DOT graphs with human gates, multi-model routing, and cloud sandboxes.

Fabro Workflow FactoryInstallationVia Claude Code (recommended)Via CodexVia BashKey CLI CommandsWorkflow managementHuman-in-the-loopSandbox accessRetrospectivesConfigWorkflow Definition (Graphviz DOT)

来源分类:skills.sh agent-skill

SKILL.md 与 Agent 调用

官方规范 ↗
name
fabro-workflow-factory
description
Skill for using Fabro, the open source AI coding workflow orchestrator that lets you define agent pipelines as Graphviz DOT graphs with human gates, multi-model routing, and cloud sandboxes.
  1. 发现技能客户端向 Agent 提供名称与描述目录。
  2. 匹配与调用用户指定或任务匹配后,载入 SKILL.md 指令。
  3. 按需加载按步骤读取参考文档、使用脚本与素材。

具体调用语法与可用工具以目标 Agent 客户端为准。 查看调用机制说明 ↗

安装这个技能

Skills CLI ↗

先选择目标 Agent 和安装范围,保留技能包的附属文件,安装后检查客户端能否发现该技能。

交给 Agent 安装

复制安装指令给支持 Agent Skills 的代理,确认其中的目标目录与客户端匹配。

把 Agent Skill「fabro-workflow-factory」安装到我的项目:SKILL.md 原文与官方 description 见 https://zicq.com/zh/skills/skl-75a82f27abed81be-%E6%B3%95%E5%B8%83%E7%BD%97%E5%B7%A5%E5%8E%82.html
请存为 .cursor/skills/fabro-workflow-factory/SKILL.md 或 .claude/skills/fabro-workflow-factory/SKILL.md,frontmatter 的 name 与 description 保持原样,不要改写。

GitHub 完整包 ↗

终端安装 · Skills CLI

需要 Node.js 与 npx。先查看仓库技能列表,确认实际名称。

npx skills add 'https://github.com/reason-machines/trending-skills' --list

npx skills add 'https://github.com/reason-machines/trending-skills' --skill 'fabro-workflow-factory'

CLI 会交互选择目标 Agent,默认安装到项目;用户级安装使用 -g。先通过查看命令核对仓库内容,再用 npx skills list 检查已安装技能。

阅读排版
--- name: fabro-workflow-factory description: Skill for using Fabro, the open source AI coding workflow orchestrator that lets you define agent pipelines as Graphviz DOT graphs with human gates, multi-model routing, and cloud sandboxes. triggers: - set up fabro for my project - create a fabro workflow - define an ai agent pipeline with human approval - run coding agents with fabro - configure multi-model routing in fabro - write a dot graph workflow for fabro - add human-in-the-loop gates to my ai workflow - orchestrate ai agents with fabro --- # Fabro Workflow Factory > Skill by [ara.so](https://ara.so) — Daily 2026 Skills collection. Fabro is an open source AI coding workflow orchestrator written in Rust. It lets you define agent pipelines as Graphviz DOT graphs — with branching, loops, human approval gates, multi-model routing, and cloud sandbox execution — then run them as a persistent service. You define the process; agents execute it; you intervene only where it matters. --- ## Installation ```bash # Via Claude Code (recommended) curl -fsSL https://fabro.sh/install.md | claude # Via Codex codex "$(curl -fsSL https://fabro.sh/install.md)" # Via Bash curl -fsSL https://fabro.sh/install.sh | bash ``` After installation, run one-time setup and per-project initialization: ```bash fabro install # global one-time setup cd my-project fabro init # per-project setup (creates .fabro/ config) ``` --- ## Key CLI Commands ```bash # Workflow management fabro run # execute a workflow fabro run --watch # stream live output fabro runs # list all runs fabro runs show # inspect a specific run # Human-in-the-loop fabro approve # approve a pending gate fabro reject # reject / revise a pending gate # Sandbox access fabro ssh # shell into a running sandbox fabro preview # expose a sandbox port locally # Retrospectives fabro retro # view run retrospective (cost, duration, narrative) # Config fabro config # view current configuration fabro config set # set a config value ``` --- ## Workflow Definition (Graphviz DOT) Workflows are `.dot` files using the Graphviz DOT language with Fabro-specific attributes. ### Node Types | Shape | Meaning | |---|---| | `Mdiamond` | Start node | | `Msquare` | Exit node | | `rectangle` (default) | Agent node (LLM turn) | | `hexagon` | Human gate (pauses for approval) | ### Minimal Hello World ```dot // hello.dot digraph HelloWorld { graph [ goal="Say hello and write a greeting file" model_stylesheet=" * { model: claude-haiku-4-5; } " ] start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] greet [label="Greet", prompt="Write a friendly greeting to hello.txt"] start -> greet -> exit } ``` ```bash fabro run hello.dot ``` --- ## Multi-Model Routing with Stylesheets Fabro uses CSS-like `model_stylesheet` declarations on the graph to route nodes to models. Use classes to target groups of nodes. ```dot digraph PlanImplementReview { graph [ goal="Plan, implement, and review a feature" model_stylesheet=" * { model: claude-haiku-4-5; reasoning_effort: low; } .planning { model: claude-opus-4-5; reasoning_effort: high; } .coding { model: claude-sonnet-4-5; reasoning_effort: high; } .review { model: gpt-4o; } " ] start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] plan [label="Plan", class="planning", prompt="Analyze the codebase and write plan.md"] implement [label="Implement", class="coding", prompt="Read plan.md and implement every step"] review [label="Review", class="review", prompt="Cross-review the implementation for bugs and clarity"] start -> plan -> implement -> review -> exit } ``` ### Supported Model Stylesheet Properties ``` model: # e.g. claude-sonnet-4-5, gpt-4o, gemini-2-flash reasoning_effort: low|medium|high provider: anthropic|openai|google ``` --- ## Human Gates (Approval Nodes) Use `shape=hexagon` to pause execution for human approval. Transitions are labeled with `[A]` (approve) and `[R]` (revise/reject). ```dot digraph PlanApproveImplement { graph [ goal="Plan and implement with human approval" model_stylesheet=" * { model: claude-sonnet-4-5; } " ] start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] plan [label="Plan", prompt="Write a detailed implementation plan to plan.md"] approve [shape=hexagon, label="Approve Plan"] implement [label="Implement", prompt="Read plan.md and implement every step exactly"] start -> plan -> approve approve -> implement [label="[A] Approve"] approve -> plan [label="[R] Revise"] implement -> exit } ``` Approve or reject from the CLI: ```bash fabro runs # find the paused run-id fabro approve # continue with implementation fabro reject --note "Add error handling to the plan" ``` --- ## Loops and Fix Cycles Use labeled transitions to build automatic retry/fix loops: ```dot digraph ImplementAndTest { graph [ goal="Implement a feature and fix failing tests automatically" model_stylesheet=" * { model: claude-haiku-4-5; } .coding { model: claude-sonnet-4-5; reasoning_effort: high; } " ] start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] implement [label="Implement", class="coding", prompt="Implement the feature described in TASK.md"] test [label="Run Tests", prompt="Run the test suite with `cargo test`. Report pass/fail."] fix [label="Fix", class="coding", prompt="Read the test failures and fix the code. Do not change tests."] start -> implement -> test test -> exit [label="[P] Pass"] test -> fix [label="[F] Fail"] fix -> test } ``` --- ## Parallel Nodes Run multiple agent nodes concurrently by forking edges from a single source: ```dot digraph ParallelReview { graph [ goal="Implement then review from multiple perspectives in parallel" model_stylesheet=" * { model: claude-haiku-4-5; } .coding { model: claude-sonnet-4-5; } .critique { model: gpt-4o; } " ] start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] implement [label="Implement", class="coding", prompt="Implement the task in TASK.md"] sec_review [label="Security Review", class="critique", prompt="Review the implementation for security issues"] perf_review [label="Perf Review", class="critique", prompt="Review the implementation for performance issues"] summarize [label="Summarize", prompt="Combine the security and performance reviews into REVIEW.md"] start -> implement implement -> sec_review implement -> perf_review sec_review -> summarize perf_review -> summarize summarize -> exit } ``` --- ## Variables and Dynamic Prompts Use `{variable}` interpolation in prompts. Pass variables at run time: ```dot digraph FeatureWorkflow { graph [ goal="Implement {feature_name} from the spec" model_stylesheet="* { model: claude-sonnet-4-5; }" ] start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] implement [label="Implement {feature_name}", prompt="Read specs/{feature_name}.md and implement the feature completely."] start -> implement -> exit } ``` ```bash fabro run feature.dot --var feature_name=oauth-login ``` --- ## Cloud Sandboxes (Daytona) To run agents in isolated cloud VMs instead of locally, configure a Daytona sandbox: ```bash fabro config set sandbox.provider daytona fabro config set sandbox.api_key $DAYTONA_API_KEY fabro config set sandbox.region us-east-1 ``` Then add sandbox config to your workflow graph: ```dot digraph SandboxedWorkflow { graph [ goal="Implement and test in an isolated environment" sandbox="daytona" model_stylesheet="* { model: claude-sonnet-4-5; }" ] start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] implement [label="Implement", prompt="Implement the feature in TASK.md"] test [label="Test", prompt="Run the full test suite and report results"] start -> implement -> test -> exit } ``` ```bash fabro run sandboxed.dot # spins up cloud VM, runs workflow, tears it down fabro ssh # shell into the running sandbox for debugging fabro preview 3000 # forward sandbox port 3000 locally ``` --- ## Git Checkpointing Fabro automatically commits code changes and execution metadata to Git branches at each stage. To inspect or resume: ```bash fabro runs show # see branch names per stage git checkout fabro//implement # inspect the code at a specific stage git diff fabro//plan fabro//implement # diff between stages ``` --- ## Retrospectives After every run, Fabro generates a retrospective with cost, duration, files changed, and an LLM-written narrative: ```bash fabro retro ``` Example output: ``` Run: implement-oauth-2024 Duration: 4m 32s Cost: $0.043 Files: src/auth.rs (+142), src/lib.rs (+8), tests/auth_test.rs (+67) Narrative: The agent successfully implemented OAuth2 PKCE flow. It created the auth module, integrated with the existing middleware, and added integration tests. One fix loop was needed after the token refresh test failed. ``` --- ## REST API and SSE Streaming Fabro runs an API server for programmatic use: ```bash fabro serve --port 8080 ``` ### Trigger a run via API ```bash curl -X POST http://localhost:8080/api/runs \ -H "Content-Type: application/json" \ -d '{ "workflow": "workflows/plan-implement.dot", "variables": { "feature_name": "dark-mode" } }' ``` ### Stream run events via SSE ```bash curl -N http://localhost:8080/api/runs//events ``` ### Approve a gate via API ```bash curl -X POST http://localhost:8080/api/runs//approve \ -H "Content-Type: application/json" \ -d '{ "decision": "approve" }' ``` --- ## Environment Variables ```bash # Required — at least one LLM provider key export ANTHROPIC_API_KEY=... export OPENAI_API_KEY=... export GOOGLE_API_KEY=... # Optional — cloud sandboxes export DAYTONA_API_KEY=... # Optional — Fabro API server auth export FABRO_API_TOKEN=... ``` --- ## Project Structure Convention ``` my-project/ ├── .fabro/ # Fabro config (created by `fabro init`) │ └── config.toml ├── workflows/ # Your DOT workflow definitions │ ├── plan-implement.dot │ ├── fix-loop.dot │ └── ensemble-review.dot ├── specs/ # Natural language specs referenced by prompts │ └── feature-name.md └── src/ # Your actual source code ``` --- ## Common Patterns ### Pattern: Spec-driven implementation ```dot digraph SpecDriven { graph [ goal="Implement from spec with LLM-as-judge verification" model_stylesheet=" * { model: claude-sonnet-4-5; } " ] start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] implement [label="Implement", prompt="Read specs/feature.md and implement it completely"] judge [label="Judge", prompt="Compare the implementation against specs/feature.md. Does it conform? Reply PASS or FAIL with reasons."] fix [label="Fix", prompt="Read the judge feedback and fix the implementation"] start -> implement -> judge judge -> exit [label="[P] PASS"] judge -> fix [label="[F] FAIL"] fix -> judge } ``` ### Pattern: Cheap draft, expensive refine ```dot digraph CheapThenExpensive { graph [ goal="Draft cheaply, refine with a frontier model" model_stylesheet=" * { model: claude-haiku-4-5; } .premium { model: claude-opus-4-5; reasoning_effort: high; } " ] start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] draft [label="Draft", prompt="Write a first draft implementation of the task"] refine [label="Refine", class="premium", prompt="Review and substantially improve the draft for correctness and clarity"] start -> draft -> refine -> exit } ``` --- ## Troubleshooting **`fabro: command not found`** - Re-run the install script and ensure `~/.local/bin` (or the install prefix) is on your `$PATH`. - Try `source ~/.bashrc` or `source ~/.zshrc` after installation. **Agent gets stuck in a loop** - Add a maximum iteration guard: use a counter variable and a conditional transition to force exit after N iterations. - Check your prompt — ambiguous exit conditions cause looping. **Human gate never pauses** - Confirm the node uses `shape=hexagon`, not just a label containing "approve". - Check `fabro runs show ` to confirm the run reached that node. **Sandbox fails to start** - Verify `DAYTONA_API_KEY` is set and valid. - Run `fabro config` to confirm `sandbox.provider` is set to `daytona`. - Check `fabro runs show ` for sandbox error details. **Model not found / API error** - Ensure the correct provider API key is exported (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, etc.). - Check the `model:` value in your stylesheet matches the provider's exact model ID. **Run exits immediately without doing work** - Verify the DOT file has a valid path from `start` (`shape=Mdiamond`) to `exit` (`shape=Msquare`). - Run `dot -Tsvg workflow.dot -o workflow.svg` to visually inspect the graph for disconnected nodes. --- ## Resources - [Documentation](https://docs.fabro.sh) - [Why Fabro](https://docs.fabro.sh/getting-started/why-fabro) - [DOT Language Reference](https://docs.fabro.sh/reference/dot-language) - [API Reference](https://docs.fabro.sh/api-reference/overview) - [Tutorials](https://docs.fabro.sh/tutorials/hello-world) - [Bug Reports](https://github.com/fabro-sh/fabro/issues) - [Feature Requests](https://github.com/fabro-sh/fabro/discussions)

相关技能

Agent 工作流

Skill Creator

创造有效技能指南。 当用户想创造出新的技能(或更新现有的技能),以专业知识,工作流程,或工具集成来扩展克洛德的能力时,应该使用这种技能.

Agent 工作流

Clawdhub

使用ClawdHub CLI搜索,安装,更新并发布从taladhub.com的代理技能. 需要获取苍蝇上的新技能时使用,将安装的技能同步到最新版本或特定版本,或者发布 npm-instainddhub CLI 的新/更新的技能文件夹.

Agent 工作流

Agent Team Orchestration

管弦乐团多代理团队,任务设定周期,交接协议,审查工作流程. 使用时间: (1)建立2+特派员队伍,具有不同专业,(2)确定任务路线和生命周期(收录框_ spec_建设_审查_完成),(3)在特派员之间制定交接协议,(4)建立审查和质量关口,(5)管理特派员之间的交流和文物共享.

Agent 工作流

Superpowers

Spec-first,TDD,子代理驱动的软件开发工作流程. 当:(1)构建任何新功能或应用——触发脑暴_计划_子代理执行回路,(2)调试出一个bug或测试失败——触发系统性的根起过程,(3)用户说"让我们构建","帮助我计划","我想添加X",或"这个被打破",(4)完成一个功…