Everything Ollama Herd Does

And why it matters. Intelligent routing, zero-config discovery, adaptive learning, multimodal support, and a real-time dashboard, on Macs, Linux servers, and Windows PCs. Features that need Apple Silicon or macOS are labeled.

Intelligent Routing

8-Signal Scoring Engine

Every request is scored across eight signals to find the optimal node. This isn't round-robin or random selection, it's a weighted decision that considers the physical reality of each device. The eighth signal is the one you feel: a follow-up message goes back to the machine that already holds that conversation, so it doesn't re-read the whole history first. Check the X-Fleet-Affinity response header to see it happen.

Signal What It Measures
Model warmth A model already loaded in memory (hot) gets +50 points. Cold-loading a 40GB model takes 15–30 seconds, the router avoids it whenever possible. A model Ollama could only partly fit on a GPU runs partly on the CPU, so since v0.12.12 it scores like a cold one and a fully loaded copy elsewhere wins (exact rule).
Memory fit Not just "is there enough memory?" but how comfortably the model fits in what it can use without evicting another model, capped by the node's dynamic memory ceiling: free GPU memory on a machine with a GPU (v0.12.10), free RAM on Apple Silicon and machines without one. Whether a model can load on a machine at all is checked against free RAM plus free GPU memory (v0.12.9). Herd detects GPU memory on Linux for NVIDIA and AMD.
Queue depth A hot model on a saturated node loses to a warm model on an empty node. Load spreads naturally.
Estimated wait time Uses real per-node, per-model latency history (p75) to estimate actual wait time. A queue of 3 on a fast model differs from a queue of 3 on a slow one.
Role affinity Large models route to powerful machines. Small models route to lighter hardware, preserving big-machine capacity.
Availability trend Is this device freeing up or getting busier right now? Keeps long requests off a machine whose owner just got busy. Only for nodes with capacity learning turned on (opt-in).
Context fit Can this node handle the requested context size without triggering a model reload?
Session affinity Did this node serve the previous turn of this conversation? Follow-up turns go back to it, so it can reuse the history it already processed instead of re-reading all of it on another machine. A conversation's first turn goes where its long system prompt and tools are already cached (prefix affinity).
Eviction charge (v0.12.10) Would loading the model here push another model out of memory, and is that model busy? A machine with room wins, so two models that cannot share one GPU settle on different machines instead of swapping on every request.

Model Fallbacks

Clients can specify backup models. If the primary model isn't available anywhere in the fleet, the router tries alternatives in order, same scoring pipeline, just a different model.

Auto-Retry

If a node fails before the first response chunk is sent, the router re-scores the remaining nodes and retries on the next-best option. Up to 2 retries. Clients never see the failure.

Context Protection

Pins every request to the context window the model is already loaded with, so a client's smaller or missing num_ctx cannot make Ollama reload a large model mid-session. When a request needs more context than the loaded model has, Herd switches to a bigger loaded model in the same category if one is hot.

Silent Truncation Detection (v0.12.0)

When a prompt is longer than the model's context window, Ollama cuts it and still answers normally, with no error. In our tests it dropped a whole message and answered from 24 tokens of a 6,000-token prompt. Herd compares how many tokens the model actually read with how many were sent, logs any loss, and raises a health card naming the model and its window, so you know to give that model more context. How to spot it yourself.

Thinking Model Support

Auto-detects chain-of-thought models (DeepSeek-R1, QwQ, Phi-4-Reasoning, GPT-OSS) and inflates num_predict by 4× to accommodate thinking tokens. Diagnostic headers (X-Thinking-Tokens, X-Output-Tokens, X-Budget-Used, X-Done-Reason) let clients see exactly how the token budget was spent.

Device-Aware Scoring (v0.6.0)

Every node's chip and memory bandwidth flow through the heartbeat into the scoring pipeline. Role affinity scales continuously with bandwidth instead of flat memory tiers. For a model over 20 GB, an M3 Ultra (819 GB/s in Herd's table) scores +25, the cap, which any chip reaches at 800 GB/s; an M4 Max at 546 GB/s scores +18.65; an M3 Pro at 150 GB/s scores +8.75. Mid-size models (8 to 20 GB) get 60% of that, and models under 8 GB invert it, so smaller, slower machines score higher for them and the fast machine stays free for heavy work. Queue-depth penalty normalizes by each node's bandwidth share of the fleet median, so a queue of 4 on a 4×-faster node is treated like a queue of 1. Expected steady-state load distribution equals each node's bandwidth share of the fleet total.

