The Auto Shop That Knows Your Car Better Than You Do

Mike's phone is ringing. He can hear it from under the 2017 Tahoe where he's replacing a CV axle. His hands are covered in grease. His two other mechanics are on lifts. His wife, Maria, is at the front counter, but she just stepped out to grab parts from the back.

The phone rings six times and goes to voicemail.

That was a brake job. Maybe $400. Maybe the caller tries back later, maybe they Google "brake shop near me" and end up at the chain place down the road. Mike will never know.

This happens 10 to 15 times a day. Mike's shop does great work. His regulars love him. But he loses thousands every month to calls that nobody picks up, and he can't afford a full-time receptionist.

There are roughly 280,000 independent auto repair shops in the United States. Strip malls, side streets, commercial parks. Most of them are 2-6 bay operations run by a mechanic who'd rather be under a car than on the phone. Almost none of them have solved this problem.

You're going to solve it for them. And charge $400 a month to do it.

What Mike actually needs

Before writing any code, go spend a morning at a shop like Mike's. Sit in the waiting area. Listen to the phone calls that do get answered.

You'll hear the same five conversations on repeat:

1. "How much for [service] on my [year] [make] [model]?"
2. "Do you have any openings this week?"
3. "My car is making a [noise]. What could that be?"
4. "I need to bring my car in for [service]. What time works?"
5. "Hey Mike, it's Carlos. I'm due for an oil change, right?"

The first two are straightforward. The shop has a service menu with pricing. They have a schedule with open slots. An AI agent can handle both of those right now.

The third one is trickier. Diagnostic questions need to be routed carefully. The agent shouldn't guess that a grinding noise is definitely the brakes when it could be a wheel bearing.

The fourth is a booking flow. Simple enough.

The fifth is where things get interesting. Carlos is a regular. He's been coming to Mike's shop for six years. His 2018 F-150 has 87,000 miles on it. Last oil change was in October. Tires rotated in January. Mike told him to think about a timing belt at the next visit. But all of that history is in Mike's head, or scribbled on a work order buried in a filing cabinet.

What if the agent already knew all of that?

Piece 1: The service catalog as a knowledge base

Every auto repair shop has pricing, even if it's on a whiteboard or a crumpled sheet in a drawer. Your first job is to turn that into structured data the agent can search.

The key insight: repair pricing varies by vehicle category, not by exact model. A brake job on a Honda Civic costs less than a brake job on a Ford F-250 because the parts are cheaper and the labor is faster. Most shops think in four buckets: economy cars, midsize/standard, SUVs and trucks, and luxury/European.

You sit down with Mike for 30 minutes and type out his service catalog as plain text. One entry per service, with pricing by vehicle category:

import { Chanl } from '@chanl/sdk'
 
const chanl = new Chanl({ apiKey: process.env.CHANL_API_KEY })
 
// Each service is a plain text entry in the knowledge base
await chanl.knowledge.create({
  name: "Front Brake Pad Replacement",
  source: "text",
  content: `Front Brake Pad Replacement
Replace front brake pads, inspect rotors, check brake fluid.
Economy vehicles (Civic, Corolla, Elantra): $220-280
Standard vehicles (Accord, Camry, Malibu): $260-320
Trucks and SUVs (F-150, Silverado, 4Runner): $300-380
Luxury/European (BMW, Mercedes, Audi): $380-520
Estimated time: 60-90 minutes depending on vehicle.
Note: If rotors need resurfacing, add $60-80. If rotors need replacement, add $120-200 per axle.`
})
 
await chanl.knowledge.create({
  name: "Oil Change - Conventional",
  source: "text",
  content: `Oil Change - Conventional
Drain and replace engine oil, replace oil filter, top off fluids, visual inspection.
Economy vehicles: $35-55
Standard vehicles: $45-65
Trucks and SUVs: $55-75
Luxury/European: $65-95
Estimated time: 30-45 minutes.
Note: Synthetic oil upgrade available. Add $25-40 depending on vehicle.`
})
 
// Repeat for each service: tire rotation, alignment, AC recharge,
// transmission flush, timing belt, etc. 20-30 entries total.

That's it. Plain text, no complex schemas. Upload each service as a separate knowledge base entry so the agent can search by service name and vehicle type.

