If you search for “LLM parameter optimization,” you’ll find guides on tuning learning rates, batch sizes, and layer configurations. But these hyperparameters for training foundation models from scratch are irrelevant if you’re building agents with one of the foundation models.
You can’t modify GPT-4’s architecture or Claude’s training schedule. Those decisions were made by model providers, and the weights are frozen. What you can optimize are the parameters controlling how your selected model generates responses at inference time, such as temperature, top_p and frequency_penalty. You can test these inference parameters in minutes instead of the days it takes training hyperparameters.
The Foundation Model Optimization Trap
When you focus your parameter optimization on training foundation models, you choose an expensive, infrastructure-intensive process of building models from scratch or fine-tuning massive checkpoints. These training hyperparameters control how billions of weights get optimized during pre-training. They require GPU clusters, days of computation, and deep expertise in model training dynamics.
For teams building production agents with pre-trained models, this optimization paradigm is irrelevant. You’re consuming models through APIs, not training them. The architectural decisions are frozen. The weights are fixed.
This frees you up to control the inference parameters, which are the settings that affect the generation behavior every time you make an API call. These parameters determine whether your model produces focused, deterministic outputs or creative, diverse responses. They control verbosity, repetition and coherence. Unlike training hyperparameters, you can instantly test inference parameters.
And many teams building agents never explore the advantage they can gain by systematically optimizing these parameters. Too often, they stick with defaults and focus exclusively on instruction or prompt engineering, missing out on parameter optimization entirely.
Critical Prerequisites for Refining Your Agent
Without clear LLM evaluation metrics, parameter optimization is just expensive guessing.
When you have the right foundation, parameter optimization delivers value.
Clarify what you want to measure. The metric should reflect production requirements and guide the optimization algorithm toward better configurations. For classification, check the accuracy. For structured output quality, use exact match. For question-answering, determine the semantic similarity.
Then build representative datasets. You need hundreds of examples covering the distribution of queries your agent handles in production, which must include common cases, edge cases and failure modes. Consider optimizing 20 hand-picked examples to produce configurations that overfit. Split that data into training, validation, and test sets and validate your data for optimization.
Because parameter optimization amplifies what your instructions already do, ensure your instructions are clear and complete. If your task definition is unclear, tuning temperature won’t fix underlying problems. A well-defined baseline makes it possible to isolate parameter effects from instruction quality.
Validate your data. Use the optimizer to find parameters that maximize performance on your validation set. Before deploying, test each parameter on separate data to confirm they generalize. A proper train-validation-test split catches overfitting before it affects production.
Make sure that your agent architecture is implemented well. Tune inference parameters to address specific bottlenecks. Even with the best parameter optimization, you can’t address the underlying issues.
Beyond the Baseline: Optimizing Agent Parameters
Once you have a solid foundation for your agent in place, you can tune agent parameters with the Opik Parameter Optimizer (docs here). Each parameter influences your AI agents performance.
The benefits compound across components. Production agents combine query analysis, tool selection, response generation, and quality checking. Each component can be optimized independently with task-appropriate parameters. You can gain accuracy, improve question-answering systems, or reduce costs based on the parameters you optimize
Temperature
Temperature controls randomness in token selection by modifying the softmax probability distribution. Lower values make the model deterministic, consistently selecting the highest probability token. Higher values increase randomness by giving less probable tokens more weight. While you can set your temperature as high as 2.0, most applications use 0.0 to 1.5.
For factual question-answering or classification, temperatures between 0.1 and 0.3 usually perform best. This model sticks to confident predictions, reducing hallucinations and improving consistency. For balanced tasks like technical documentation, 0.4 to 0.7 works well. And in creative writing, consider a temperature of 0.8 to 1.2 for more diverse outputs.
Top_p
Nucleus sampling establishes a probability threshold and only considers tokens whose cumulative probability exceeds it. If top_p is 0.9, the model samples from the smallest set of tokens whose probabilities sum to at least 90 percent. This filters out low-probability options while preserving diversity among likely choices.
Low top_p values between 0.1 and 0.3 restrict the model to confident predictions. Values from 0.8 to 0.95 allow variation while maintaining coherence. For most tasks, optimize either temperature or top_p, but not both, because the parameters affect sampling in overlapping ways.
Frequency_penalty and presence_penalty
Frequency_penalty and presence_penalty discourage repetition. Frequency_penalty scales with how often a token appears. If there are more repetitions, there are stronger penalties. Presence_penalty applies a fixed penalty after a token’s first occurrence, regardless of how many times it appears. Values range from 0.0 to 1.0 for practical applications.
For agents generating longer outputs like reports or summaries, penalties between 0.3 and 0.5 prevent the model from getting stuck in loops or repeating the same phrasing. Agents producing structured data like JSON might need lower values because legitimate keyword repetition is expected in formatted outputs.
Max_tokens
The max_tokens parameter sets the ceiling for response length, controlling verbosity and managing API costs. Classification responses need 10 to 50 tokens. Short-form answers work with 100 to 200. Long-form generation might require 1,000 to 4,000. Setting appropriate limits prevents rambling while ensuring sufficient space for complete responses.
N_threads
N_threads empower you to run multiple evaluations concurrently while respecting API rate limits. This is especially powerful when you are refining multi-task agents. You can run separate optimization experiments for each capability to figure out where you can rapidly improve your agent capabilities.
Model
You can select your model to optimize as a categorical parameter. If you’re deciding between GPT-4, Claude, or Gemini for specific tasks, the Parameter Optimizer tests which model performs best with optimized parameters for each. Different models exhibit different behaviors even at identical parameter settings, and the optimal choice depends on your evaluation criteria.
Finding Your Optimal Settings with Bayesian Optimization
The Parameter Optimizer uses Bayesian optimization through Optuna to search the parameter space efficiently.
Define which parameters to optimize and their valid ranges. Then use the optimizer to evaluate configurations against your dataset using your chosen metric. After initial random sampling—typically 10 to 20 trials—Bayesian optimization builds a probabilistic model predicting how parameter combinations affect performance.
The algorithm balances exploration and exploitation, testing diverse configurations to understand the parameter landscape, and then it focuses on the most promising regions for fine-grained optimization. Where grid search would require thousands of evaluations, Bayesian optimization can converge in as few as 50 trials.
The optimizer calculates parameter importance, revealing which settings drove performance variance. You might discover temperature contributed 70 percent of improvement while frequency_penalty added only 5 percent. Based on which parameters matter, you can continue to refine your optimization strategy.
Two-phase optimization improves results through global search followed by optional local refinement. The global phase explores the full parameter space. You can then refine your results in your local phase with fine-grained optimization around the most impactful parameters for your agent task.
Integrating Optimized Parameters into Your Workflow
You can get started by optimizing and test just a few parameters:
- Pick temperature or top_p for the highest impact.
- Build a 200-example validation set representing production distribution.
- Run 50 trials with the Parameter Optimizer.
This process should generate near-optimal settings pretty efficiently.
To optimize these parameters further, return to baseline. Review your metrics to see what improvements you made. Tweak your parameters again.
Test your agent with default parameters and then the optimized parameters. Compare the performance against your baseline to see if you are achieving meaningful gains. Verify that optimized settings don’t create new failure modes.
Monitor. Re-optimize. Rinse. Repeat. Track the same metrics in production. Watch for any shift in your distribution. As your application evolves, re-optimize periodically to ensure you are achieving the best results.
Combining Parameter Optimization With Eval-Driven Development
Parameter optimization on its own won’t fix bad task definitions, flawed architectures, or inadequate data. But when you have solid foundations, systematic parameter tuning extracts additional performance without retraining models or adding infrastructure.
This process pairs well with an eval-driven development workflow where logging, scoring, and automatic prompt optimization cycles help you test and monitor new AI features. Each step in this end-to-end workflow matters because the nondeterministic nature of LLM outputs makes traditional unit testing impossible. With enough testing and production data logged and scored, you can iterate on your AI app and gain confidence that it’s performing to end-user expectations at scale.
Opik makes this easy with LLM tracing, scoring and annotation, LLM-as-a-judge evaluation metrics, and more. The free open-source version and the free cloud version both include the full LLM observability and evaluation featureset, plus automated parameter optimization. Sign up here to start optimizing your AI applications and agents today.
