Building a Landscaping Business Agent: Quote Generation, Seasonal Scheduling, and Maintenance Plans

Why Landscaping Businesses Benefit from AI Agents

Landscaping companies operate on razor-thin margins with highly seasonal demand. A company that does spring cleanups, weekly mowing, fall leaf removal, and snow plowing must manage four distinct service models with different pricing, equipment, and crew requirements. An AI agent handles quote generation based on property size and service mix, builds seasonal schedules that optimize route density, creates recurring maintenance plans, and adjusts operations based on weather forecasts.

The biggest operational win is route optimization. A crew that visits five properties within a two-mile radius is dramatically more profitable than one driving across town between jobs.

Service Catalog and Quote Generation

Landscaping quotes depend on property dimensions, service frequency, and seasonal requirements. The agent calculates pricing from a structured catalog.

sequenceDiagram
    autonumber
    participant Caller as Caller
    participant Agent as CallSphere Agent
    participant API as CRM API
    participant DB as CRM Database
    participant Webhook as Webhook Listener
    Caller->>Agent: Inbound call begins
    Agent->>Agent: STT plus intent detection
    Agent->>API: Lookup contact by phone
    API->>DB: Read contact record
    DB-->>API: Contact and history
    API-->>Agent: Personalized context
    Agent->>API: Create call activity
    Agent->>API: Update deal stage
    API->>Webhook: Outbound webhook fires
    Webhook-->>Agent: Confirmed
    Agent->>Caller: Spoken confirmation

from dataclasses import dataclass
from enum import Enum

class ServiceFrequency(Enum):
    ONE_TIME = "one_time"
    WEEKLY = "weekly"
    BI_WEEKLY = "bi_weekly"
    MONTHLY = "monthly"
    SEASONAL = "seasonal"

@dataclass
class ServiceDefinition:
    service_id: str
    name: str
    base_price_per_sqft: float
    minimum_charge: float
    frequency_options: list[ServiceFrequency]
    season: list[str]  # months when service is available
    equipment_required: list[str]

SERVICE_CATALOG = {
    "mowing": ServiceDefinition(
        service_id="mowing",
        name="Lawn Mowing & Edging",
        base_price_per_sqft=0.008,
        minimum_charge=45.0,
        frequency_options=[ServiceFrequency.WEEKLY, ServiceFrequency.BI_WEEKLY],
        season=["apr", "may", "jun", "jul", "aug", "sep", "oct"],
        equipment_required=["mower", "edger", "blower"],
    ),
    "spring_cleanup": ServiceDefinition(
        service_id="spring_cleanup",
        name="Spring Cleanup",
        base_price_per_sqft=0.015,
        minimum_charge=175.0,
        frequency_options=[ServiceFrequency.ONE_TIME],
        season=["mar", "apr"],
        equipment_required=["rake", "blower", "trailer"],
    ),
    "leaf_removal": ServiceDefinition(
        service_id="leaf_removal",
        name="Fall Leaf Removal",
        base_price_per_sqft=0.012,
        minimum_charge=150.0,
        frequency_options=[ServiceFrequency.WEEKLY, ServiceFrequency.ONE_TIME],
        season=["oct", "nov", "dec"],
        equipment_required=["blower", "vacuum", "trailer"],
    ),
    "snow_plowing": ServiceDefinition(
        service_id="snow_plowing",
        name="Snow Plowing",
        base_price_per_sqft=0.005,
        minimum_charge=75.0,
        frequency_options=[ServiceFrequency.SEASONAL],
        season=["nov", "dec", "jan", "feb", "mar"],
        equipment_required=["plow_truck", "salt_spreader"],
    ),
}

class QuoteGenerator:
    def generate_quote(
        self, property_sqft: int, services: list[str],
        frequency: ServiceFrequency, season_months: int = 7,
    ) -> dict:
        line_items = []
        for svc_id in services:
            svc = SERVICE_CATALOG.get(svc_id)
            if not svc:
                continue
            per_visit = max(property_sqft * svc.base_price_per_sqft, svc.minimum_charge)
            if frequency == ServiceFrequency.WEEKLY:
                visits = season_months * 4
            elif frequency == ServiceFrequency.BI_WEEKLY:
                visits = season_months * 2
            elif frequency == ServiceFrequency.MONTHLY:
                visits = season_months
            else:
                visits = 1

            line_items.append({
                "service": svc.name,
                "per_visit": round(per_visit, 2),
                "visits": visits,
                "subtotal": round(per_visit * visits, 2),
            })

        total = sum(item["subtotal"] for item in line_items)
        return {
            "property_sqft": property_sqft,
            "line_items": line_items,
            "subtotal": round(total, 2),
            "tax": round(total * 0.07, 2),
            "total": round(total * 1.07, 2),
            "payment_options": {
                "annual_prepay": round(total * 1.07 * 0.95, 2),
                "monthly": round(total * 1.07 / 12, 2),
                "per_visit": "See line items",
            },
        }

Seasonal Schedule Management

The agent builds and adjusts schedules based on the time of year, transitioning crews between service types.

from datetime import datetime