Now when someone calls and asks "how much for brakes on my Civic?", the agent searches the knowledge base, matches "brakes" to "Front Brake Pad Replacement", classifies "Civic" as economy, and responds with "$220 to $280 for front brake pads on a Civic, depending on rotor condition."

That answer is better than what most receptionists give, because it includes the conditional. The caller knows that $280 isn't the ceiling if the rotors are shot. No surprise when they pick up the car.

Piece 2: Vehicle memory (this is the killer feature)

The knowledge base handles the "how much" question. But the question that separates a good shop from a great one is "what does my car need?"

Mike knows, for his top 50 customers, roughly what's been done to their cars. He remembers that he told Carlos about the timing belt. He remembers that Mrs. Patterson's Camry has a slow oil leak they've been monitoring. This knowledge is what keeps customers coming back. It's also trapped entirely in Mike's head.

Chanl's memory system makes this automatic. Here's the lifecycle:

Call starts: The agent searches for memories tied to the caller's phone number and injects them into the LLM context. If Carlos has called before, the agent already knows his vehicle, his history, and what Mike recommended last time. No lookup. No asking "what's your name?" It just knows.

During the call: The agent has a memory_add tool available via MCP. If Carlos mentions something new ("I just hit 90,000 miles" or "I think my brakes are squeaking"), the agent stores it in real-time. No waiting until the call ends.

Call ends: This is the magic. Chanl runs memory.extract() on the full transcript. An LLM reads the entire conversation and pulls out every relevant fact: vehicle info, service performed, recommendations made, customer preferences, follow-up items. These facts get saved automatically to the customer's memory profile.

// This happens automatically at the end of every call.
// You don't write this code — the platform does it.
// But here's what's happening under the hood:
 
const facts = await chanl.memory.extract({
  text: fullTranscriptText,
  entityType: 'customer',
  entityId: 'carlos-martinez-555-0147',
  save: true  // auto-saves extracted facts as memory entries
})
 
// Result: 4 facts extracted and saved
// - "Owns 2018 Ford F-150 XLT, 4WD, 5.0L V8"
// - "Oil change performed, synthetic. Mileage: 87,100"
// - "Timing belt replacement recommended — approaching 90k miles"
// - "Prefers Thursday morning appointments"

So the first time Carlos calls Mike's shop, the agent doesn't know him. It takes the appointment, answers his questions, books the service. Normal call. But at the end, fact extraction runs. Now Carlos has a memory profile.

The second time Carlos calls? The agent greets him differently:

"Hi Carlos. Looking at your F-150, you're about due for an oil change. Your last one was five months ago at 84,200 miles. Mike also recommended a timing belt replacement since you're coming up on 90,000 miles. Want to get both done? I have openings Thursday morning or Friday afternoon."

That's not a phone answering service. That's a service advisor who never forgets. Carlos doesn't have to explain what he needs because the agent already knows. Mike doesn't have to dig through a filing cabinet before the appointment.

You can also seed memory for existing customers. If Mike has 50 regulars with service history in a spreadsheet or shop management system, you can bulk-load their vehicle profiles before launch:

// One-time import for existing customers
await chanl.memory.create({
  entityType: 'customer',
  entityId: 'carlos-martinez-555-0147',
  content: '2018 Ford F-150 XLT, 4WD, 5.0L V8. Oct 2025: Oil change (synthetic), tire rotation, brake inspection at 84,200 miles. Brakes at 60% front, 70% rear. Timing belt recommended at next visit. Jan 2026: Tire rotation, alignment check at 86,500 miles. Prefers Thursday mornings.',
})

After that initial seed, the memory builds itself from every conversation. Every call makes the agent smarter about that customer. By month three, Mike's agent knows his top 50 customers better than he does.

This is the feature that makes shop owners' eyes go wide. Every independent shop is competing against dealerships that have fancy CRM systems tracking service intervals. This gives them the same capability for $400 a month.

Piece 3: Appointment booking

Now the agent needs to actually book that Thursday morning slot. This means connecting to whatever scheduling system the shop uses. Many small shops use Google Calendar, some use shop management software like Mitchell or ShopWare, and plenty still use a paper book.

For the paper-book shops, you're going to set up a simple calendar. For shops with existing software, you'll build a tool that talks to their system's API.

