How to Build a Fully Autonomous Local Fleet-Maintenance Analysis Agent Using SmolAgents and the Qwen Model

In this tutorial, we walk through the process of building a fully autonomous fleet-analysis agent using SmolAgents and a local QWAN model. We generate telemetry data, load it through a custom tool, and let your agent reason, analyze, and visualize maintenance risks without any external API calls. At each stage of implementation, we see how the agent interprets structured logs, applies logical filters, detects anomalies and ultimately produces a clear visual alert for fleet managers. check it out full code here,

print("⏳ Installing libraries... (approx 30-60s)")
!pip install smolagents transformers accelerate bitsandbytes ddgs matplotlib pandas -q


import os
import pandas as pd
import matplotlib.pyplot as plt
from smolagents import CodeAgent, Tool, TransformersModel

We install all the necessary libraries and import the core modules we rely on to build our agent. We have installed SmallAgent, Transformer, and basic data-handling tools to process telemetry and run local models smoothly. At this stage, we prepare our environment and make sure everything loads correctly before proceeding. check it out full code here,

fleet_data = {
   "truck_id": ("T-101", "T-102", "T-103", "T-104", "T-105"),
   "driver": ("Ali", "Sara", "Mike", "Omar", "Jen"),
   "avg_speed_kmh": (65, 70, 62, 85, 60),
   "fuel_efficiency_kml": (3.2, 3.1, 3.3, 1.8, 3.4),
   "engine_temp_c": (85, 88, 86, 105, 84),
   "last_maintenance_days": (30, 45, 120, 200, 15)
}
df = pd.DataFrame(fleet_data)
df.to_csv("fleet_logs.csv", index=False)
print("✅ 'fleet_logs.csv' created.")

We create a dummy fleet dataset that our agent will later analyze. We create a small but realistic set of telemetry fields, convert it to a DataFrame, and save it as a CSV file. Here, we establish the main data sources that drive the agent’s logic and predictions. check it out full code here,

class FleetDataTool(Tool):
   name = "load_fleet_logs"
   description = "Loads vehicle telemetry logs from 'fleet_logs.csv'. Returns the data summary."
   inputs = {}
   output_type = "string"


   def forward(self):
       try:
           df = pd.read_csv("fleet_logs.csv")
           return f"Columns: {list(df.columns)}nData Sample:n{df.to_string()}"
       except Exception as e:
           return f"Error loading logs: {e}"

We define FleetDataTool, which acts as a bridge between the agent and the underlying telemetry file. We give the agent the ability to load and inspect a CSV file to understand its structure. This tool becomes the basis of every subsequent analysis performed by the model. check it out full code here,

print("⏳ Downloading & Loading Local Model (approx 60-90s)...")
model = TransformersModel(
   model_id="Qwen/Qwen2.5-Coder-1.5B-Instruct",
   device_map="auto",
   max_new_tokens=2048
)
print("✅ Model loaded on GPU.")


agent = CodeAgent(
   tools=(FleetDataTool()),
   model=model,
   add_base_tools=True
)


print("n🤖 Agent is analyzing fleet data... (Check the 'Agent' output below)n")


query = """
1. Load the fleet logs.
2. Find the truck with the worst fuel efficiency (lowest 'fuel_efficiency_kml').
3. For that truck, check if it is overdue for maintenance (threshold is 90 days).
4. Create a bar chart comparing the 'fuel_efficiency_kml' of ALL trucks.
5. Highlight the worst truck in RED and others in GRAY on the chart.
6. Save the chart as 'maintenance_alert.png'.
"""
response = agent.run(query)


print(f"n📝 FINAL REPORT: {response}")

We load the Qwen2.5 local model and initialize our CodeAgent with the custom tools. We then create a detailed query that outlines the logical steps we want the agent to follow and execute it from start to finish. This is where we see the agent thinking, analyzing, calculating and even plotting with complete autonomy. check it out full code here,

if os.path.exists("maintenance_alert.png"):
   print("n📊 Displaying Generated Chart:")
   img = plt.imread("maintenance_alert.png")
   plt.figure(figsize=(10, 5))
   plt.imshow(img)
   plt.axis('off')
   plt.show()
else:
   print("⚠️ No chart image found. Check the agent logs above.")

We check whether the agent has successfully saved the generated maintenance chart and display it if available. We visualize the output directly in the notebook, allowing us to confirm that the agent performed data analysis and plotting correctly. This gives us a clean, interpretable result from the entire workflow.

Ultimately, we built an intelligent end-to-end pipeline that enables a local model to autonomously load data, evaluate fleet health, identify the highest-risk vehicle, and generate a diagnostic chart for actionable insights. We look at how easily we can extend this framework to real-world datasets, integrate more complex devices, or add multi-step reasoning capabilities for safety, efficiency, or predictive maintenance use cases. Finally, we appreciate how SmolAgents empowers us to build practical agent systems that execute real code, reason on real telemetry and provide insights instantly.

check it out full code hereAlso, feel free to follow us Twitter And don’t forget to join us 100k+ ml subreddit and subscribe our newsletterwait! Are you on Telegram? Now you can also connect with us on Telegram.