Bandwidth comes from a lookup table: Apple Silicon chips, plus a handful of NVIDIA cards when a Linux node reports one. Hardware the table doesn't know falls back to memory tiers. Herd does not read GPU utilization or route by GPU load. It does read GPU memory: from v0.12.9 a model bigger than RAM alone can load on a machine that holds it across RAM and GPU memory, and from v0.12.10 memory-fit scoring on a GPU machine uses the card’s free memory, so an empty card beats a full one. See Ollama across mixed GPUs.

Line chart of role affinity points against memory bandwidth from 50 to 900 GB/s. For models over 20 GB the score rises from about 6 to a cap of 25 at 800 GB/s: M3 Pro at 150 GB/s scores 8.75, M4 Max at 546 GB/s scores 18.65, M3 Ultra at 819 GB/s scores 25. Models of 8 to 20 GB get 60% of that, topping out at 15. Models under 8 GB fall from about 14 to a floor of 3, so slower machines score higher for them.
For a model over 20 GB, role affinity is 5 points plus 1 point per 40 GB/s of memory bandwidth, capped at 25, so an M3 Ultra earns 25 and an M3 Pro 8.75; small models get the reverse. Sourced: the Ollama Herd v0.9.5 scorer formula and its chip bandwidth table. A chip missing from the table falls back to memory-size tiers (up to +15).
How does this compare? No other local routing tool offers 8-signal device-aware scoring. See how Herd's routing compares to exo, GPUStack, and vLLM.

Smart Benchmark

Multimodal Benchmark Suite

Benchmark your entire fleet across all five model types, LLMs, embeddings, image generation, speech-to-text, and vision, in a single run. Smart mode auto-discovers fleet capabilities and selects an optimal model mix to fill available memory.

Two Benchmark Modes

Default mode benchmarks whatever models are currently loaded, quick sanity check. Smart mode analyzes fleet hardware, pulls recommended models, and runs a comprehensive benchmark that fills available memory with an optimal mix. Duration, concurrency, and model types are all configurable.

Per-Model and Per-Node Charts

Four new benchmark visualizations: per-model latency and throughput, per-model success rates, per-node concurrency utilization, and an overall timeline. Results persist in SQLite, compare runs over time.

Dynamic Context Optimization

Context Usage Tracking

Every request's actual token usage (prompt + completion) is tracked. The context optimizer computes p50, p75, p95, p99, and max distributions per model, revealing that most models use under 5% of their allocated context window.

Automatic Right-Sizing

Three-phase optimization: observe actual usage, recommend optimal context sizes, then auto-adjust. A model allocated 131K context but using only 5K at p99? Herd recommends 16K, freeing KV-cache memory (50GB+ in that case) that can be used to load additional models.

Context Usage API

The /dashboard/api/context-usage endpoint shows per-model utilization percentage, recommended context size, and potential memory savings. The health engine warns when allocated context exceeds actual usage by 4× or more.

Zero-Config Discovery

mDNS Auto-Discovery

Run herd-node on any Mac, Linux, or Windows machine on the same network. It finds the router automatically via mDNS (Bonjour/Avahi). No IP addresses to configure, no config files to maintain, no DNS entries to manage.

Heartbeat-Based Health

Each node sends heartbeats every 5 seconds with full system state: CPU, memory, memory pressure (macOS and Linux), CPU temperature where the OS exposes it (Linux, some Windows machines), loaded models, disk space, Ollama version. The router knows the state of every device in real time.

LAN Proxy

The node agent automatically bridges LAN traffic to localhost Ollama. Other devices can reach each node's Ollama through the fleet without manual port forwarding.

Keeps Working Without the Internet

Requests go from your client to the router to Ollama, all on your own network, so nothing in that path needs the internet. On our own herd it held up for real: on 2026-11-20 the internet was out for about six hours, and Herd served 260 requests in that window, all completed, with no restarts. That was a one-machine herd with every client on the same Mac. A multi-machine herd also needs the LAN between its machines; if yours rides out an outage, tell us how it went.

Adaptive Learning

Capacity learning is opt-in per node (herd-node --learn-capacity), meant for machines people also use for work. Meeting detection and app fingerprinting run as part of it.

