In this article, you will learn how to fine-tune an agentic AI system holistically, covering all four critical dials: training data, parameter-efficient fine-tuning, runtime hyperparameters, and preference alignment. Topics we will cover include: How to build and validate a well-formatted tool-calling fine-tuning dataset that prevents hallucinated function calls before training ever begins. How to configure and apply QLoRA for parameter-efficient fine-tuning, and how to tune inference-time hyperparameters such as temperature and retry policy with the same rigor as training hyperparameters. How to use Direct Preference Optimization (DPO) to teach judgment calls that supervised fine-tuning alone cannot express, and how to evaluate the result with a verdict-driven framework that catches catastrophic forgetting before it ships. Agentic AI fine-tuning, tool calling, LoRA, QLoRA, DPO, and agent hyperparameters all show up in the same search results because they are all part of the same underlying problem, and most guides only cover one piece of it. Fine-tune the base model well and ship it with the wrong runtime temperature, and it will still fail in production. Get the temperature right but train on a badly formatted tool-calling dataset, and it will still hallucinate function names. This article treats agentic AI fine-tuning as what it actually is: a system with four separate dials — training data, parameter-efficient fine-tuning, runtime hyperparameters, and preference alignment — and walks through tuning all four together rather than one in isolation. One example runs through the whole guide: a support-ticket triage agent being fine-tuned to reliably call three internal tools, lookup_order, issue_refund, and escalate_to_human, rather than answering from a general instinct about what sounds right. Prerequisites: Python 3.10+ pip install peft transformers datasets accelerate for the training-side examples (a real training run additionally needs bitsandbytes and a CUDA GPU, called out specifically where it matters below); no special hardware is needed for the dataset, hyperparameter, and evaluation examples, which run anywhere Why “Fine-Tuning an Agent” Means More Than Fine-Tuning a Model Before touching any of the four levers, it is worth being clear about when fine-tuning is even the right tool. Frontier base models are already excellent general instruction-followers, and what fine-tuning actually fixes in 2026 comes down to three things: exact output schema, narrow domain vocabulary, and consistent behavior that a prompt alone cannot reliably pin down. What it does not fix is missing knowledge; if your agent needs facts that did not exist at training time, that is a retrieval problem, not a fine-tuning problem, and no amount of training will make a model reliably know something it was never shown. Once fine-tuning is the right call, “fine-tuning the agent” splits into four genuinely separate problems, and skipping any one of them is a common way these projects underperform: The training data: does it teach the actual behavior you need, in the format the model will see at inference time? Parameter-efficient training: how you actually update the weights without needing a datacenter. Runtime hyperparameters: temperature, iteration limits, retry policy — all decided after training, at inference time, and just as capable of breaking a well-trained model as a bad training run. Preference alignment: teaching judgment calls that a single “correct” training label cannot express. The rest of this article covers all four, in order, against the same triage-agent example. Building the Tool-Calling Fine-Tuning Dataset Format matters more than volume for this specific kind of fine-tuning. A base model can already write fluent English about refund policy; what it does not reliably do is emit a syntactically exact tool call with the right argument names every time, and that is a formatting problem that a few hundred well-structured examples can fix far more reliably than a few thousand loosely formatted ones. # dataset.py import json TOOLS_SCHEMA = [ { “name”: “lookup_order”, “description”: “Retrieves order details by order ID.”, “parameters”: {“type”: “object”, “properties”: {“order_id”: {“type”: “string”}}, “required”: [“order_id”]}, }, { “name”: “issue_refund”, “description”: “Issues a refund for an order. Only call this after confirming eligibility.”, “parameters”: { “type”: “object”, “properties”: {“order_id”: {“type”: “string”}, “amount”: {“type”: “number”}}, “required”: [“order_id”, “amount”], }, }, { “name”: “escalate_to_human”, “description”: “Hands the ticket to a human agent. Use for anything ambiguous, high-value, or policy-adjacent.”, “parameters”: {“type”: “object”, “properties”: {“reason”: {“type”: “string”}}, “required”: [“reason”]}, }, ] def make_example(user_message: str, tool_name: str, tool_args: dict) -> dict: return { “messages”: [ {“role”: “system”, “content”: “You are a support triage agent with access to tools.”}, {“role”: “user”, “content”: user_message}, { “role”: “assistant”, “content”: None, “tool_calls”: [{“type”: “function”, “function”: {“name”: tool_name, “arguments”: json.dumps(tool_args)}}], }, ] } def validate_examples(examples: list[dict]) -> list[str]: “””Schema validation, before training starts, not after a wasted run.””” valid_tool_names = {t[“name”] for t in TOOLS_SCHEMA} tools_by_name = {t[“name”]: t for t in TOOLS_SCHEMA} errors = [] for i, example in enumerate(examples): for message in example[“messages”]: if message[“role”] != “assistant” or “tool_calls” not in message: continue for call in message[“tool_calls”]: name = call[“function”][“name”] if name not in valid_tool_names: errors.append(f”Example {i}: unknown tool ‘{name}’”) continue required = set(tools_by_name[name][“parameters”].get(“required”, [])) provided = set(json.loads(call[“function”][“arguments”]).keys()) missing = required – provided if missing: errors.append(f”Example {i}: tool ‘{name}’ missing required args {missing}”) return errors 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 # dataset.py import json   TOOLS_SCHEMA = [     {         “name”: “lookup_order”,         “description”: “Retrieves order details by order ID.”,         “parameters”: {“type”: “object”, “properties”: {“order_id”: {“type”: “string”}}, “required”: [“order_id”]},     },     {         “name”: “issue_refund”,         “description”: “Issues a refund for an order. Only call this after confirming eligibility.”,         “parameters”: {             “type”: “object”,             “properties”: {“order_id”: {“type”: “string”}, “amount”: {“type”: “number”}},             “required”: [“order_id”, “amount”],         },     },     {         “name”: “escalate_to_human”,         “description”: “Hands the ticket to a human agent. Use for anything ambiguous, high-value, or policy-adjacent.”,         “parameters”: {“type”: “object”, “properties”: {“reason”: {“type”: “string”}}, “required”: [“reason”]},     }, ]     def make_example(user_message: str,