AI Agent for Electrical Contractors: Job Estimation, Permit Tracking, and Scheduling

The Electrical Contracting Workflow

Electrical contractors juggle a complex web of responsibilities: assessing job scope from architectural plans, calculating material lists, pulling permits from municipal databases, ensuring NEC code compliance, scheduling crews with the right certifications, and coordinating inspections. Each of these steps involves specialized knowledge and careful documentation. An AI agent that handles estimation, permit tracking, and scheduling frees licensed electricians to focus on the work only they can do.

The highest-value capability is accurate job estimation. Underbidding loses money; overbidding loses contracts. An AI agent trained on historical job data produces consistently accurate estimates.

Building the Scope Assessment Engine

Electrical job estimation starts with understanding what the project requires. The agent gathers structured information about the scope and maps it to labor and material estimates.

flowchart LR
    REQ(["Inbound request"])
    PII["PII detection<br/>regex plus NER"]
    POL{"Policy engine<br/>OPA or rules"}
    REDACT["Redact or mask"]
    LLM["LLM call"]
    OUT["Response"]
    AUDIT[("Append only<br/>audit log")]
    BLOCK(["Block plus<br/>notify DPO"])
    REQ --> PII --> POL
    POL -->|Allow| REDACT --> LLM --> OUT --> AUDIT
    POL -->|Deny| BLOCK
    style POL fill:#4f46e5,stroke:#4338ca,color:#fff
    style AUDIT fill:#ede9fe,stroke:#7c3aed,color:#1e1b4b
    style BLOCK fill:#dc2626,stroke:#b91c1c,color:#fff
    style OUT fill:#059669,stroke:#047857,color:#fff

from dataclasses import dataclass, field
from enum import Enum

class JobType(Enum):
    RESIDENTIAL_NEW = "residential_new"
    RESIDENTIAL_REMODEL = "residential_remodel"
    COMMERCIAL_TENANT = "commercial_tenant"
    COMMERCIAL_NEW = "commercial_new"
    INDUSTRIAL = "industrial"
    SERVICE_UPGRADE = "service_upgrade"

@dataclass
class ScopeItem:
    category: str        # "outlets", "lighting", "panel", "circuits"
    quantity: int
    specification: str   # "20A GFCI", "200A main panel", "LED recessed"
    unit_labor_hours: float
    unit_material_cost: float

@dataclass
class JobEstimate:
    job_type: JobType
    scope_items: list[ScopeItem] = field(default_factory=list)
    permit_required: bool = True
    inspection_count: int = 1

    @property
    def total_labor_hours(self) -> float:
        return sum(item.quantity * item.unit_labor_hours for item in self.scope_items)

    @property
    def total_material_cost(self) -> float:
        return sum(item.quantity * item.unit_material_cost for item in self.scope_items)

    def generate_estimate(self, hourly_rate: float = 85.0) -> dict:
        labor = self.total_labor_hours * hourly_rate
        materials = self.total_material_cost
        permit_fees = self._estimate_permit_fees()
        overhead = (labor + materials) * 0.15
        profit = (labor + materials + overhead) * 0.10
        return {
            "labor": round(labor, 2),
            "materials": round(materials, 2),
            "permit_fees": round(permit_fees, 2),
            "overhead": round(overhead, 2),
            "profit_margin": round(profit, 2),
            "total": round(labor + materials + permit_fees + overhead + profit, 2),
            "estimated_days": round(self.total_labor_hours / 8, 1),
        }

    def _estimate_permit_fees(self) -> float:
        base_fees = {
            JobType.RESIDENTIAL_NEW: 250,
            JobType.RESIDENTIAL_REMODEL: 150,
            JobType.COMMERCIAL_TENANT: 350,
            JobType.COMMERCIAL_NEW: 750,
            JobType.INDUSTRIAL: 1200,
            JobType.SERVICE_UPGRADE: 200,
        }
        return base_fees.get(self.job_type, 200) if self.permit_required else 0

Permit Tracking System

Electrical work almost always requires permits. The agent tracks applications through their lifecycle and alerts when action is needed.

from datetime import datetime, timedelta
from typing import Optional

class PermitStatus(Enum):
    DRAFT = "draft"
    SUBMITTED = "submitted"
    UNDER_REVIEW = "under_review"
    APPROVED = "approved"
    REVISION_REQUIRED = "revision_required"
    EXPIRED = "expired"
    INSPECTION_SCHEDULED = "inspection_scheduled"

@dataclass
class PermitRecord:
    permit_id: str
    job_id: str
    jurisdiction: str
    permit_type: str
    status: PermitStatus
    submitted_date: Optional[datetime] = None
    approved_date: Optional[datetime] = None
    expiration_date: Optional[datetime] = None
    inspector_notes: str = ""

