More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    threadforge

    1

    Generate, visualize, and validate multi-agent orchestration workflows from JSON thread definitions.

    $3

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    threadforge

    threadforge

    Example session with this skill installed

    threadforge make a workflow that crawls a list of documentation URLs, summarizes each, and then has a senior-writer synthesize them into a single report.

    • Read your context and instructions
    • Compiled the threadforge

    I have initialized the workflow using the `b-nested-orchestration` template because it involves per-item work (summarizing) over a discovered list (URLs) followed by a synthesis step. ## Thread Topology: doc-synthesizer | Node | Activity | Inputs | Produces | | :--- | :--- | :--- | :--- | | **begin** | Initialize | `urls` (string[]) | - | | **crawler** | orchestrate | `urls` | `pages` | | **summarizer** | agent | `pages` | `summaries` | | **synthesizer** | agent (senior-writer) | `summaries` | `final_report` | | **end** | review | `final_report` | - | ```mermaid graph TD Start((Start)) --> Begin[begin: urls] Begin --> Crawl[fanout: crawler] subgraph per_url [Per URL] Crawl --> Summarize[agent: summarizer] end Summarize --> Synthesize[agent: synthesizer] Synthesize --> End((End: final_report)) ``` The thread has been validated. I've mapped the `synthesizer` step to the `senior-writer` agentType as requested. **Next steps** 1. Review the `threads/doc-synthesizer.thread.json` file for the specific agent instructions. 2. Approve this diagram by saying "Looks good" to trigger the JavaScript codegen. 3. Once generated, run the workflow using `run doc-synthesizer --urls='["url1", "url2"]'`.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Managing complex multi-agent workflows often results in brittle JavaScript files that are impossible to maintain or visualize. ThreadForge solves this by introducing a schema-first approach to agent orchestration. It treats the workflow topology as a validated JSON "thread," acting as the single source of truth for agent activities, handoffs, and logic. ## What it does - **Topology Modeling** defines agent interactions, parallel branches, and loops using a structured JSON schema. - **Workflow Codegen** generates runnable Claude dynamic-workflow scripts from validated thread definitions. - **Visual Documentation** renders Mermaid diagrams and handoff tables to make complex logic scannable. - **Strict Validation** runs a specialized Node.js validator to catch circular dependencies or broken handoffs before deployment. - **Workflow Decompilation** reverses existing workflow scripts back into JSON threads for easier maintenance. ## How it works 1. **Bootstrap** a new workflow by selecting a template from patterns like fanout-compare or nested-orchestration. 2. **Interview** the user to pin down specific agents, transformation logic, stop conditions, and data constants. 3. **Validate and Render** the JSON thread to ensure it meets the schema and produces a clear Mermaid topology. 4. **Generate** the final JavaScript runtime script only after the engineer approves the visual diagram. ## Where this comes from 1. **[Thread-Based Engineering](https://claudefa.st/blog/guide/mechanics/thread-based-engineering)** is the source model. A thread is *"a unit of engineering work over time, driven by you and your agent"* — with two mandatory human touchpoints: you begin it (prompt or plan) and you end it (review or validate). Everything between is agent work. 2. **[Dynamic Workflows](https://claudefa.st/blog/guide/development/dynamic-workflows)** is the target layer. Workflows are *"the orchestration layer for everything multi-agent,"* sitting **beneath** the thread model — which is exactly the boundary ThreadForge builds on: you author at the thread layer (strategy), the skill generates the orchestration layer beneath it (mechanism). You never hand-write `pipeline()` vs `parallel()` again, and when the runtime grows new primitives, your threads don't change — you regenerate. Workflows are *"powerful and expensive"* — *"wasteful for a two-line bug fix,"* and most traditional coding tasks don't need a panel of five reviewers. Read [when *not* to use a workflow](https://claudefa.st/blog/guide/development/dynamic-workflows#when-not-to-use-a-workflow) before drawing your first thread: if a single agent can hold the whole task in one context window, you don't need a thread — just ask your agent. ThreadForge is for the work that's *"too big, too parallel, or too prone to self-grading for one context window to handle."* ## Frameworks & tools This tool uses Node.js for validation and rendering scripts. It targets the Claude dynamic-workflows runtime and utilizes Mermaid.js for visualization. ## Why this beats prompting it yourself Writing workflow scripts manually often leads to hidden bugs in handoffs and inconsistent agent behavior. ThreadForge enforces a contract where logic is defined in JSON and verified by a validator, ensuring the generated code is always syntactically correct and architecturally sound. ## Use cases - Building an adversarial verification loop where a "critic" agent reviews a "generator" agent. - Orchestrating parallel data processing over a discovered list with a final synthesis step. - Creating multi-stage engineering pipelines that require human-in-the-loop review boundaries. ## Known limitations Does not support workflows that require mid-run human input; these must be split into separate threads. Limited to expressing topologies supported by the thread JSON schema.

    Workflows requiring mid-run human input must be split into separate threads. Expressible logic is limited to the provided JSON schema primitives.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 13 days ago

    Permissions

    Read Files
    Write Files
    Listed13 days ago

    What's inside

    Frequently Asked Questions

    ThreadForge uses a JSON-schema approach to replace fragile, hard-coded orchestration scripts with a validated "source of truth." It prevents common deployment errors like circular dependencies and broken agent handoffs by validating the logic before any code is generated.

    While the tool generates runtime scripts specifically for the Claude dynamic-workflows environment, the underlying JSON thread definitions can model logic for any LLM. The generated diagrams and documentation are framework-agnostic, providing a clear map of agent interactions regardless of the model used.

    Yes, the "Workflow Decompilation" feature allows you to input existing scripts and reverse-engineer them into structured JSON threads. This makes it easy to visualize legacy workflows and bring them into the ThreadForge validation ecosystem for safer maintenance.

    You will receive the core Node.js validation engine, the JSON schema for workflow modeling, a library of boilerplate templates (like fanout and nested-orchestration), and the rendering engine for Mermaid.js visualizations.

    ThreadForge currently does not support real-time human-in-the-loop (HITL) inputs during a single execution run. If your workflow requires a human approval step, you must design it as two separate threads where the first terminates at the review point and the second resumes after input.

    New in Agents & Orchestration