class SeasonalScheduler:
    SEASON_MAP = {
        1: "winter", 2: "winter", 3: "spring",
        4: "spring", 5: "spring", 6: "summer",
        7: "summer", 8: "summer", 9: "fall",
        10: "fall", 11: "fall", 12: "winter",
    }

    def get_active_services(self, month: int) -> list[str]:
        month_abbr = datetime(2026, month, 1).strftime("%b").lower()
        return [
            svc_id for svc_id, svc in SERVICE_CATALOG.items()
            if month_abbr in svc.season
        ]

    def build_weekly_schedule(
        self, crews: list[dict], properties: list[dict], month: int,
    ) -> list[dict]:
        active_services = self.get_active_services(month)
        schedule = []
        for crew in crews:
            crew_properties = [
                p for p in properties
                if p["assigned_crew"] == crew["id"]
                  and any(s in active_services for s in p["services"])
            ]
            # Sort by geographic proximity for route efficiency
            crew_properties.sort(key=lambda p: (p["lat"], p["lon"]))
            daily_assignments = []
            day_index = 0
            properties_per_day = max(1, len(crew_properties) // 5)

            for i, prop in enumerate(crew_properties):
                if i > 0 and i % properties_per_day == 0:
                    day_index += 1
                daily_assignments.append({
                    "property": prop["address"],
                    "services": [s for s in prop["services"] if s in active_services],
                    "day_of_week": ["Monday", "Tuesday", "Wednesday",
                                    "Thursday", "Friday"][min(day_index, 4)],
                })
            schedule.append({"crew": crew["name"], "assignments": daily_assignments})
        return schedule

Weather-Aware Operations

The agent checks forecasts and adjusts schedules when weather makes service impossible or unnecessary.

class WeatherIntegration:
    def __init__(self, weather_api_client):
        self.weather = weather_api_client

    async def check_service_feasibility(
        self, zip_code: str, service_type: str, target_date: str,
    ) -> dict:
        forecast = await self.weather.get_forecast(zip_code, target_date)
        blockers = []
        if service_type == "mowing":
            if forecast["precipitation_chance"] > 60:
                blockers.append("High rain probability — wet grass causes poor cut quality")
            if forecast["wind_speed_mph"] > 25:
                blockers.append("High winds — unsafe for debris blowing")
        elif service_type == "snow_plowing":
            if forecast["snowfall_inches"] < 2:
                blockers.append("Snowfall below 2-inch trigger threshold")

        return {
            "date": target_date,
            "service": service_type,
            "feasible": len(blockers) == 0,
            "blockers": blockers,
            "recommendation": "Proceed as scheduled" if not blockers else "Reschedule recommended",
            "next_clear_day": forecast.get("next_clear_day"),
        }

Recurring Maintenance Plans

The agent creates annual maintenance plans that automatically generate work orders each season.

class MaintenancePlanBuilder:
    def create_annual_plan(self, property_sqft: int, climate_zone: str) -> dict:
        plans = {
            "northeast": [
                {"month": 3, "service": "spring_cleanup"},
                {"month": 4, "service": "mowing", "frequency": "weekly", "through": 10},
                {"month": 5, "service": "fertilization"},
                {"month": 6, "service": "irrigation_check"},
                {"month": 9, "service": "aeration_overseeding"},
                {"month": 10, "service": "leaf_removal", "frequency": "weekly", "through": 12},
                {"month": 11, "service": "winterization"},
                {"month": 12, "service": "snow_plowing", "frequency": "as_needed", "through": 3},
            ],
            "southeast": [
                {"month": 2, "service": "pre_emergent"},
                {"month": 3, "service": "mowing", "frequency": "weekly", "through": 11},
                {"month": 5, "service": "fertilization"},
                {"month": 7, "service": "irrigation_check"},
                {"month": 10, "service": "aeration_overseeding"},
                {"month": 12, "service": "leaf_removal"},
            ],
        }
        plan_template = plans.get(climate_zone, plans["northeast"])
        quote_gen = QuoteGenerator()
        services = list({item["service"] for item in plan_template})
        estimate = quote_gen.generate_quote(property_sqft, services, ServiceFrequency.WEEKLY)
        return {
            "climate_zone": climate_zone,
            "schedule": plan_template,
            "annual_estimate": estimate["total"],
            "monthly_payment": round(estimate["total"] / 12, 2),
        }

FAQ

How does the agent handle property measurements when the customer does not know their lot size?

The agent integrates with public property records (county assessor APIs) and satellite imagery services to estimate lot size from the property address. It pulls the parcel boundary data and calculates the lawn area by subtracting the building footprint, driveway, and hardscape. This estimate is typically within 10% of actual measurement.

Can the agent adjust pricing for terrain difficulty?

Yes. Properties are tagged with terrain modifiers — flat, sloped, heavily wooded, or fenced sections requiring push mowing. Each modifier applies a multiplier to the base rate. A steep slope might add 25% to mowing costs because it requires specialized equipment and takes more time. The agent captures these modifiers during the initial property assessment.

How does weather integration prevent revenue loss?

Rather than simply canceling service days, the agent reschedules to the next feasible day and compresses the week's remaining schedule. It also distinguishes between "skip" conditions (property does not need mowing after a dry week) and "delay" conditions (rain today but mowing needed tomorrow). This preserves visit counts and revenue targets.

---

#Landscaping #QuoteGeneration #SeasonalScheduling #MaintenancePlans #WeatherIntegration #AgenticAI #LearnAI #AIEngineering