LLM providers

Nitpick has a pluggable provider abstraction. Every provider implements the same Provider interface — you don’t rewrite your skill or config to switch. In v2.0+, all three providers also consume the MCP knowledge base, each via the surface that fits their architecture.

Supported providers

Provider	Setup	Default model	KB access
Anthropic	ANTHROPIC_API_KEY	claude-opus-4-6	In-process kb_* function calls
OpenAI	OPENAI_API_KEY	gpt-5.4	In-process kb_* function calls
Claude Code	claude CLI	claude-opus-4-6	stdio MCP config passed to subprocess

Configure

nitpick.yaml:

llm:
  provider: anthropic       # anthropic | openai | claude-code
  api_key_env: ANTHROPIC_API_KEY
  model: claude-opus-4-6    # optional override
  fast_model: claude-haiku-4-5  # used for scope inference + smoker
  temperature: 0
  max_iterations: 60
  use_mcp_kb: true          # enable KB tools for this provider

Switch providers by changing provider and the env var. No other changes needed.

What all providers support

• Parallel tool calls: the model can call multiple tools per turn
• Automatic retries: 429 / 5xx / network errors, exponential backoff, 5 attempts, jittered
• Usage tracking: input/output tokens in the result
• Structured JSON tool schemas: same schema works for all
• Health checks: nitpick providers verifies auth works before a run
• MCP KB tools (v2.0+): kb_list_pages, kb_get_page, kb_search, kb_list_open_bugs, kb_get_flow, kb_add_bug, kb_note_flaky, kb_put_resolved_question

What’s different per provider

Anthropic supports prompt caching. The skill’s system prompt (~15–20 k tokens) is cached via cache_control: { type: "ephemeral" }. Subsequent calls within the cache TTL pay ~10% of the input cost. For agent loops with 20+ iterations this is a ~70% cost reduction. KB tools arrive as standard function calls in the tool list.

OpenAI supports parallel tool calls natively — the model can emit multiple tool_calls[] in one response, and Nitpick executes them concurrently. Also supports OpenAI Skills (use_openai_skills: true + nitpick skill publish): uploads SKILL.md once; runs reference it by skill_id through the Responses API, saving ~15 KB of system prompt on every call. KB tools are added to the Responses API tool list alongside the skill.

Claude Code routes everything through the claude -p subprocess. KB access is different: instead of in-process function calls, Nitpick writes a temp mcp.json to os.tmpdir() and passes --mcp-config to the subprocess. Claude Code connects to nitpick mcp serve via stdio, giving it the same 8 KB tools through MCP rather than direct function calls. You lose some tool-call observability in the Nitpick logs (those calls happen inside Claude Code) but gain clean billing attribution.

OpenAI Skills config

llm:
  provider: openai
  api_key_env: OPENAI_API_KEY
  model: gpt-5.4
  fast_model: gpt-5.4-mini
  use_openai_skills: true
  skill_id: skill_69f453fc...    # from `nitpick skill publish`
  skill_version: "1"             # optional; defaults to latest
  use_mcp_kb: true

Claude Code config

llm:
  provider: claude-code
  model: claude-opus-4-6
  use_mcp_kb: true

mcp:
  kb:
    trust: read-write

Health check

nitpick providers

Available LLM providers:
  anthropic    Anthropic (direct API)          ✓ ready
  openai       OpenAI (direct API)             ✓ ready
  claude-code  Claude Code CLI (subprocess)    ✗ claude CLI not found

One green check is all you need.

Cost comparison

See Cost management for per-scenario estimates. Rough benchmarks on a 15-page full run:

Provider	Model	Est. cost
Anthropic	Opus + prompt caching	~$30–50
Anthropic	Sonnet + prompt caching	~$8–12
OpenAI	gpt-5.4 + Skills	~$15–25
OpenAI	gpt-5.4-mini + Skills	~$3–6

Crawler and smoker are LLM-free. KB tool calls add negligible token cost.