AI Agent for Auto Service Scheduling: Appointment Booking and Service Recommendations

Automating the Service Advisor Role

Auto service shops depend on service advisors who greet customers, look up their vehicle history, recommend services, provide price quotes, and book appointments. This role requires deep knowledge of manufacturer maintenance schedules and the ability to juggle a busy calendar. An AI agent can handle the entire intake workflow, letting human advisors focus on complex diagnostics and customer relationships.

The agent we build will decode VINs to identify vehicles, check service histories, recommend overdue maintenance, quote prices from a service catalog, and book available appointment slots.

VIN Decoding and Vehicle Identification

A Vehicle Identification Number (VIN) encodes the make, model, year, engine type, and manufacturing plant. Here is a simplified decoder:

from dataclasses import dataclass
from typing import Optional

@dataclass
class VehicleInfo:
    vin: str
    year: int
    make: str
    model: str
    engine: str
    transmission: str

VIN_DATABASE = {
    "1HGCG5655WA027834": VehicleInfo(
        "1HGCG5655WA027834", 2023, "Honda", "Accord", "1.5L Turbo", "CVT"
    ),
    "5YJSA1E26MF384721": VehicleInfo(
        "5YJSA1E26MF384721", 2025, "Tesla", "Model 3", "Electric", "Single Speed"
    ),
    "2T1BURHE0KC246810": VehicleInfo(
        "2T1BURHE0KC246810", 2024, "Toyota", "Camry", "2.5L I4", "8-Speed Auto"
    ),
}

In production, you would call the NHTSA VIN Decoder API or a commercial service like DataOne for comprehensive vehicle data.

Service Catalog and Pricing

Define your service offerings with pricing that varies by vehicle type:

from agents import function_tool

@dataclass
class ServiceItem:
    service_id: str
    name: str
    description: str
    base_price: float
    duration_minutes: int
    mileage_interval: int

SERVICE_CATALOG = [
    ServiceItem("SVC-001", "Oil Change - Synthetic", "Full synthetic oil and filter",
                79.99, 30, 7500),
    ServiceItem("SVC-002", "Tire Rotation", "Rotate and balance all four tires",
                49.99, 30, 7500),
    ServiceItem("SVC-003", "Brake Inspection", "Full brake pad and rotor check",
                39.99, 45, 25000),
    ServiceItem("SVC-004", "Transmission Fluid", "Drain and fill transmission fluid",
                189.99, 60, 60000),
    ServiceItem("SVC-005", "Coolant Flush", "Complete cooling system flush and refill",
                129.99, 45, 50000),
    ServiceItem("SVC-006", "Air Filter Replacement", "Engine and cabin air filters",
                59.99, 15, 30000),
]

@function_tool
def lookup_vehicle(vin: str) -> str:
    """Look up vehicle details by VIN number."""
    vehicle = VIN_DATABASE.get(vin.upper())
    if not vehicle:
        return f"VIN {vin} not found. Please verify and try again."
    return (
        f"Vehicle: {vehicle.year} {vehicle.make} {vehicle.model}\n"
        f"Engine: {vehicle.engine}\n"
        f"Transmission: {vehicle.transmission}"
    )

Service History and Recommendations

The recommendation engine compares current mileage against service intervals and last-performed dates:

from datetime import date

SERVICE_HISTORY = {
    "1HGCG5655WA027834": [
        {"service_id": "SVC-001", "date": "2025-09-15", "mileage": 30000},
        {"service_id": "SVC-002", "date": "2025-09-15", "mileage": 30000},
        {"service_id": "SVC-006", "date": "2025-03-10", "mileage": 22000},
    ],
}