// Create the booking tool
const bookingTool = await chanl.tools.create({
  name: "check_availability",
  description: "Check available appointment slots for the auto shop. Returns open time slots for a given date range and estimated service duration.",
  inputSchema: {
    type: "object",
    properties: {
      date: {
        type: "string",
        description: "Date to check, YYYY-MM-DD format"
      },
      durationMinutes: {
        type: "number",
        description: "Estimated service duration in minutes"
      },
      bayPreference: {
        type: "string",
        enum: ["any", "lift-required", "alignment-bay"],
        description: "Type of bay needed for the service"
      }
    },
    required: ["date", "durationMinutes"]
  },
  endpoint: "https://your-api.com/shops/mikes-auto/availability",
  method: "GET"
})
 
const createBookingTool = await chanl.tools.create({
  name: "book_appointment",
  description: "Book an appointment slot for a customer. Requires customer name, phone, vehicle info, service description, and selected time slot.",
  inputSchema: {
    type: "object",
    properties: {
      customerName: { type: "string" },
      customerPhone: { type: "string" },
      vehicleInfo: { type: "string", description: "Year, make, model" },
      serviceDescription: { type: "string", description: "What work is being done" },
      date: { type: "string" },
      time: { type: "string" },
      estimatedDuration: { type: "number" }
    },
    required: ["customerName", "customerPhone", "vehicleInfo", "serviceDescription", "date", "time"]
  },
  endpoint: "https://your-api.com/shops/mikes-auto/appointments",
  method: "POST"
})

The scheduling logic behind these endpoints is something you build once and reuse for every shop. A four-bay shop has four parallel "resources." Oil changes take 30-45 minutes. Brake jobs take 60-90 minutes. Timing belt replacements take 3-4 hours. The booking system checks which bays are open for the requested duration and returns available slots.

The conversation with Carlos now flows naturally:

Carlos: Hey, I need to bring my truck in.

Agent: Hi Carlos. Looking at your F-150, you're due for an oil change, and Mike has recommended a timing belt replacement at your last two visits. Want to get both done? I'm checking availability now.

Carlos: Yeah, let's do it. What's that going to run me?

Agent: Oil change with synthetic is $55-75 for your F-150. Timing belt replacement runs $450-600. So you're looking at roughly $500-675 total. I have Thursday at 8 AM or Friday at 9 AM. The timing belt takes about 3 hours, so we'd want to start early.

Carlos: Thursday works. 8 AM.

Agent: Got it. You're booked for Thursday at 8 AM. Oil change and timing belt replacement for your 2018 F-150. We'll plan for about 3.5 hours. Mike will give you a call if anything comes up during the work.

Every piece of that conversation used real data. The service history came from memory. The pricing came from the knowledge base. The availability check came from the booking tool. None of it was made up.

Piece 4: Proactive maintenance reminders

Everything so far handles inbound calls. But the biggest revenue opportunity for auto shops is outbound: reminding customers about maintenance before they think to call.

Most car owners are reactive. They drive until something squeals, clunks, or lights up on the dashboard. The smart shops send reminders. The problem is that sending reminders manually takes time nobody has, and generic "it's been 6 months" postcards get thrown away.

Personalized reminders based on actual service history convert at much higher rates.

Here's the logic. For each customer in the memory system, you check:

• Last oil change date and mileage. If it's been 5+ months or 5,000+ estimated miles, trigger a reminder.
• Last tire rotation. Every 5,000-7,500 miles.
• Any deferred maintenance from the last visit notes.
• State inspection due date (if tracked).

// Run this weekly as a scheduled job
async function generateReminders(shopAgentId: string) {
  // Search memory for all vehicle profiles
  const vehicles = await chanl.memory.search({
    agentId: shopAgentId,
    entityType: 'vehicle',
    query: 'service history oil change tire rotation'
  })
 
  const reminders = []
 
  for (const vehicle of vehicles.results) {
    const lastOilChange = parseServiceDate(vehicle.facts, 'oil change')
    const monthsSinceOil = monthsBetween(lastOilChange, new Date())
 
    if (monthsSinceOil >= 5) {
      reminders.push({
        customer: vehicle.entityId,
        phone: extractPhone(vehicle.facts),
        message: buildReminderMessage(vehicle, 'oil change', monthsSinceOil)
      })
    }
 
    // Check for deferred maintenance
    const deferred = findDeferredMaintenance(vehicle.facts)
    if (deferred.length > 0) {
      reminders.push({
        customer: vehicle.entityId,
        phone: extractPhone(vehicle.facts),
        message: buildDeferredMessage(vehicle, deferred)
      })
    }
  }
 
  return reminders
}
 
