Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Bend Skills

    1

    Develop, benchmark, and verify massively parallel functional programs using Bend Classic and Bend 2.

    Free

    1 useSecurity scanned
    bend-skills

    bend-skills

    Example session with this skill installed

    Write a Bend classic program to calculate Fibonacci(20) using a recursive divide-and-conquer approach, then benchmark it in both rs and c modes.

    • Read your context and instructions
    • Compiled the bend-

    I have created the recursive Fibonacci program and performed a benchmark across sequential (rs) and parallel (c) modes.

    Recursive Fibonacci Benchmark

    
    # fib_recursive.bend
    def fib(n):
      if n == 0:
        return 0
      elif n == 1:
        return 1
      else:
        # Divide-and-conquer: HVM reduces these branches in parallel
        return fib(n - 1) + fib(n - 2)
    
    def main():
      return fib(20)
    
    MetricRust (Sequential)C (Parallel)
    Median Time0.045s0.012s
    Min Time0.042s0.010s
    Result67656765

    Next steps

    1. Run bend_run(name="fib_recursive", mode="cu") if you have an NVIDIA GPU to test massively parallel reduction.
    2. Increase the input value to fib(32) to see a more significant speedup as the interaction graph grows.
    3. Use bend_read_program(name="fib_recursive") to verify the source before deployment.

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

    About this skill

    Writing massively parallel code often results in a trade-off between performance and developer velocity. This skill enables the creation, execution, and benchmarking of functional programs in Bend, a language designed for implicit parallelism across CPUs and GPUs via interaction combinators.

    What it does

    • Multi-version support provides dedicated workflows for both Bend classic (0.2.x) and Bend 2 (2.x) syntax.
    • MCP integration uses bend-mcp to write, compile, and run programs directly within your environment.
    • Hardware benchmarking compares execution across Rust/CPU, C/Parallel, and CUDA/GPU modes.
    • Verification and proofing validates syntax for classic programs and executes mathematical proofs for Bend 2 logic.
    • Performance analysis identifies code patterns like divide-and-conquer that benefit from implicit parallelism.

    How it works

    1. bend_check_install confirms the installed version (Classic vs v2) and hardware capabilities like CUDA availability.
    2. bend_write_program saves source files to the workspace for execution or compilation.
    3. bend_check performs static analysis to catch syntax errors or proof failures before runtime.
    4. bend_run executes the code using the appropriate backend mode (rs, c, or cu).

    Frameworks & tools

    Supports bend-lang (0.2.x), hvm (2.0.x), and the new bend (2.x) compiler. Works with CUDA for NVIDIA GPU acceleration and Node.js/C for transpilation targets.

    Why this beats prompting it yourself

    Generic models frequently hallucinate and mix syntax between the incompatible 0.2.x and 2.x versions. This skill enforces version-specific rules, such as affine type constraints in Bend 2 and loop-specific fork usage in Classic, ensuring code actually compiles.

    Use cases

    • Porting recursive algorithms to massively parallel GPU kernels.
    • Verifying mathematical properties of functional programs using Bend 2 proofs.
    • Benchmarking speedups between sequential Rust and parallel C backends.
    • Implementing IO-driven CLI tools using Bend's monadic effects.

    Known limitations

    Bend 2 requires explicit type annotations and lacks a native if keyword. CUDA execution requires nvcc and compatible hardware; otherwise, the skill falls back to CPU execution.

    Bend 2 requires explicit type annotations and lacks 'if' (uses match). GPU modes require nvcc and NVIDIA hardware. No cross-mixing of 0.2.x and 2.x syntax.

    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

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 27 days ago

    • Free with an Agensi account

    Requires

    Anthropic
    GitHub
    Llvm
    Bend Lang
    Bend MCP

    Permissions

    Terminal / Shell
    Network Access
    Read Files
    Environment Variables
    Write Files

    Allowed Hosts

    apt.llvm.org
    bend-lang.com
    api.anthropic.com
    api.github.com

    Skill/Conector IA

    Listed27 days ago

    What's inside

    Frequently Asked Questions

    This skill eliminates syntax hallucinations by enforcing strict version-specific rules for Bend Classic (0.2.x) and Bend 2 (2.x), ensuring that the generated parallel code actually compiles and runs on your hardware.

    The skill supports execution across Rust (single-core), C (multi-core), and CUDA (GPU) backends, allowing you to benchmark and identify the most efficient environment for your specific functional programs.

    Yes, the skill includes specialized workflows for Bend 2's verification features, allowing you to perform static analysis and execute mathematical proofs to validate program logic.

    You will need the Bend compiler (either version 0.2.x or 2.x) and HVM installed; for GPU acceleration, a compatible NVIDIA GPU and the `nvcc` compiler are required.

    The skill uses the `bend_check_install` function to automatically detect your local environment's version and hardware capabilities, tailoring its code generation to match your specific setup.

    New in Agents & Orchestration