@function_tool
def get_service_recommendations(vin: str, current_mileage: int) -> str:
    """Get recommended services based on VIN, mileage, and service history."""
    vehicle = VIN_DATABASE.get(vin.upper())
    if not vehicle:
        return "Vehicle not found."

    history = SERVICE_HISTORY.get(vin.upper(), [])
    recommendations = []

    for service in SERVICE_CATALOG:
        last_record = next(
            (h for h in reversed(history) if h["service_id"] == service.service_id),
            None,
        )

        if last_record:
            miles_since = current_mileage - last_record["mileage"]
            if miles_since >= service.mileage_interval:
                recommendations.append(
                    f"OVERDUE: {service.name} (last done at "
                    f"{last_record['mileage']} mi, {miles_since} mi ago) "
                    f"- ${service.base_price}"
                )
        else:
            if current_mileage >= service.mileage_interval:
                recommendations.append(
                    f"RECOMMENDED: {service.name} (never performed, "
                    f"due at {service.mileage_interval} mi) - ${service.base_price}"
                )

    if not recommendations:
        return "All services are up to date for this vehicle."

    total = sum(
        s.base_price for s in SERVICE_CATALOG
        if any(s.name in r for r in recommendations)
    )
    recommendations.append(f"\nEstimated Total: ${total:,.2f}")
    return "\n".join(recommendations)

Appointment Booking Tool

AVAILABLE_SLOTS = {
    "2026-03-18": ["08:00", "08:30", "09:00", "10:30", "13:00", "14:00", "15:30"],
    "2026-03-19": ["08:00", "09:30", "11:00", "13:00", "14:30"],
    "2026-03-20": ["08:30", "10:00", "11:00", "13:30", "15:00"],
}

@function_tool
def book_service_appointment(
    vin: str,
    customer_name: str,
    preferred_date: str,
    preferred_time: str,
    services: list[str],
) -> str:
    """Book a service appointment for a vehicle."""
    if preferred_date not in AVAILABLE_SLOTS:
        available_dates = ", ".join(AVAILABLE_SLOTS.keys())
        return f"No availability on {preferred_date}. Available dates: {available_dates}"

    if preferred_time not in AVAILABLE_SLOTS[preferred_date]:
        slots = ", ".join(AVAILABLE_SLOTS[preferred_date])
        return f"Time {preferred_time} not available. Open slots: {slots}"

    AVAILABLE_SLOTS[preferred_date].remove(preferred_time)

    total_minutes = sum(
        s.duration_minutes for s in SERVICE_CATALOG if s.service_id in services
    )
    return (
        f"Appointment confirmed:\n"
        f"Customer: {customer_name}\n"
        f"Vehicle: {vin}\n"
        f"Date/Time: {preferred_date} at {preferred_time}\n"
        f"Services: {', '.join(services)}\n"
        f"Estimated Duration: {total_minutes} minutes\n"
        f"Please arrive 10 minutes early."
    )

Assembling the Service Agent

from agents import Agent, Runner

service_agent = Agent(
    name="Service Advisor",
    instructions="""You are an auto service scheduling assistant. Help customers:
    1. Look up their vehicle by VIN
    2. Review service history and get recommendations
    3. Get price quotes for recommended services
    4. Book appointments at available times
    Always explain why each service is recommended and be transparent about pricing.""",
    tools=[lookup_vehicle, get_service_recommendations, book_service_appointment],
)

result = Runner.run_sync(
    service_agent,
    "My VIN is 1HGCG5655WA027834 and I have 38,000 miles. What do I need done?"
)
print(result.final_output)

FAQ

How do I get accurate manufacturer maintenance schedules?

Use the NHTSA or manufacturer OEM APIs to pull official maintenance schedules by VIN. Companies like Carfax and AutoData also sell maintenance schedule APIs. Map each manufacturer interval to your service catalog items so the agent can recommend exact services.

Can the agent handle warranty-covered services?

Yes. Add a warranty check tool that verifies whether the vehicle is still under factory or extended warranty. If a recommended service is warranty-covered, the agent should note that and direct the customer to an authorized dealer if your shop is independent.

How do I handle customers who need immediate service (walk-ins)?

Add a real-time availability tool that checks the current shop bay status. If a bay is open and a technician is available, the agent can offer a same-day walk-in slot. Otherwise, it suggests the earliest available appointment and offers to add the customer to a cancellation waitlist.

---

#AutoService #AppointmentScheduling #VINLookup #MaintenanceAI #Python #AgenticAI #LearnAI #AIEngineering