Capacity Learner

A 168-slot behavioral model (one slot per hour of the week) learns each device's availability patterns. After a few weeks, the router knows your laptop is busy Tuesday mornings and the Linux server in the closet is always available. Routing decisions reflect these patterns.

Meeting Detection (macOS)

Detects active cameras and microphones and hard-pauses the node. No inference competes with your video calls. The node resumes automatically when the meeting ends.

App Fingerprinting (all platforms)

Classifies the current workload on each device (idle / light / moderate / heavy / intensive) using CPU, memory, and network patterns, without reading app names or window titles. Heavy workloads reduce the node's memory ceiling, shifting requests to other machines.

Latency Tables

Per-node, per-model response times tracked in SQLite. The scoring engine uses historical latency to estimate wait times accurately. A node that's consistently slow for a particular model gradually gets fewer requests for that model.

Queue Management

Per Node:Model Queues

Each node+model pair has its own queue with dynamic concurrency. The router knows how many parallel requests each device can handle without degrading performance.

Holding Queue

When no node can take a request right now (every candidate is offline, paused, under memory pressure, or short on free memory), it waits in a holding queue instead of failing. The router rescores it every 2 seconds for up to 30 seconds as node states change.

Pre-Warming

When a primary node's queue gets deep, the router proactively loads the same model on the runner-up node. The next request hits a hot model instead of waiting.

Background Rebalancer

Runs every 5 seconds, moving queued requests from overloaded nodes to nodes with spare capacity, but only where the model is already loaded.

Zombie Reaper

Detects and cleans up stuck in-flight requests that never completed. Keeps queues accurate.

Backends

Ollama, the default runtime

Every node that runs herd-node needs Ollama, on macOS, Linux, or Windows, with whatever acceleration Ollama uses there (Metal on Apple Silicon, CUDA on NVIDIA). The router speaks Ollama's native API for chat, embeddings, model pulling, and lifecycle management. All mainstream GGUF models work out of the box, Gemma, Qwen, DeepSeek, Llama, Phi, GPT-OSS, hundreds more.

MLX, first-class alongside Ollama (Apple Silicon) (v0.6.0)

Apple Silicon nodes can optionally spawn one or more mlx_lm.server processes alongside Ollama. Useful for MLX-specific models (Qwen3-Coder-Next MoE, Qwen3-Coder-30B-A3B-Instruct) and for running a dedicated compactor model side-by-side with the main coding model without Ollama eviction risk.

Multi-MLX-Server per Node (Apple Silicon) (v0.6.0)

Configure N MLX servers on N ports via FLEET_NODE_MLX_SERVERS. Each runs in its own process with independent logs. Memory-pressure startup gate estimates weight size from the HuggingFace disk cache and refuses to spawn when the total (model + headroom) won't fit, surfaces the skip reason on the dashboard instead of failing silently.

Multi-Node MLX Aggregation (Apple Silicon) (v0.6.0)

Set FLEET_NODE_MLX_BIND_HOST=0.0.0.0 to expose MLX servers on the LAN. The router walks every online node and routes each MLX request to a healthy server hosting the requested model. Per-URL httpx.AsyncClient cache isolation prevents a slow server from back-pressuring a fast one.

Native Text Embedding Server (v0.7.0)

A dedicated FastAPI server on port 11439 runs nomic-embed-text via fastembed + ONNX Runtime, no PyTorch, no Ollama. The router intercepts /api/embed calls for nomic-embed-text before they reach Ollama and proxies to the best node's text embedding server. Zero contention with LLM inference slots, the structural fix for an embed-timeout incident where a running 120B inference held both Ollama parallel slots and embedding requests queued indefinitely despite 14% CPU and 291 GB free RAM. Weights download automatically on first request (130 MB Q-quantized int8) and cache in ~/.fleet-manager/models/text-embedding/. Enable via uv sync --extra embedding, same flag that enables vision embeddings.

Vision Embedding Service

A separate vision-embedding service exposes DINOv2, SigLIP2, and CLIP via ONNX Runtime, so it is not tied to one platform. The dashboard shows availability per node and the health engine fires vision_backend_missing when weights are cached on disk but onnxruntime isn't loadable, closes the "chip says available but /embed-image returns 500" footgun.

Multimodal Support

LLM Inference

Full support for chat completions and text generation. Both streaming and non-streaming. OpenAI and Ollama API formats.

