More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Orchestrator-Worker Pattern

    1

    - **Worker (a script + a light model):** does the heavy lifting — iterating over millions of lines, doing math, transforming rows.

    Free

    Security scanned
    Orchestrator-Worker Pattern

    Orchestrator-Worker Pattern

    Example session with this skill installed

    A 64MB JSON of 2,755 communities, each with a description. Goal: give every community a short name. The orchestrator reads only the first few entries to see the shape, writes the task 'Give this community a short, meaningful name (max 3 words)', and runs the worker with --model qwen36-mx — 2,755 small calls instead of one context-overflowing paste.

    • Read your context and instructions
    • Compiled the orchestrator-worker pattern

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

    About this skill

    When a file is too big for the LLM's context — a 64MB JSON, a million-line log, a CSV with thousands of rows — the instinct is to paste it in and ask the model to "process this." That fails: the context saturates, instructions get lost, the model times out, or it silently forgets the middle.

    The orchestrator-worker pattern fixes this by splitting the job into two roles:

    • Orchestrator (the LLM): thinks about the goal, designs the processing logic, writes a small specialized script, runs it, and inspects the final result. It never touches the raw data directly.
    • Worker (a script + a light model): does the heavy lifting — iterating over millions of lines, doing math, transforming rows. When a step needs intelligence (e.g. "give this community a meaningful name"), the script calls a light, cheap model on each element individually, instead of asking one big model to do it all at once.

    The result: you process gigabytes without ever saturating context, and you pay only for the tokens each small step actually needs.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for LLM Ops.

    It is a pattern + template, not a finished product: you adapt the worker to your data shape. The template covers common cases (JSON/CSV/text, one model call per element); exotic shapes need a few lines of your own. It trades latency for safety (one call per element is slower but never crashes on context limits). For small files, just read them directly — don't reach for this pattern. Quality depends on the light model you point it at. The template is sequential by design; parallelize the element loop yourself if you need speed.

    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 buying a skill.

    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

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 15 days ago

    • Free with an Agensi account

    Software
    Python 3.10+httpxOpenAI-compatible model endpoint

    Set MODEL_ENDPOINT to it, for example a local router, DeepSeek or OpenRouter.

    Permissions

    File Scopes

    reads
    the
    input
    file
    you
    point
    it
    at
    writes
    one
    output
    (JSON/CSV/text)
    next
    to
    it;
    never
    touches
    anything
    else

    Purpose: a generic ORCHESTRATOR-WORKER template that processes a large file element-by-element, calling a light model per element. Network: it makes HTTPS requests to exactly ONE user-configured model endpoint (MODEL_ENDPOINT, default http://127.0.0.1:8080/v1) via httpx; the user chooses which endpoint, and the worker contacts no other host, does no scraping, and calls no third-party APIs. File I/O: reads the input file only; writes one output file. Env vars: MODEL_API_KEY (optional, if the endpoint needs auth), MODEL_ENDPOINT, MODEL_NAME. No eval(), no shell subprocesses, no curl|sh, no rm -rf, no base64 blobs. The template is fully readable and commented.

    Listed15 days ago

    What's inside

    Frequently Asked Questions

    No — it is a pattern + a generic template. You adapt the worker to your data shape. The template covers JSON/CSV/text and one model call per element; exotic shapes need a few lines of your own.

    Because it is a method, not a product. Free aligns expectations (no disappointment) and acts as a gateway to my paid skills (the proxy, the indexer, the factory).

    Only if your endpoint needs auth. Set MODEL_API_KEY. A local router usually doesn't.

    The template is sequential by design (easy to reason about). To parallelize, fork the element loop yourself — the pattern doesn't change.

    For small files that fit in context (just read them directly), or for global aggregations that need the whole dataset at once. It's for per-element work on big data.

    New in LLM Ops

    Free