Model Behavior & Costs
Temperature, reasoning effort, caching, rate limits, spend tracking
Choosing a provider gets you connected; tuning model behavior is how you get the right output at the right price. Nexgile Code reads each model’s capability flags and shows only the controls that model actually supports — temperature, reasoning effort, thinking budgets, verbosity — alongside universal cost machinery: prompt caching, per-profile rate limits, a live cost readout, and hard spending caps. All behavior settings live on the model’s configuration profile in Settings → Providers, so different profiles can carry different tuning.
Temperature
Section titled “Temperature”Check Use custom temperature to override the model’s default randomness. Lower values make output more deterministic; higher values make it more varied. For code edits, low temperatures reduce drive-by rewrites; leave the override off to use the model’s default.
Reasoning effort and thinking budgets
Section titled “Reasoning effort and thinking budgets”Reasoning models “think” before answering, and thinking tokens are billed as output. Two control styles exist, and the panel shows whichever the selected model supports:
- Effort levels — the Model Reasoning Effort dropdown offers, depending on the model: None, Minimal (Fastest), Low, Medium, High, Extra High, and Max. Examples: GPT-5.x models range None→Extra High; Claude Opus 4.8/4.7 use adaptive thinking steered by effort (up to Max, their default) and manage the token budget themselves; Gemini 3.x models take Low→High.
- Thinking budgets — hybrid models (Claude Sonnet 4.x, Claude Haiku 4.5, Gemini 2.5 family, and others) expose Max Thinking Tokens (with Max Tokens alongside): a hard cap on deliberation before the answer starts. Some models always reason and cannot be set to zero (Gemini 2.5 Pro,
:thinkingmodel variants).
Rule of thumb: high effort or generous budgets for architecture, debugging mysteries, and tricky algorithms; low/none for mechanical edits, renames, and boilerplate — reasoning you don’t need is latency and cost you still pay.
Verbosity
Section titled “Verbosity”Models that support it (notably the GPT-5.4/5.5 general line) get an Output Verbosity control — Low, Medium, or High. Low keeps answers terse, which suits agent work where the code diff is the real product; High produces fuller explanations for learning or review contexts.
Image input
Section titled “Image input”Models flagged with image support accept images in chat — paste a screenshot of a broken layout or an error dialog directly into the task. Most current frontier models support it; check the model’s capability line in the settings panel. For endpoints configured via OpenAI Compatible, you declare this capability yourself.
Prompt caching
Section titled “Prompt caching”Agent conversations resend a large, mostly stable prefix — system prompt, rules, history — on every request. Prompt caching lets the provider store that prefix and bill re-reads at a fraction of the normal input price (on Anthropic models, roughly a tenth: e.g. $0.30 instead of $3.00 per million tokens on Sonnet-class models). Over a long task the majority of input tokens become cache hits, which is often the single biggest cost lever available.
- Automatic for cache-capable models on Anthropic, OpenAI, Google Gemini, OpenRouter, and most other providers — nothing to configure.
- Amazon Bedrock: an explicit Enable prompt caching checkbox, on by default; disable it only if your account or region rejects cache fields.
- LiteLLM: an explicit Use prompt cache checkbox, off by default — opt in when your gateway fronts cache-capable models.
The task-header cost figure already includes cache writes and discounted cache reads.
Per-profile rate limiting
Section titled “Per-profile rate limiting”Each configuration profile has a Rate limit slider — the minimum number of seconds between API requests (rateLimitSeconds, default 0). Use it to stay under a provider’s requests-per-minute quota (free tiers especially), or to pace spend on pay-as-you-go accounts. Because it’s per profile, your throttled free-tier profile and your unthrottled production profile coexist cleanly.
Live cost in the task header
Section titled “Live cost in the task header”Every task shows its accumulated API cost in the task header, computed from real token usage (input, output, cache reads/writes) at the model’s configured prices. Expand the header for the token breakdown. Watching this number for a day teaches you more about your real cost profile than any pricing page — subscription-style providers (for example the ChatGPT Plus/Pro entry) and local models report $0 here.
Hard caps: Max Count and Max Cost
Section titled “Hard caps: Max Count and Max Cost”In the Auto-Approve settings you can set two per-task ceilings, both Unlimited by default:
- Max Count — the maximum number of API requests a task may make automatically (
allowedMaxRequests). - Max Cost — the maximum dollars a task may spend automatically (
allowedMaxCost).
When a running task hits either limit, Nexgile Code stops and asks whether to continue — the cap is a checkpoint for your attention, not a task kill. This is your safety net against runaway loops during long-running or highly autonomous sessions; a practical baseline is around $5 for normal tasks and ~$20 for large refactors. Details in Command Guardrails & Limits.
API request timeout
Section titled “API request timeout”The editor setting nexgile-code.apiRequestTimeout caps how long to wait for an API response — default 600 seconds, range 0–3600, where 0 disables the timeout. Raise it for local providers like Ollama and LM Studio that need more processing time on large prompts; lower it if you’d rather fail fast on a flaky network.
Picking settings per task type
Section titled “Picking settings per task type”| Task type | Suggested tuning |
|---|---|
| Precise code edits, renames, mechanical changes | Low/no reasoning effort, low temperature override, fast or mid-tier model |
| Architecture, design review, hard debugging | High/Max effort or a generous thinking budget on a frontier model |
| Bulk low-stakes work (docstrings, test scaffolds) | Cheap model profile + Max Cost cap + rate limit |
| Long autonomous sessions | Frontier model, caching-friendly provider, both caps set, checkpoints on |
| Context condensing | A dedicated cheap profile via API Configuration for Context Condensing — see Context Management |
Because profiles are switchable mid-conversation and pinnable per mode, “precise-and-cheap for Code, deep-and-expensive for Architect” is a one-time setup, not a per-task chore — see Providers Overview and Using Modes.