Embeddings

Route embedding requests to the node with the embedding model loaded. Supports /api/embed and /api/embeddings (Ollama format). nomic-embed-text goes to the dedicated native fastembed server (port 11439) when a node runs one, so embedding traffic never queues behind LLM inference, and to Ollama otherwise. Once your herd has served it, it stays on the backend that served it last: the two backends’ vectors differ, and one index should not mix them. Other embedding models route to Ollama.

Image Generation

Routes image generation requests to Apple Silicon nodes running mflux (FLUX models) or DiffusionKit (Stable Diffusion 3 and 3.5). Ollama's native image models (experimental in Ollama) go through the normal Ollama path instead, so they are not tied to Apple Silicon. OpenAI-compatible /v1/images/generations endpoint included.

Speech-to-Text

Routes transcription requests to nodes with MLX and Qwen3-ASR installed. Apple Silicon only.

Model Pulling

Pull models onto fleet nodes through the router. Auto-selects the node with the most available memory, or target a specific node. Streams progress in real time.

Real-Time Dashboard

A web dashboard at /dashboard with five tabs, in light or dark (it follows your system, or pick one in Settings):

  • Overview, A one-line verdict (Healthy, Needs attention, Critical) and the health score, then live figures with sparklines (requests per minute, tokens per second, time to first token, error rate, running and queued), an activity chart of tokens per second by model, and node cards that plot CPU, memory and tokens per second on shared scales so the odd node out stands out. Updated live over Server-Sent Events.
  • Models, Per-model latency, tokens/sec and usage, with their trend charts over one time range
  • Usage, Per-tag analytics with request volume, latency, tokens, error rates
  • Health, 45+ automated health checks with severity levels, findings first, including context waste detection, silent input truncation, MLX server monitoring and backend availability, with model mix recommendations per node below
  • Settings, Runtime toggles, config overview, node version tracking, and Appearance

Benchmarks has its own page, linked from Models and Settings: capacity growth over time with per-run throughput and latency percentiles. Every older dashboard URL still works and opens the right section.

No external dependencies. No build process. Opens in any browser.

Fleet Overview tab of the Ollama Herd dashboard showing two node cards. Left card: Neons-Mac-Studio online, CPU 63.8%, Memory 489 GB / 512 GB, 32 cores, with 5 models loaded (gpt-oss:120b, qwen3:8b, gemma3:27b via Ollama; Qwen3-Coder-Next-4bit and Qwen3-Coder-30B-A3B-Instruct-4bit via MLX) plus image generation, speech-to-text, embedding, and vision services. Right card: Twin2-Macbook-Pro-M4 online, CPU 47.3%, Memory 61.4 GB / 128 GB, 16 cores, with gemma3:4b, gemma3:27b, qwen3-coder:30b-agent, and nomic-embed-text loaded.
Fleet Overview tab. Each node surfaces CPU, memory, core count, hot-loaded models with backend + quant + context window, and the full set of services (image gen, STT, embeddings, vision) available for routing.

Fails Loudly, Never Silently

When something goes wrong, Herd tells your client in the client’s own protocol instead of passing a broken answer off as a good one. Each of these was a quiet failure once, and each is fixed in a release you can install today:

  • A cut-off answer is a failure, not a finished one. When the backend’s stream ends early, the client gets its protocol’s real error event (or a 502), not a normal stop reason over partial text. On the OpenAI, Anthropic and Responses APIs since v0.11.4, and on Ollama’s own non-streaming API since v0.12.5.
  • An empty embedding is never a success. No embedding request counts as completed unless the backend returned one vector per input; a wrong count is a 502 (v0.12.6), which also fixed the legacy /api/embeddings call that returned an empty vector with a 200.
  • A full queue says so. Ollama’s queue-full answer comes back as 429 with Retry-After: 10 on every API (v0.12.11), so your client backs off instead of seeing a generic error.
  • A request that fails before its first token gets a real status code, streaming or not, instead of a 200 with an error inside (v0.12.11).
  • X-Fleet-Node names the machine that actually answered, along with its retry count, even when a retry moved the request to a second machine (v0.12.11).

Every routed response carries an X-Request-Id (v0.12.11) you can look up in the router’s traces to see exactly what happened (API reference). Prompts that Ollama silently truncates are caught too: see Silent Truncation Detection.

Health Monitoring

45+ Automated Health Checks

