# Choosing a model

Pentest Swarm AI supplies the tools and coordination; your model supplies the
reasoning. A model family (such as Claude or DeepSeek) is distinct from the
provider or server hosting it. The same model can have different costs, privacy
conditions, and restrictions depending on where it runs.

The comparisons below are qualitative guidance, not measured rankings. Quality,
expense, and offensive-prompt refusal depend on the exact model, hosting service,
and task. Every choice must support **native tool/function calling** through its
serving API; a compatible chat endpoint alone is not enough.

## Comparison matrix

| Choice | Quality | Cost | Privacy | Offensive-prompt refusal | Setup effort | Best for |
|--------|---------|------|---------|--------------------------|--------------|----------|
| Claude (Anthropic) | Project's quality-oriented default; results depend on task and model | Paid API usage; budget depends on model and run length | Prompts and tool results sent to Anthropic | May refuse security tasks, including authorised ones | Low: `claude` plus API key | Easy start and quality-oriented reasoning |
| OpenAI-compatible services: OpenAI, Together AI, DeepSeek, Groq | Broad model selection; evaluate the chosen model's reasoning and tool use | Model-dependent API charges; lower-cost options can suit iteration | Prompts and tool results sent to the selected host | Depends on model and host policy; open weights do not imply no refusals | Low for `together`; `openai` needs a key and vendor endpoint for other hosts | Hosted model choice and cost-conscious iteration |
| OrcaRouter | Depends on the selected backend model | Gateway and backend pricing determine expense | Gateway and backend handling both matter | Backend model and gateway restrictions apply | Low: `orcarouter`, key, and a tool-capable model | Access to multiple model families through one gateway |
| Gemini (Google) | Evaluate the selected model for reasoning, context needs, and tool use | Model- and tier-dependent API cost | Prompts and tool results sent to Google | Model and service restrictions apply | Low: `gemini` plus API key | Google-hosted inference and context-heavy tasks |
| Local Ollama / LM Studio | Depends on model, quantisation, and available hardware; not inherently lower quality | No local API bill; hardware, memory, and energy still cost resources | Inference stays local only with local endpoints and local agent overrides | Depends on the loaded model; local hosting does not remove refusals | Moderate: download a suitable model and run its server | Control over inference data and repeated local experiments |
| Security-tuned open models, such as Pentest-R1 | Specialised tuning may help; validate task performance and tool use | Local resource costs or the chosen host's API charges | Determined by hosting, not security tuning | Tuning may change refusal tendencies; no zero-refusal guarantee | Higher: find compatible weights, serving API, and native tool support | Bring-your-own-model evaluation for security workflows |

## Configuration notes

- **Cloud keys and endpoints:** `claude`, `openai`, `together`, `gemini`, and
  `orcarouter` require an API key. Together AI has its own `together` alias with
  a default endpoint of `https://api.together.xyz/v1`. For DeepSeek or Groq, use
  `openai` with the vendor's base URL in `orchestrator.endpoint`, its key, and a
  tool-capable model available from that host.
- **Other compatible aliases:** OpenRouter (`openrouter`) is separate from
  OrcaRouter (`orcarouter`). Their default endpoints are
  `https://openrouter.ai/api/v1` and `https://api.orcarouter.ai/v1`, respectively.
  Muse Spark uses `musespark` (or `meta`) with a default endpoint of
  `https://api.meta.ai/v1`. These aliases also require keys. Gateway access does
  not guarantee tool support for every model; select a tool-capable model
  explicitly rather than relying on an unspecified automatic route.
- **Local servers:** `ollama` defaults to `http://localhost:11434`; `lmstudio`
  defaults to `http://localhost:1234`. Neither requires an API key in the
  factory, but both need a running server with a suitable model loaded. Hardware
  requirements depend on the model, quantisation, and context size.
- **Privacy boundaries:** Pointing a local-provider configuration at a remote
  endpoint sends inference data there. Agents inherit the orchestrator's settings
  by default, but can override provider, endpoint, model, and key. Check every
  override before treating inference as local. Local inference does not suppress
  the scan's network traffic to targets. For cloud inference, review the host's
  data handling terms for the prompts and tool results you send.
- **Pentest-R1 is a model example, not a provider identifier or a verified
  dedicated integration.** Use it only if its serving stack supports a compatible
  provider API and native tool/function calling. Security tuning alone does not
  establish compatibility.

See [provider setup](../website/docs/providers.md) for configuration examples and
[configuration](../website/docs/configuration.md) for per-agent overrides. The
[provider factory](../internal/llm/factory.go) defines the aliases, key checks,
and default endpoints summarised here.

## Recommendation

For an **easy start with quality as the priority**, use the project's Claude
default and supply an API key. For **inexpensive iteration**, evaluate a lower-cost,
tool-capable hosted model through Together AI or another OpenAI-compatible service;
compare actual run cost and useful results for your workload. For **local inference
privacy**, use Ollama or LM Studio with a model your hardware can run, keep all
inference endpoints and agent overrides local, and validate tool calling before
starting a larger scan.