Skip to content
Skills Library
AI & agents · Automation

bulk

/bulk

Batch API processing for 50% cost savings on non-urgent bulk analysis. Triggers on: batch, bulk process, batch API, cheap bulk, process many, overnight analysis, 50% savings.

Repository
attune-ai ↗
Licence
Apache-2.0
Last repository change
24.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 24.10.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Batch API processing for 50% cost savings on non-urgent bulk analysis. Triggers on: batch, bulk process, batch API, cheap bulk, process many, overnight analysis, 50% savings.

Original author description

Batch API processing for 50% cost savings on non-urgent bulk analysis. Triggers on: batch, bulk process, batch API, cheap bulk, process many, overnight analysis, 50% savings.

How it works

  1. Scoping
  2. Execution
  3. Output
  4. When to use
Original SKILL.md headings · 82 lines, 450 words
SKILL.md preview
---
name: bulk
description: "Batch API processing for 50% cost savings on non-urgent bulk analysis. Triggers on: batch, bulk process, batch API, cheap bulk, process many, overnight analysis, 50% savings."
---
# Bulk Batch Processing

**IMPORTANT: Start your response with a context preamble.**

Call `help_lookup(topic="bulk", mode="preamble")` and display
the returned `preamble` text as a blockquote. Then tell the
user they can say "tell me more" for a step-by-step guide, or
answer the scoping questions below to proceed.

If the MCP call fails, fall back to:

> **Bulk** — Submits tasks to the Anthropic Batch API for 50% cost savings. Runs asynchronously (up to 24h), so it's ideal for non-urgent, high-volume analysis rather than interactive work.

## Scoping

Before submitting, ask:

1. **What to batch**: "Which tasks should I batch — e.g. a
   workflow run across many files, or many independent
   analyses?"
2. **How many / which targets**: "List the items (files,
   modules, or task inputs) to process."
3. **Urgency check**: "Batch results take up to 24h. Is
   non-urgent turnaround acceptable? If you need it now, run
   the single-shot workflow instead."

## Execution

### Shared command workspace (preferred)

Open adapter `bulk` with either the provider-ready `requests` list or an
existing `batch_id`. Present the widget or returned Markdown. New submissions
must consume the bound, explicitly confirmed `submit_batch` action before
calling `analyze_batch`; a reconnect uses the read-only `check_batch` action.
Publish the real provider response as `submission_result` or `status_result`.
Only a response with the exact accepted task count and a non-empty batch id may
render as submitted. Rejections and timeouts must render “did not submit” (or
“did not complete” for status), never a synthetic batch id. Preserve the same
decision and receipt in compact text when the shared tools are unavailable.

The workspace status receipt completes the interactive invocation; `pending`
does not mean the remote work completed. Reinvoke later with the returned
`batch_id` to reconnect.

Call the `analyze_batch` MCP tool with a `requests` array,
one entry per task:

```
analyze_batch(requests=[
  {"task_id": "<unique-id>", "task_type": "<e.g. analyze_logs>",
   "input_data": {...}, "model_tier": "capable"},
  ...
])
```

- `task_id` and `task_type` and `input_data` are required per
  request; `model_tier` is optional (`cheap` / `capable` /
  `premium`, default `capable`).
- **Premium tier policy:** interactive premium = `claude-fable-5-1`
  (with server-side opus fallback); **batch premium =
  `claude-opus-4-8`** — the Batch API rejects the `fallbacks`
  param, so fable models are downgraded at request-build time.
- The call returns a batch id and submits asynchronously — it
  does not block for results.

## Output

Report back:

- The **batch id** and submitted task count.
- That processing is asynchronous (up to 24h) at 50% cost.
- How to retrieve results later (re-invoke and reference the
  batch id).

## When to use

- Multi-workflow analysis runs, project-wide audits, nightly
  / CI jobs — anything non-interactive where cost matters more
  than latency.
- For a single urgent analysis, use the matching workflow
  skill directly (e.g. security-audit, bug-predict) instead.

Versions

RepositoryScoreLicence
This page · smart-ai-memory/attune-ai100Apache-2.0
hamzafer/claude-routines100MIT

Identical content appears in 1 other GitHub folders. We show one copy with the highest score.

Database snapshot: 13.11.2026 · package version 95a8c7ccc82d (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100batch-api-orchestrator
    This skill should be used when the user asks to "batch LLM requests", "should I use the batch API", "estimate batch vs realtime cost", "design a bulk LLM job", or "process thousands of prompts cheaply".
  • 100code-execution
    Execute Python code locally with marketplace API access for 90%+ token savings on bulk operations. Activates when user requests bulk operations (10+ files), complex multi-step workflows, iterative processing, or mentions efficiency/performance.
  • 100processing-api-batches
    Optimize bulk API requests with batching, throttling, and parallel execution. Use when processing bulk API operations efficiently. Trigger with phrases like "process bulk requests", "batch API calls", or "handle batch operations".
  • 100processing-api-batches
    Optimize bulk API requests with batching, throttling, and parallel execution. Use when processing bulk API operations efficiently. Trigger with phrases like "process bulk requests", "batch API calls", or "handle batch operations".
  • 100klingai-batch-processing
    Process multiple video generation requests efficiently with Kling AI. Use when generating batches of videos or building content pipelines. Trigger with phrases like ''klingai batch'', ''kling ai bulk'', ''multiple videos klingai'', ''klingai parallel generation''.
  • 100klingai-batch-processing
    Process multiple video generation requests efficiently with Kling AI. Use when generating multiple videos or building content pipelines. Trigger with phrases like 'klingai batch', 'kling ai bulk', 'multiple videos klingai', 'klingai parallel generation'.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.