Refly: An Open-Source Skill Builder With a Vibe-Workflow Canvas

Most agent skills live as prompts inside a single tool. When the prompt grows you end up with a wall of text nobody can audit. Refly takes the opposite stance: skills are durable, versioned infrastructure, designed on a canvas, paused mid-run, and exported as APIs or chatops endpoints. The README leads with "Skills are infrastructure, not prompts."

Why This Skill Matters

Refly is positioned as the first open-source agent skills builder. The core idea is a "vibe workflow": you arrange Web Search, LLM, and Output nodes on a canvas, connect them, save, and run. The runtime is intervenable — you can pause, audit, and re-steer the agent mid-execution, which is rare in agent tools. Each saved workflow becomes a Skill you can register, version, and reuse.

The output side is where Refly is unusually broad: the same Skill runs against Claude Code, Cursor, Codex, Manus, AutoGen, and LangChain as an agent skill (plus MCP-powered workflows, Lovable, custom Python stacks, and Clawdbot per the README), and exposes itself as an HTTP API (POST /api/v1/workflows/{WORKFLOW_ID}/execute) or as a Slack / Lark / Feishu / Microsoft Teams bot trigger. The license is the ReflyAI Open Source License, which the README describes as essentially Apache 2.0 with some additional restrictions — read LICENSE before commercial use.

If you have ever wanted to graduate a one-off Claude Code prompt into something teammates can audit, share, and call from Slack, Refly is the tooling for that move.

Installation

Refly ships two install paths. The CLI is the entry point most users need.

# Global CLI install
npm install -g @powerformer/refly-cli

# Or run without installing
npx skills add refly-ai/<skill-name>

Once the CLI is installed, manage skills directly:

# Install a skill from the registry
refly skill install <skill-id>

# Publish your own skill to the registry
refly skill publish <skill-id>

Self-hosting is documented in the Self-Deployment Guide linked from the README (docs.refly.ai/community-version/self-deploy/). The README does not paste Docker Compose snippets; it points to the guide. Before any workflow runs, configure a model provider in Settings — Refly uses your own OpenAI or Anthropic key, not a managed backend.

Real Workflow: Build a Product-Research Skill on the Canvas

You want a reusable Skill that, given a product URL, fetches the page, extracts the value proposition, and returns a one-paragraph summary. Today it lives as a hand-pasted prompt in your team's Claude Code sessions; you want it versioned.

Step 1. Open the Refly canvas and add three nodes: a Web Search node pointed at the URL, an LLM node with your summarisation prompt, and an Output node for the structured result.

Step 2. Connect them in order: Web Search → LLM → Output. Save the workflow under a stable name like product-research-v1.

Step 3. Test the workflow by hitting the API directly:

curl -X POST https://your-refly-instance.com/api/v1/workflows/product-research-v1/execute \
  -H "Authorization: Bearer {your-token}" \
  -H "Content-Type: application/json" \
  -d '{"input": {"product_url": "https://example.com/product"}}'

Step 4. Poll the execution endpoint for status:

curl https://your-refly-instance.com/api/v1/executions/{execution_id} \
  -H "Authorization: Bearer {your-token}"

When the status is succeeded, the response body contains the structured summary. Publish it with refly skill publish product-research-v1 so teammates can refly skill install product-research-v1 and reuse the exact same pipeline.

Real Workflow: Trigger the Same Skill From Lark or Feishu

Once the skill is published, you can wire it into a chat surface so non-developers trigger it without opening Claude Code or curl. The README mentions this as Use Case 2.

Step 1. In Refly, register the skill as a webhook target. Refly exposes a stable URL per workflow; paste that URL into your Lark or Feishu bot's "trigger on message" handler.

Step 2. In the bot config, set the trigger phrase — for example analyze URL. When a user sends the phrase in a Lark room, the bot forwards the URL to the Refly webhook.

Step 3. Refly runs the workflow and posts the summary back into the same Lark thread. The bot acts as a thin shell; the heavy lifting still happens inside the canvas-defined skill.

Step 4. Treat the Lark wiring as documentation: every skill that should be chat-triggerable needs the bot's trigger phrase added to its SKILL.md. The next person who asks "can Claude do X in Lark?" finds the answer there.

• Build skills on the canvas before exporting — the versioned Skill is the unit of reuse, not the API call.
• Configure your model provider in Settings first; without an OpenAI or Anthropic key, no workflow runs.
• Use the pause-and-resteer runtime when a workflow fails mid-way — re-running from scratch wastes prior work.
• Cursor export is listed as "coming soon" in the README; do not assume it is available today.
• Read LICENSE before commercial use; the ReflyAI license is "essentially Apache 2.0 with additional restrictions," which matters for closed-source products.
• Treat the Lark/Feishu guide as best-effort — the README flags it as "coming soon".

When Not to Use This

If the workflow is a single linear prompt with no branching, Refly is overkill — just paste the prompt into Claude Code. Refly pays off when the workflow has nodes, mid-run intervention, versioned reuse, or a chatops surface; for one-shots, the canvas setup overhead loses.

See the leaderboard for more skill-creation tools.