The health engine continuously monitors fleet liveness, routing quality, backend reliability, and observability. Each check carries a severity (INFO / WARNING / CRITICAL) and an actionable recommendation. Highlights:

Category What it catches
Fleet livenessOffline nodes, degraded nodes, memory pressure (OS-reported, not just %), underutilized nodes
Routing qualityVRAM fallbacks (requests served by a loaded model of the same category, summarized over 24 hours), model thrashing, request timeouts, retry rates, context waste detection
MLX backendServer down (CRITICAL), server quarantined (crash-loop containment after 5 crashes/5min), memory-blocked (skipped start due to memory gate)
Text embedding backendEmbed error rate (WARN at ≥5/hr, CRIT at ≥25/hr), text-embedding backend missing (nomic weights cached but fastembed not installed), text-embedding Ollama bypass (native server not running so embed requests still contend for LLM inference slots), nomic still loaded in Ollama despite native server handling traffic (VRAM waste signal)
Vision backendBackend missing (weights cached but onnxruntime not loadable), closes the "chip says available but /embed-image returns 500" footgun
ObservabilityTrace-store write failures (closes a silent SQLite-contention black hole), version mismatch, KV-cache bloat, zombie reaper activity
Stream + client integrityClient disconnects, incomplete streams, context protection events, prompts Ollama silently truncated

Each check has a severity level and actionable recommendation. Available via the dashboard and the /dashboard/api/health endpoint.

API Compatibility

OpenAI Format

Endpoint Purpose
POST /v1/chat/completionsChat completions (streaming + non-streaming)
GET /v1/modelsList available models
POST /v1/responsesOpenAI Responses API, used by Codex CLI and the Codex desktop app. Stateless (no previous_response_id) and served by Ollama-backed models only; see the Codex guide
POST /v1/images/generationsGenerate images

Ollama Format

Endpoint Purpose
POST /api/chatChat completions
POST /api/generateText generation
POST /api/pullPull models onto fleet nodes
GET /api/tagsList all models
GET /api/psList loaded models
POST /api/embedGenerate embeddings
POST /api/embeddingsGenerate embeddings (alternative)

Anthropic Messages Format (v0.6.0)

Point Claude Code CLI at your herd with one env var: ANTHROPIC_BASE_URL=http://localhost:11435. The router translates Anthropic Messages ↔ Ollama format transparently, including tool-use, streaming SSE events, and count_tokens. No LiteLLM sidecar.

Endpoint Purpose
POST /v1/messagesAnthropic Messages API (streaming + non-streaming)
POST /v1/messages/count_tokensToken budget pre-flight (tiktoken estimate)

See the Claude Code integration guide for model mapping, tier routing (claude-haiku-* vs claude-sonnet-* / claude-opus-*), and the four stability knobs for long sessions.

Claude Code Reliability Layer (v0.6.0)

Three-Layer Context Management

Mirrors hosted Claude's behavior so local Qwen3-Coder sessions don't fall apart past 30K tokens.

  • Layer 1, mechanical tool-result clearing. When the Anthropic request exceeds FLEET_ANTHROPIC_AUTO_CLEAR_TOOL_USES_TRIGGER_TOKENS (default 100K), older tool_result blocks are replaced with a short placeholder before the request reaches the model. No LLM call, microsecond-scale. Real Claude Code session verified: first fire reclaimed 81K tokens (206K → 125K, a 39% reduction).
  • Layer 2, LLM-based compactor with dynamic curator selection. Off by default (FLEET_CONTEXT_COMPACTION_ENABLED=true turns it on). Once the prompt passes FLEET_CONTEXT_COMPACTION_BUDGET_TOKENS (default 20K), it summarizes bulky tool_result blocks; if the prompt is still over 150K after Layer 1, it summarizes every one of them. If no capable model is free, it passes the request through unchanged. Summary work goes to whatever capable model is already hot and idle rather than cold-loading a default. Cache key deliberately excludes curator_model so MLX prefix-cache bytes stay stable across curator-selection events.
  • Layer 3, pre-inference 413 cap. If the prompt is still over FLEET_ANTHROPIC_MAX_PROMPT_TOKENS (default 180K) after clearing + compaction, the route returns HTTP 413 with a run /compact and resubmit message before the request reaches the model, no multi-minute MLX prefill wedge.