function buildReminderMessage(vehicle, serviceType, monthsSince) {
  // Returns something like:
  // "Hi Carlos, this is Mike's Auto Shop. It's been 5 months since
  // your last oil change on your F-150. Would you like to schedule
  // one this week? Reply YES or call us at 555-0123."
  return `Hi ${vehicle.ownerFirstName}, this is Mike's Auto Shop. ` +
    `It's been ${monthsSince} months since your last ${serviceType} ` +
    `on your ${vehicle.yearMakeModel}. Would you like to schedule ` +
    `one this week? Reply YES or call us at ${shopPhone}.`
}

These reminders go out via text message. The response rate on personalized texts ("your F-150" not "your vehicle", "5 months" not "it's been a while") is significantly higher than generic postcards.

When Carlos texts back "YES," the conversation picks up with the AI agent: "Great, Carlos. I have openings Tuesday at 10 AM and Wednesday at 2 PM. Which works better?"

The loop closes. Inbound calls get answered. Service history gets recorded. Reminders go out based on that history. Reminders generate bookings. Bookings generate service history. The shop's revenue compounds.

Putting it all together: the agent

You've built four pieces. Now wire them into a single agent that handles phone calls for Mike's shop.

// Create the shop agent
const shopAgent = await chanl.agents.create({
  name: "Mike's Auto Shop Assistant",
  systemPrompt: `You are the phone assistant for Mike's Auto Shop, a family-owned auto repair shop.
 
Your job:
- Answer questions about services and pricing using the service catalog
- Look up returning customers' vehicle history
- Book appointments based on bay availability
- Be honest about pricing (always give ranges, never exact quotes without seeing the car)
- For complex diagnostic questions you can't answer, offer to schedule a diagnostic appointment ($49 inspection fee) or take a message for Mike
 
Your personality:
- Friendly and straightforward. This is a blue-collar business.
- Use the customer's first name when you know it
- Don't upsell aggressively, but do mention deferred maintenance from previous visits
- If a repair sounds safety-related (brakes grinding metal-on-metal, steering wobble), treat it as urgent and try to get them in within 24 hours
 
What you don't do:
- Never diagnose a problem you haven't seen. "That could be several things" is fine. "That's definitely your alternator" is not.
- Never guarantee a price. Always say "estimated range" or "typically runs between X and Y"
- Never commit to a completion time. Say "we'll plan for about X hours but Mike will call you if anything changes"
 
Shop hours: Monday-Friday 7:30 AM to 5:30 PM, Saturday 8 AM to 1 PM. Closed Sunday.
Address: 4721 Industrial Blvd, Suite C
Phone: 555-0123`,
  tools: [bookingTool.id, createBookingTool.id],
  knowledgeBases: [kb.id]
})

The prompt does a lot of work here. Notice what's explicit:

Always give ranges. Auto repair pricing is inherently variable. The agent says "$260-320" not "$290." This sets honest expectations and avoids the "you said it would be $290" argument.

Never diagnose remotely. Mike can listen to a noise and make a good guess. The AI cannot. Routing diagnostic questions to "come in for an inspection" is the right call.

Urgency detection. If someone describes brakes grinding or a steering problem, the agent skips the casual scheduling and tries to get them in fast. This is a safety feature that also happens to be good business.

Testing before you give it Mike's phone number

Before this agent takes a single real call, run it through scenario testing. Build test conversations that cover the common flows and the edge cases:

The easy ones:

• "How much for an oil change on my Camry?"
• "Do you have any openings Friday?"
• "I need new tires on my F-150"

The tricky ones:

• "My brakes are grinding really bad, is it safe to drive?" (should recommend coming in immediately)
• "Can you fix a Tesla?" (Mike's shop doesn't work on EVs. Agent should say so.)
• "I need a quote for a head gasket on a 2003 BMW 325i" (luxury + major repair = high variance. Agent should recommend an in-person diagnostic.)
• "This is Carlos, I was just in last month" (should pull up vehicle memory)

The ones that catch bad agents:

• "My check engine light is on, what's wrong?" (should not guess. Should offer diagnostic appointment.)
• "How much to fix my transmission?" (way too broad. Should ask questions first.)
• "I found a shop that charges $50 less, can you match it?" (should not make pricing commitments. Offer to have Mike call back.)

