Skip to main content
Glama

hunt

Run multiple independent (fetch, plan, score) strategies concurrently, then merge and rank all results into a single leaderboard to compare yields across different hunt framings.

Instructions

Run multiple (fetch → map → score) hunt strategies in parallel and merge.

Each strategy is an independent (fetch, plan, score) triple with its own seed prompt or explicit seeds, plan template, and rubric. Strategies run concurrently; a failure in one does not halt the others. All scored refs across all strategies are merged into a single globally-ranked leaderboard so you can see which strategy produced the highest-yield finding.

This is the compound combinator that makes "run all the hunt framings at once" tractable — rather than sequentially trying one hunt shape at a time, you parallelise across framings (problem-driven, gap-in-field, broken-claims, tool-landscape, connection) and let the scoring sort them.

Strategy dict fields:

  • name (required) — short label used for tagging and per-strategy reporting in the leaderboard.

  • seeds (optional) — pre-supplied list of seed strings (each becomes a map input). Exactly one of seeds or fetcher_prompt must be set.

  • fetcher_prompt (optional) — prompt sent to a single run call that must emit a JSON array of seed strings (or a JSON object with a seeds key). The agent runs with network enabled.

  • planner_template (required) — prompt template for the map step. Use {input} as the placeholder for each seed.

  • rubric (required) — evaluator directive for the score step. Any form accepted by _evaluate_node: validate:<type>, score:<criterion>, or exec:<cmd>.

  • top_k (optional, default 3) — how many winners this strategy contributes to the unified leaderboard.

  • model_planner (optional, default "haiku") — model for the map step.

  • model_fetcher (optional, default "haiku") — model for the fetch step.

  • timeout (optional) — per-agent timeout in seconds.

Args: strategies: JSON array of strategy dicts (or a Python list). max_parallel_strategies: Upper bound on strategies running at once (default: 5). Each strategy internally parallelises its map step. top_k_global: Size of the unified leaderboard across all strategies (default: 10).

Returns: JSON with run_id, strategies (per-strategy summary including name, error-if-any, total_cost, winner_ref, best_score), and leaderboard (globally-ranked list tagged by strategy). The full per-ref scoring trace lives at strategy_details[i].ranked.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
strategiesYes
max_parallel_strategiesNo
top_k_globalNo

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
resultYes
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description fully covers behavioral traits: concurrent execution, failure isolation, merging into a global leaderboard, default values for strategies (top_k, models, timeout), and detailed return structure (run_id, strategies, leaderboard, per-ref scoring trace).

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is somewhat lengthy but well-structured: it starts with the core purpose, then explains the strategy dict in detail, followed by args and returns. Every sentence earns its place, though some sections (like the extensive strategy fields) could be slightly more compressed without losing clarity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (orchestrating multiple strategies), the description is complete. It covers usage, parameter details, defaults, failure behavior, merging logic, and return format. The output schema exists but the description also explains the return structure, so no gaps remain.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, but the description compensates by exhaustively documenting the strategies parameter with required/optional fields, each field's meaning, and examples. It also explains max_parallel_strategies and top_k_global with defaults, adding all meaning beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Run multiple (fetch → map → score) hunt strategies in parallel and merge.' It further explains it's a 'compound combinator' for parallelizing hunt framings, distinguishing it from sibling tools like run, map, or chain that operate on single sequences.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly indicates when to use this tool: 'makes run all the hunt framings at once tractable — rather than sequentially trying one hunt shape at a time.' It implies an alternative (sequential use) but does not explicitly list when not to use it. The parallel nature and failure isolation are well explained.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/stiege/swarm-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server