TigerStrike is bring-your-own-model (BYOM) — you provide the LLM API key, TigerGate does the orchestration. The provider key is configured once per org in the dashboard and lives on TigerGate’s side; the worker host never sees it.

​
Why BYOM

  • Cost transparency — you see the LLM bill directly from the provider, not marked up.
  • Compliance — many enterprises already have data-processing agreements with OpenAI / Anthropic / Azure. Routing through your key honours those agreements.
  • Model choice — pick the model that fits your budget. A reasoning-heavy scan benefits from o1/claude-opus; a quick crawl runs fine on gpt-4o-mini.

​
Supported providers

ProviderRecommended modelsNotes
OpenAIgpt-4o, gpt-4o-mini, o1, o1-mini, gpt-4-turboDefault. Fastest path.
Anthropicclaude-opus-4-7, claude-sonnet-4-6, claude-haiku-4-5Best for reasoning-heavy scans.
Google Geminigemini-1.5-pro, gemini-1.5-flashCheapest at scale; smaller context window.
Azure OpenAIWhatever your Azure deployment exposesSupply deployment name, endpoint, API key.
OpenAI-compatible (self-hosted)LiteLLM, vLLM, Ollama with the OpenAI shim, etc.Set base URL; we use the OpenAI SDK.

​
Configure a provider

1

Open Pentest → Settings → AI Providers

Click Add provider.
2

Pick the provider

The form changes per provider — Azure asks for endpoint + deployment name, self-hosted asks for base URL, the others just want the key.
3

Paste the key + click Test

TigerGate makes a tiny live call (typically a 1-token completion) against the model. If it succeeds you’ll see the model name + cost echoed back; if it fails you get the upstream error string (“invalid key”, “model not found”, “quota exceeded”).
4

Pick default models

Each scan picks one of three roles (reasoning, tool-use, cheap). Map each role to a specific model in the provider’s catalogue. Reasonable defaults are pre-filled per provider; tune if you want to spend less.

​
Per-scan overrides

The defaults you set in Settings → AI Providers apply to every scan, but each scan can override:
  • Reasoning model — used for plan / replan / triage.
  • Tool-use model — used for the agent loop (most calls).
  • Cheap model — used for boilerplate (summarising a response, classifying a status code).
For a fast, cheap pass: set all three to a small model. For a thorough one: reasoning = o1, tool-use = gpt-4o, cheap = gpt-4o-mini.

​
OpenAI

Base URL: https://api.openai.com/v1   (default)
Auth:     Bearer <your-key>
Recommended models:
RoleModel
Reasoningo1 (slow but deep) or gpt-4o (faster, good enough for most)
Tool-usegpt-4o
Cheapgpt-4o-mini

​
Anthropic

Base URL: https://api.anthropic.com/v1   (default)
Auth:     x-api-key header
Recommended models:
RoleModel
Reasoningclaude-opus-4-7
Tool-useclaude-sonnet-4-6
Cheapclaude-haiku-4-5
For thinking-heavy reasoning steps, opt-in to extended thinking under the per-provider config.

​
Google Gemini

Base URL: https://generativelanguage.googleapis.com/v1beta   (default)
Auth:     query-string ?key=...
Recommended models:
RoleModel
Reasoninggemini-1.5-pro
Tool-usegemini-1.5-pro
Cheapgemini-1.5-flash
Smaller context window than OpenAI / Anthropic — for very large codebases the agents may have to chunk more aggressively.

​
Azure OpenAI

Endpoint:  https://<your-resource>.openai.azure.com/
Deploy:    <deployment-name>   (you set in Azure Portal)
API ver:   2024-08-01-preview  (or newer)
Auth:      api-key header
You’ll set up one deployment per model in Azure (gpt-4o, gpt-4o-mini, o1). Map each deployment name into the role slots in the dashboard.

​
OpenAI-compatible / self-hosted

Anything that speaks the OpenAI Chat Completions API works:
  • vLLM with the OpenAI-compatible server
  • LiteLLM proxy in front of any model
  • Ollama with the --openai shim
  • Internal LLM platforms with an OpenAI-style facade
Base URL: https://your-llm.internal.example.com/v1
Auth:     Bearer <whatever-token-your-proxy-needs>   (optional)
For self-hosted endpoints with non-standard model names, just type the model name into the role slots — TigerGate doesn’t validate against a known catalogue.

​
How the key reaches the agent

1. You configure the provider key in the dashboard.
2. TigerGate stores it AES-256-CBC encrypted at rest in Postgres.
3. When a scan job is published to NATS, the platform decrypts the
   key and embeds it into the job payload (scoped to that one scan).
4. The worker pulls the job, sees the key, passes it to its sandbox
   containers as an env var, and the agents call the provider.
5. When the scan ends, the sandbox is torn down and the env var
   is gone with it. The worker host's filesystem never touches the key.
The key is scoped per-scan — a stolen worker token can’t enumerate the org’s saved provider key from the platform; it can only see keys for jobs it has actively claimed.

​
Spend tracking

Every LLM call’s prompt + completion token count + per-million pricing is recorded. The dashboard’s Pentest → Spend page shows a per-scan breakdown — useful for:
  • Seeing which scans burn the most (often: full-scope on a deep web app).
  • Budgeting next month’s quota.
  • Catching agent loops that waste tokens (a runaway scan flags as budget_exhausted before it hurts).
See Budgets & spend for the cap mechanics.