Run these through Chanl's scenario testing with different personas. A calm customer, an impatient one, someone who barely speaks English, someone who's clearly stressed about the cost. Watch how the agent handles each one.

Then set up monitoring for the live calls. Track which questions the agent handles well, where it struggles, and which calls it routes to Mike. That data tells you what to improve in the knowledge base and prompt.

The business math

Here's the pitch deck for Mike, in napkin math he'll understand.

Mike's problem in dollars:

• 30-40 calls per day, roughly 10-15 go to voicemail
• Average repair ticket: $200-500
• If voicemail costs him 5 booked jobs per week: $1,000-2,500/week lost
• That's $4,000-10,000/month walking out the door

What you charge Mike:

• Setup: $500 (knowledge base, agent config, scheduling integration, testing)
• Monthly: $350-450 (includes platform costs, maintenance, updates)

Mike's ROI:

• Recovering even 3 missed calls per week pays for the service
• Maintenance reminders turn 1x/year customers into 3x/year customers
• A shop with 500 customers sending targeted reminders can add $15,000-25,000/year in recurring visits

Mike doesn't need to understand AI. He needs to understand that his phone will never go to voicemail again, and his customers' cars will be tracked like they're at a dealership.

Your costs per shop:

• Chanl platform: ~$50/month
• Scheduling API hosting: ~$10-20/month
• Your margin per shop: $280-380/month

The side hustle math:

• Setup time per shop: 4-6 hours (first one takes longer, rest get faster)
• Ongoing maintenance: 2-3 hours/month per shop
• 5 shops = $1,400-1,900/month net
• 10 shops = $2,800-3,800/month net

Why auto repair shops specifically?

There are 280,000 of them in the US alone. They're in every strip mall and every small town. The owners are mechanics, not tech people. They know their phone situation is a problem. They've thought about hiring a receptionist. They just can't justify $2,500-3,000/month for a full-time front desk person to answer a phone that's busy for 2 hours and dead for 6.

$400/month for an AI that works every hour they're open, never calls in sick, and remembers every vehicle? That's an easy yes.

Selling it: the first five shops

You don't cold-call auto shops. You walk in.

Go to the shop. Tell the owner you want to get your oil changed (or actually need one). While you're in the waiting area, watch. Count how many times the phone rings. Notice who answers it and how long they wait. If you hear a voicemail pickup, that's your opening.

When you pick up your car, mention it casually. "I noticed your phone rang a few times while I was waiting. I build AI phone systems for shops like yours. It answers calls with your real pricing, books appointments, and remembers every customer's car. Want to see a demo?"

The demo is everything. Call the agent from your phone while the shop owner listens. Ask it about brake pricing on a Civic. Ask about availability. Then show the vehicle memory feature. Pull up a test customer profile with six months of service history and watch the owner react when the agent rattles off the service record and recommends the timing belt.

The vehicle memory is what closes the deal. Every shop owner has 50-100 regulars whose history lives in their head. The idea that an AI can hold that same information and use it during a phone call, that's the moment they pull out a checkbook.

Start with one shop. Get it running perfectly. Use that shop as a reference for the next four. Auto repair is a word-of-mouth industry. Mechanics talk to each other. If Mike loves it, he'll tell three other shop owners at the parts counter.

What you've built

An AI agent that:

• Answers every call with real pricing from the shop's service catalog
• Knows every returning customer's vehicle and full service history
• Books appointments into open bay slots based on service duration
• Sends personalized maintenance reminders that bring customers back
• Routes complex questions to the mechanic instead of guessing

The knowledge base handles the "how much." The vehicle memory handles the "what does my car need." The tools handle the "when can I come in." The reminders handle the "don't forget about us."

For Mike, it's the $400/month solution to a problem he's had for twenty years. For you, it's a repeatable product you can sell to every independent shop in your city.

Carlos is going to call Thursday morning to confirm his 8 AM timing belt appointment. The agent is going to pick up on the first ring, greet him by name, confirm the appointment, and remind him they'll need the truck for about three and a half hours.

Mike is going to be under a car the whole time. Exactly where he should be.

Learn Agentic AI

One lesson a week — practical techniques for building, testing, and shipping AI agents. From prompt engineering to production monitoring. Learn by doing.

Subscribe

500+ engineers subscribed