class PermitTracker:
    def __init__(self, db):
        self.db = db

    async def check_permit_status(self, job_id: str) -> list[dict]:
        permits = await self.db.fetch(
            """SELECT permit_id, permit_type, status, submitted_date,
                      approved_date, expiration_date, inspector_notes
               FROM permits WHERE job_id = $1
               ORDER BY submitted_date DESC""",
            job_id,
        )
        results = []
        for p in permits:
            alert = None
            if p["status"] == "approved" and p["expiration_date"]:
                days_left = (p["expiration_date"] - datetime.now()).days
                if days_left < 30:
                    alert = f"Permit expires in {days_left} days"
            elif p["status"] == "submitted":
                days_waiting = (datetime.now() - p["submitted_date"]).days
                if days_waiting > 10:
                    alert = f"Permit pending for {days_waiting} days — consider following up"
            results.append({**dict(p), "alert": alert})
        return results

    async def get_expiring_permits(self, days_ahead: int = 30) -> list[dict]:
        cutoff = datetime.now() + timedelta(days=days_ahead)
        return await self.db.fetch(
            """SELECT p.permit_id, p.job_id, j.address, p.expiration_date
               FROM permits p JOIN jobs j ON p.job_id = j.id
               WHERE p.status = 'approved'
                 AND p.expiration_date <= $1
               ORDER BY p.expiration_date ASC""",
            cutoff,
        )

Code Compliance Verification

The agent checks job specifications against NEC requirements to flag compliance issues before inspection.

NEC_RULES = {
    "kitchen_circuits": {
        "rule": "NEC 210.11(C)(1)",
        "requirement": "Minimum two 20A small-appliance branch circuits",
        "check": lambda scope: sum(
            1 for item in scope
            if item.category == "circuits" and "kitchen" in item.specification.lower()
              and "20A" in item.specification
        ) >= 2,
    },
    "bathroom_gfci": {
        "rule": "NEC 210.8(A)(1)",
        "requirement": "All bathroom receptacles must be GFCI protected",
        "check": lambda scope: all(
            "GFCI" in item.specification
            for item in scope
            if item.category == "outlets" and "bathroom" in item.specification.lower()
        ),
    },
    "service_grounding": {
        "rule": "NEC 250.24",
        "requirement": "Service entrance must have grounding electrode conductor",
        "check": lambda scope: any(
            "grounding" in item.specification.lower()
            for item in scope
            if item.category == "panel"
        ),
    },
}

def verify_code_compliance(scope_items: list[ScopeItem]) -> list[dict]:
    results = []
    for rule_name, rule in NEC_RULES.items():
        passed = rule["check"](scope_items)
        results.append({
            "rule": rule["rule"],
            "requirement": rule["requirement"],
            "status": "compliant" if passed else "non_compliant",
            "action_needed": None if passed else f"Review {rule_name} — does not meet {rule['rule']}",
        })
    return results

Crew Scheduling with Certification Tracking

Electrical work requires licensed electricians. The agent matches crew members to jobs based on license type and availability.

class CrewScheduler:
    def __init__(self, db):
        self.db = db

    async def assign_crew(
        self, job_id: str, job_type: JobType, start_date: datetime, days_needed: int,
    ) -> dict:
        license_requirements = {
            JobType.RESIDENTIAL_NEW: ["journeyman", "master"],
            JobType.COMMERCIAL_NEW: ["master"],
            JobType.INDUSTRIAL: ["master"],
            JobType.SERVICE_UPGRADE: ["journeyman", "master"],
        }
        required_licenses = license_requirements.get(job_type, ["journeyman"])

        available = await self.db.fetch(
            """SELECT e.id, e.name, e.license_type, e.license_expiry
               FROM electricians e
               WHERE e.license_type = ANY($1)
                 AND e.license_expiry > $2
                 AND e.id NOT IN (
                     SELECT electrician_id FROM assignments
                     WHERE start_date < $4 AND end_date > $3
                 )
               ORDER BY e.license_type DESC, e.rating DESC""",
            required_licenses, datetime.now(),
            start_date, start_date + timedelta(days=days_needed),
        )
        if not available:
            return {"assigned": False, "reason": "No qualified crew available for requested dates"}

        lead = available[0]
        return {
            "assigned": True,
            "lead_electrician": lead["name"],
            "license_type": lead["license_type"],
            "license_valid_through": lead["license_expiry"].isoformat(),
            "start_date": start_date.isoformat(),
            "end_date": (start_date + timedelta(days=days_needed)).isoformat(),
        }

FAQ

How does the agent stay current with NEC code changes?

The NEC code rules are stored as structured data that can be updated when new code editions are adopted. Since jurisdictions adopt NEC versions at different times, the agent tracks which NEC edition each jurisdiction uses and applies the correct rule set. The compliance rules are versioned alongside the agent and updated during the triennial NEC revision cycle.

Can the agent generate permit application documents?

Yes. The agent collects all required scope information during the estimation phase — circuit counts, panel sizes, wire gauges, and load calculations. It formats this data into the permit application template required by the specific jurisdiction. For jurisdictions that accept electronic submissions, the agent can submit directly via API.

How accurate are AI-generated electrical estimates compared to manual?

When trained on historical job data with at least 200 completed projects, the agent typically achieves 90-95% accuracy on material costs and 85-90% on labor hours. The key is capturing scope variations — a 200A panel upgrade in a 1960s ranch requires very different labor than the same upgrade in a modern home with an accessible utility room.

---

#ElectricalContractors #PermitTracking #JobEstimation #CodeCompliance #CrewScheduling #AgenticAI #LearnAI #AIEngineering