Pipeline, v0.9.5 defaults, Anthropic Messages route
Claude Code request: 206K tokensa real long session, as measured
over 100K tokens
Layer 1: tool-result clearing (on)Older tool results become a short placeholder, the 3 most recent stay verbatim. No LLM call. Measured: 206K to 125K tokens, 39% smaller.
over 20K tokens, and only if you turned it on
Layer 2: LLM compactor (off by default)An idle loaded model summarizes bulky tool results; above 150K it summarizes all of them. Passes through unchanged if no capable model is free.
still over 180K tokens?
No: sent to the modelrouted like any other request
Yes: Layer 3, HTTP 413refused before inference, with "run /compact and resubmit"
On a real 206K-token Claude Code request, Layer 1 alone cut the prompt to 125K, under the 180K cap, without calling a model; Layer 2 only runs if you enable it, and Layer 3 refuses what is still too big instead of letting it stall.

Tool-Schema Fixup

Claude Code's 27-tool schema has heavy optional-param usage (Grep has 13 optional params); llama.cpp#20164 documents that Qwen3-Coder starts silently dropping optional params at ~30K tokens and loops tool calls with a field consistently missing. Herd promotes optional params with known-safe defaults (Bash.timeout=120000, Grep.head_limit=250, Read.offset=0) to required-with-default in the outbound schema.

Tool-Call JSON Repair

Local coding models occasionally emit tool_use.input with minor syntax errors. A repair cascade tries strict parse → json-repair → a 4-pattern regex catalog adapted from open-source proxies → pass-through. Every repair attempt is schema-validated before substitution, never hides real failures silently. Per-model repair counters exposed on /fleet/queue. Repair runs on MLX-served models (Apple Silicon); Ollama-served models use Ollama's own tool-call parsing.

MLX Wall-Clock Timeout

FLEET_MLX_WALL_CLOCK_TIMEOUT_S (default 300s) catches wedged-request syndrome where mlx_lm.server keeps emitting tokens slowly but never stops. On timeout, the slot is released and the route returns 413 with the /compact hint. No silent server-side retry, client owns the decision of whether to resubmit.

Warm-Prompt Preload

After mlx_lm.server passes its health check, a fire-and-forget 1-token request primes the prompt cache with the system-prompt prefix. Based on measured 1.3–2.25× TTFT improvement on the first real request.

Why does Claude Code break at 30K tokens on local models? See the full research in Claude Code integration guide and the why-claude-code-degrades-at-30k analysis.

Fleet Management

Endpoint Purpose
GET /fleet/statusFull fleet state
GET /fleet/queueLightweight queue depths

Works with Open WebUI, LangChain, CrewAI, AutoGen, Aider, Continue.dev, LlamaIndex, LiteLLM, and any OpenAI-compatible client. Just change the base URL.

Request Tagging

Tag requests with an app identifier to get per-tag analytics. Add X-Herd-Tags: my-app to any request and the dashboard breaks down usage by app, request volume, latency, tokens, error rates. See which tools consume the most fleet resources.

Platform Support

Feature macOS Linux Windows
LLM routing, scoring, queuesYesYesYes
EmbeddingsYesYesYes
mDNS auto-discoveryYesYesYes
Dashboard & tracesYesYesYes
OpenAI, Ollama, Anthropic Messages, Responses APIsYesYesYes
Tool-schema fixup, context management (router-side)YesYesYes
Tool-call JSON repair (MLX models)Apple Silicon––
MLX backendApple Silicon––
Image gen (mflux, DiffusionKit)Apple Silicon––
Image gen (Ollama native)YesYesYes
Speech-to-text (MLX)Apple Silicon––
Meeting detectionYes––
Memory pressure detectionYesYes–

Core routing works identically on all platforms, with or without an NVIDIA GPU. Apple Silicon and macOS-only features degrade gracefully on other machines: a Linux or Windows node simply doesn't advertise them, and the router sends those requests to a Mac that does.

Configuration

All settings via environment variables with FLEET_ prefix (server) or FLEET_NODE_ prefix (node). 44+ configuration options covering scoring weights, queue behavior, retry limits, heartbeat intervals, and more. Sensible defaults mean you don't need to touch any of them to get started.

See How We Compare

Honest, detailed comparisons with feature tables, pros/cons, and when to choose each tool:

Everything you just read is two commands away

Install Herd, point your tools at one endpoint, and let the fleet sort itself out.