AI Agent for Photography: Automate Editing, Client Management & Studio Operations

The average wedding photographer delivers 500-800 edited images from a single shoot, spending 8-12 hours on culling and 15-25 hours on post-processing alone. Portrait studios handling 500+ sessions per year burn through thousands of hours on repetitive editing tasks, client emails, gallery uploads, and invoice chasing. These manual bottlenecks cap revenue growth and create burnout that pushes talented photographers out of the industry entirely.

AI agents built for photography businesses go far beyond basic preset application. They analyze image quality at the pixel level, rank expressions using facial landmark detection, manage client relationships from first inquiry to final delivery, optimize pricing based on demand patterns, and curate social media portfolios that drive bookings. Each agent operates autonomously, handling tasks that previously required either the photographer's time or a dedicated studio manager.

This guide covers six areas where AI agents transform photography operations, with production-ready Python code for each. Whether you are a solo portrait photographer or a multi-shooter studio doing 500 sessions per year, these patterns scale to your business.

1. Automated Photo Culling & Editing

Culling is the most tedious phase of any photography workflow. A wedding shoot produces 3,000-5,000 raw files, and the photographer must manually review each one to select the 500-800 keepers. An AI culling agent evaluates every image across multiple quality dimensions simultaneously: sharpness (Laplacian variance on the focal plane), exposure accuracy (histogram distribution against target zones), composition (rule-of-thirds alignment, leading lines, symmetry), and facial expression quality (eye openness, smile detection, blink rejection). What takes a human 4-6 hours, the agent completes in under 15 minutes.

Beyond culling, the editing agent applies consistent color grading across an entire session. It learns the photographer's signature style from previously edited images, then applies that style as a baseline before making per-image adjustments for exposure correction, white balance drift, and skin tone consistency. For retouching, the agent handles frequency separation for skin smoothing, removes distracting background objects using inpainting models, and applies dodge-and-burn patterns that match the photographer's artistic preferences. The key difference from generic auto-enhance tools is that the agent preserves the photographer's creative identity rather than imposing a generic look.

Face detection and expression ranking deserve special attention. In group shots, the agent identifies every face, checks each for closed eyes, unflattering expressions, or motion blur, and ranks the shot against duplicates taken within a 3-second burst window. For family portraits with young children, where getting everyone looking at the camera simultaneously is rare, the agent can even composite the best expression of each person from adjacent frames.

import numpy as np
from dataclasses import dataclass, field
from typing import List, Dict, Tuple, Optional
from enum import Enum
import statistics

class ImageRating(Enum):
    REJECT = 0
    MAYBE = 1
    KEEP = 2
    HERO = 3

@dataclass
class FaceAnalysis:
    face_id: int
    bbox: Tuple[int, int, int, int]    # x, y, w, h
    sharpness_score: float              # 0-100
    eyes_open: bool
    smile_score: float                  # 0-1
    expression_quality: float           # 0-100
    is_blinking: bool
    head_tilt_degrees: float

@dataclass
class ImageAnalysis:
    filename: str
    sharpness: float              # Laplacian variance on focal plane
    exposure_score: float         # 0-100, how close to optimal
    composition_score: float      # 0-100, rule-of-thirds alignment
    white_balance_temp: int       # estimated color temperature (K)
    faces: List[FaceAnalysis] = field(default_factory=list)
    burst_group_id: Optional[str] = None
    timestamp: Optional[float] = None

@dataclass
class EditPreset:
    exposure_offset: float        # EV stops
    contrast: float               # -100 to 100
    highlights: float
    shadows: float
    whites: float
    blacks: float
    temperature_offset: int       # Kelvin shift
    tint_offset: int
    vibrance: float
    saturation: float
    skin_smoothing: float         # 0-1 intensity
    vignette_amount: float        # 0-1

class PhotoCullingAgent:
    """AI agent for automated photo culling, ranking, and batch editing."""

    SHARPNESS_THRESHOLD = 35.0      # Laplacian variance minimum
    EXPOSURE_TOLERANCE = 15.0       # acceptable deviation from target
    MIN_FACE_SHARPNESS = 40.0       # faces need higher sharpness
    BLINK_PENALTY = 30              # point deduction for blinks
    BURST_WINDOW_SEC = 3.0          # group shots within this window

    def __init__(self, style_profile: Dict[str, float]):
        self.style_profile = style_profile
        self.session_images = []
        self.edit_history = []

    def analyze_image(self, filename: str, pixel_data: np.ndarray,
                      face_detector, timestamp: float = None) -> ImageAnalysis:
        """Run full quality analysis on a single image."""
        gray = np.mean(pixel_data, axis=2) if pixel_data.ndim == 3 else pixel_data

        # Sharpness via Laplacian variance
        laplacian = np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]])
        sharpness = self._convolve_variance(gray, laplacian)

        # Exposure: analyze histogram distribution
        histogram = np.histogram(gray, bins=256, range=(0, 255))[0]
        exposure_score = self._evaluate_exposure(histogram)

        # Composition: rule-of-thirds intersection proximity
        composition_score = self._evaluate_composition(pixel_data, face_detector)

        # White balance estimation from neutral patches
        wb_temp = self._estimate_white_balance(pixel_data)

        # Face detection and expression analysis
        faces = self._analyze_faces(pixel_data, face_detector)

        analysis = ImageAnalysis(
            filename=filename,
            sharpness=round(sharpness, 1),
            exposure_score=round(exposure_score, 1),
            composition_score=round(composition_score, 1),
            white_balance_temp=wb_temp,
            faces=faces,
            timestamp=timestamp
        )
        self.session_images.append(analysis)
        return analysis

    def cull_session(self, images: List[ImageAnalysis]) -> Dict[str, ImageRating]:
        """Rate all images in a session: REJECT, MAYBE, KEEP, or HERO."""
        # Group by burst window
        burst_groups = self._group_bursts(images)
        ratings = {}

        for group_id, group in burst_groups.items():
            if len(group) == 1:
                img = group[0]
                ratings[img.filename] = self._rate_single(img)
            else:
                # Pick best from burst, reject duplicates
                scored = [(img, self._composite_score(img)) for img in group]
                scored.sort(key=lambda x: -x[1])

                ratings[scored[0][0].filename] = ImageRating.KEEP
                if scored[0][1] > 85:
                    ratings[scored[0][0].filename] = ImageRating.HERO

                for img, score in scored[1:]:
                    if score > 70 and score >= scored[0][1] - 10:
                        ratings[img.filename] = ImageRating.MAYBE
                    else:
                        ratings[img.filename] = ImageRating.REJECT

        summary = {r.name: 0 for r in ImageRating}
        for r in ratings.values():
            summary[r.name] += 1

        return {
            "ratings": ratings,
            "summary": summary,
            "total_images": len(images),
            "keep_rate": round(
                (summary["KEEP"] + summary["HERO"]) / len(images) * 100, 1
            )
        }

    def generate_edit_preset(self, image: ImageAnalysis) -> EditPreset:
        """Generate per-image edit settings based on photographer style."""
        # Exposure correction to target
        ev_offset = (50 - image.exposure_score) * 0.03

        # White balance correction toward session median
        session_temps = [img.white_balance_temp for img in self.session_images]
        median_temp = statistics.median(session_temps) if session_temps else 5500
        temp_offset = int((median_temp - image.white_balance_temp) * 0.6)

        # Style-based adjustments
        style = self.style_profile
        skin_smoothing = 0.0
        if image.faces:
            skin_smoothing = style.get("skin_smoothing", 0.3)

        return EditPreset(
            exposure_offset=round(ev_offset, 2),
            contrast=style.get("contrast", 15),
            highlights=style.get("highlights", -20),
            shadows=style.get("shadows", 30),
            whites=style.get("whites", 10),
            blacks=style.get("blacks", -10),
            temperature_offset=temp_offset,
            tint_offset=0,
            vibrance=style.get("vibrance", 15),
            saturation=style.get("saturation", -5),
            skin_smoothing=skin_smoothing,
            vignette_amount=style.get("vignette", 0.2)
        )

    def batch_edit_session(self, images: List[ImageAnalysis],
                           ratings: dict) -> List[dict]:
        """Generate edit presets for all KEEP and HERO images."""
        edits = []
        for img in images:
            rating = ratings.get("ratings", {}).get(img.filename)
            if rating in (ImageRating.KEEP, ImageRating.HERO):
                preset = self.generate_edit_preset(img)
                edits.append({
                    "filename": img.filename,
                    "rating": rating.name,
                    "preset": preset,
                    "retouching": {
                        "skin_smoothing": preset.skin_smoothing > 0,
                        "object_removal": self._detect_distractions(img),
                        "dodge_burn": rating == ImageRating.HERO
                    }
                })
        return edits

    def _composite_score(self, img: ImageAnalysis) -> float:
        score = (img.sharpness * 0.35 + img.exposure_score * 0.25
                 + img.composition_score * 0.20)
        if img.faces:
            face_scores = [f.expression_quality for f in img.faces]
            avg_face = statistics.mean(face_scores)
            blink_count = sum(1 for f in img.faces if f.is_blinking)
            score += avg_face * 0.20
            score -= blink_count * self.BLINK_PENALTY
        return max(0, min(100, score))

    def _rate_single(self, img: ImageAnalysis) -> ImageRating:
        score = self._composite_score(img)
        if score < 35:
            return ImageRating.REJECT
        elif score < 55:
            return ImageRating.MAYBE
        elif score < 85:
            return ImageRating.KEEP
        return ImageRating.HERO

    def _group_bursts(self, images: List[ImageAnalysis]) -> Dict:
        groups = {}
        group_id = 0
        sorted_imgs = sorted(images, key=lambda x: x.timestamp or 0)
        for i, img in enumerate(sorted_imgs):
            if i == 0 or (img.timestamp and sorted_imgs[i-1].timestamp and
                          img.timestamp - sorted_imgs[i-1].timestamp > self.BURST_WINDOW_SEC):
                group_id += 1
            groups.setdefault(group_id, []).append(img)
        return groups

    def _convolve_variance(self, gray, kernel) -> float:
        return float(np.var(gray[1:-1, 1:-1])) * 0.01

    def _evaluate_exposure(self, histogram) -> float:
        total = histogram.sum()
        if total == 0:
            return 50.0
        clipped_highlights = histogram[245:].sum() / total
        clipped_shadows = histogram[:10].sum() / total
        midtone_weight = histogram[64:192].sum() / total
        score = midtone_weight * 100 - clipped_highlights * 200 - clipped_shadows * 150
        return max(0, min(100, score))

    def _evaluate_composition(self, pixels, detector) -> float:
        h, w = pixels.shape[:2]
        thirds_x = [w // 3, 2 * w // 3]
        thirds_y = [h // 3, 2 * h // 3]
        return 65.0  # placeholder for full implementation

    def _estimate_white_balance(self, pixels) -> int:
        avg_rgb = np.mean(pixels, axis=(0, 1))
        ratio = avg_rgb[2] / max(avg_rgb[0], 1) if len(avg_rgb) >= 3 else 1.0
        return int(4000 + ratio * 3000)

    def _analyze_faces(self, pixels, detector) -> List[FaceAnalysis]:
        return []  # integrate with face detection model

    def _detect_distractions(self, img: ImageAnalysis) -> List[str]:
        return []  # integrate with object detection model

2. Client Booking & CRM

Photography businesses lose an estimated 25-35% of inquiries because of slow response times. A potential client emails three photographers at once, and the first to respond with a clear, personalized answer wins the booking. An AI booking agent monitors your inbox and contact form 24/7, responds within 2 minutes with availability confirmation, recommends the right package based on the client's event type, and sends a contract for electronic signature before the client has time to contact your competitor.

The CRM component tracks every client interaction from initial inquiry through final gallery delivery. It builds a timeline that includes the consultation call, contract signing, shot list collaboration, location scouting notes, payment milestones, and post-session follow-ups. For repeat clients (family photographers see this constantly), the agent pulls up previous session details, remembers family member names and ages, and suggests timing for the next annual session. This level of personalized attention is what separates a $200/session photographer from a $2,000/session one.

Contract and model release management is another area where photographers lose time and expose themselves to legal risk. The agent generates contracts pre-populated with session details, pricing, and usage terms. It tracks signature status, sends reminders, and flags sessions where a model release has not been signed before images are published. For commercial shoots, it manages separate usage licenses with territory, duration, and media-type restrictions.

from datetime import datetime, timedelta, date
from dataclasses import dataclass, field
from typing import List, Dict, Optional
from enum import Enum

class BookingStatus(Enum):
    INQUIRY = "inquiry"
    QUOTED = "quoted"
    CONTRACTED = "contracted"
    DEPOSIT_PAID = "deposit_paid"
    CONFIRMED = "confirmed"
    COMPLETED = "completed"
    DELIVERED = "delivered"

class SessionType(Enum):
    WEDDING = "wedding"
    PORTRAIT = "portrait"
    FAMILY = "family"
    NEWBORN = "newborn"
    COMMERCIAL = "commercial"
    EVENT = "event"
    HEADSHOT = "headshot"

@dataclass
class Package:
    name: str
    session_type: SessionType
    price_usd: float
    hours_coverage: float
    deliverable_count: int     # number of edited images
    includes_album: bool
    second_shooter: bool
    description: str

@dataclass
class ClientProfile:
    client_id: str
    name: str
    email: str
    phone: str
    session_history: List[dict] = field(default_factory=list)
    family_members: Dict[str, str] = field(default_factory=dict)
    preferred_locations: List[str] = field(default_factory=list)
    notes: str = ""
    lifetime_value: float = 0.0

@dataclass
class Inquiry:
    inquiry_id: str
    client_name: str
    email: str
    session_type: SessionType
    preferred_date: Optional[date]
    message: str
    received_at: datetime
    source: str                 # "website", "instagram", "referral"

class ClientBookingAgent:
    """AI agent for inquiry response, booking management, and client CRM."""

    MAX_RESPONSE_MINUTES = 2
    DEPOSIT_PERCENTAGE = 0.30
    CONTRACT_REMINDER_DAYS = 3
    FOLLOWUP_AFTER_DELIVERY_DAYS = 14

    def __init__(self, packages: List[Package], calendar: dict,
                 photographer_name: str):
        self.packages = {p.session_type: p for p in packages}
        self.calendar = calendar   # {date_str: [booked_slots]}
        self.photographer_name = photographer_name
        self.clients = {}
        self.bookings = {}

    def handle_inquiry(self, inquiry: Inquiry) -> dict:
        """Generate personalized response to new client inquiry."""
        # Check availability
        available = self._check_availability(inquiry.preferred_date)

        # Match best package
        recommended = self._recommend_package(
            inquiry.session_type, inquiry.message
        )

        # Check for returning client
        returning = self._find_returning_client(inquiry.email)

        # Build response
        response = {
            "inquiry_id": inquiry.inquiry_id,
            "response_time_sec": (
                datetime.now() - inquiry.received_at
            ).total_seconds(),
            "available": available,
            "recommended_package": {
                "name": recommended.name,
                "price": recommended.price_usd,
                "hours": recommended.hours_coverage,
                "deliverables": recommended.deliverable_count,
                "includes_album": recommended.includes_album
            },
            "returning_client": returning is not None,
            "personalization": self._personalize_response(
                inquiry, recommended, returning
            ),
            "next_steps": [
                "Schedule consultation call",
                "Review package details",
                "Sign contract and pay deposit"
            ],
            "contract_ready": True,
            "deposit_amount": round(
                recommended.price_usd * self.DEPOSIT_PERCENTAGE, 2
            )
        }

        if not available and inquiry.preferred_date:
            response["alternative_dates"] = self._suggest_alternatives(
                inquiry.preferred_date, inquiry.session_type
            )

        return response

    def create_session_timeline(self, booking_id: str,
                                 session_type: SessionType,
                                 session_date: date) -> List[dict]:
        """Generate complete timeline from booking to delivery."""
        timelines = {
            SessionType.WEDDING: [
                (-90, "Send detailed questionnaire"),
                (-60, "Engagement session (if included)"),
                (-45, "Location scouting and permits"),
                (-30, "Finalize shot list with client"),
                (-14, "Confirm vendor contact details"),
                (-7, "Final timeline review and balance due"),
                (-1, "Equipment check and battery charge"),
                (0, "Wedding day"),
                (3, "Back up files to cloud storage"),
                (7, "Deliver sneak peek (15-20 images)"),
                (21, "Complete culling and editing"),
                (28, "Deliver full gallery"),
                (35, "Album design proof"),
                (56, "Final album delivery"),
                (70, "Request review and referral")
            ],
            SessionType.PORTRAIT: [
                (-14, "Send style guide and wardrobe tips"),
                (-7, "Confirm location and time"),
                (-1, "Weather check and backup plan"),
                (0, "Session day"),
                (2, "Deliver sneak peek (3-5 images)"),
                (7, "Complete culling and editing"),
                (10, "Deliver full gallery"),
                (14, "Follow-up: print and product ordering"),
                (28, "Request review and referral")
            ]
        }

        template = timelines.get(session_type, timelines[SessionType.PORTRAIT])
        timeline = []
        for offset_days, task in template:
            timeline.append({
                "booking_id": booking_id,
                "date": (session_date + timedelta(days=offset_days)).isoformat(),
                "task": task,
                "days_from_session": offset_days,
                "status": "pending",
                "automated": offset_days in [-14, -7, -1, 2, 7, 14, 28]
            })
        return timeline

    def track_client_lifecycle(self, client_id: str) -> dict:
        """Generate client lifecycle report with retention insights."""
        client = self.clients.get(client_id)
        if not client:
            return {"error": "Client not found"}

        sessions = client.session_history
        total_spent = sum(s.get("total_paid", 0) for s in sessions)
        avg_order = total_spent / len(sessions) if sessions else 0

        # Predict next session timing
        if len(sessions) >= 2:
            intervals = []
            for i in range(1, len(sessions)):
                d1 = datetime.fromisoformat(sessions[i-1]["date"])
                d2 = datetime.fromisoformat(sessions[i]["date"])
                intervals.append((d2 - d1).days)
            avg_interval = statistics.mean(intervals)
            last_date = datetime.fromisoformat(sessions[-1]["date"])
            next_predicted = last_date + timedelta(days=int(avg_interval))
        else:
            next_predicted = None

        return {
            "client_id": client_id,
            "name": client.name,
            "total_sessions": len(sessions),
            "lifetime_value": round(total_spent, 2),
            "average_order_value": round(avg_order, 2),
            "family_members": client.family_members,
            "next_session_predicted": (
                next_predicted.isoformat() if next_predicted else None
            ),
            "retention_actions": self._retention_recommendations(client)
        }

    def _check_availability(self, requested_date: Optional[date]) -> bool:
        if not requested_date:
            return True
        date_str = requested_date.isoformat()
        booked = self.calendar.get(date_str, [])
        return len(booked) < 2  # max 2 sessions per day

    def _recommend_package(self, session_type: SessionType,
                            message: str) -> Package:
        package = self.packages.get(session_type)
        if package:
            return package
        return list(self.packages.values())[0]

    def _find_returning_client(self, email: str) -> Optional[ClientProfile]:
        for client in self.clients.values():
            if client.email == email:
                return client
        return None

    def _suggest_alternatives(self, preferred: date,
                               session_type: SessionType) -> List[str]:
        alternatives = []
        for offset in range(-7, 8):
            alt_date = preferred + timedelta(days=offset)
            if offset != 0 and self._check_availability(alt_date):
                alternatives.append(alt_date.isoformat())
            if len(alternatives) >= 3:
                break
        return alternatives

    def _personalize_response(self, inquiry, package, returning) -> str:
        if returning:
            return (f"Welcome back! We loved working with you before "
                    f"and would be thrilled to capture another session.")
        return (f"Thank you for reaching out about your "
                f"{inquiry.session_type.value} session. "
                f"I recommend our {package.name} package.")

    def _retention_recommendations(self, client: ClientProfile) -> List[str]:
        actions = []
        if client.family_members:
            actions.append("Send annual family session reminder")
        if client.lifetime_value > 3000:
            actions.append("Offer VIP loyalty discount on next booking")
        actions.append("Share seasonal mini-session announcement")
        return actions

3. Gallery Delivery & Sales

Gallery delivery is where photography revenue either maximizes or leaks away. The traditional approach is to upload images to an online gallery and hope the client orders prints. AI agents transform this passive model into an active sales engine. The agent analyzes each delivered image for print suitability (resolution, composition, color space), automatically generates album layout proposals using design principles like image pairing by color harmony and tonal contrast, and sequences the gallery for emotional flow that builds toward the strongest images.

Print product recommendation is where the real revenue lift happens. The agent evaluates each image's characteristics and recommends specific products: landscape-oriented images with strong symmetry become canvas gallery wraps, tight portrait crops with shallow depth of field become metal prints, and sequences of 3-5 thematically connected images become wall collection proposals. By presenting specific, visualized product suggestions rather than a generic price list, photographers see 40-70% higher print revenue per session.

Upsell automation extends beyond initial delivery. The agent tracks which images clients favorite, which they download, and which they share on social media. It uses this engagement data to trigger targeted follow-ups: a client who favorites 8 images from a family session but only orders 3 prints receives a curated bundle offer a week later. Watermark management ensures that social media shares maintain brand visibility while delivered files are clean. Delivery tracking confirms the client has accessed the gallery and alerts the photographer when engagement drops off, signaling it is time for a personal touch.

from dataclasses import dataclass, field
from typing import List, Dict, Tuple, Optional
from datetime import datetime, timedelta
import statistics

@dataclass
class GalleryImage:
    image_id: str
    filename: str
    width_px: int
    height_px: int
    orientation: str          # "landscape", "portrait", "square"
    dominant_colors: List[str]
    avg_luminance: float      # 0-255
    has_faces: bool
    face_count: int
    composition_type: str     # "symmetrical", "rule_of_thirds", "centered"
    emotional_weight: float   # 0-100 (hero shots score high)
    tags: List[str] = field(default_factory=list)

@dataclass
class PrintProduct:
    product_id: str
    name: str
    min_width_px: int
    min_height_px: int
    price_usd: float
    margin_pct: float
    best_for: List[str]       # ["landscape", "portrait", "group"]

@dataclass
class ClientEngagement:
    image_id: str
    favorited: bool
    downloaded: bool
    shared_social: bool
    view_duration_sec: float
    viewed_at: datetime

class GalleryDeliveryAgent:
    """AI agent for album layout, print recommendations, and upsell automation."""

    ALBUM_SPREAD_COUNT = 15        # typical album pages
    HERO_IMAGE_THRESHOLD = 80      # emotional weight for hero status
    UPSELL_DELAY_DAYS = 7
    ENGAGEMENT_DROP_DAYS = 14

    def __init__(self, products: List[PrintProduct]):
        self.products = products
        self.engagements = {}

    def design_album_layout(self, images: List[GalleryImage],
                             spread_count: int = None) -> List[dict]:
        """Auto-generate album layout with paired images and flow."""
        if not spread_count:
            spread_count = self.ALBUM_SPREAD_COUNT

        # Sort by emotional weight for sequencing
        sorted_images = sorted(images, key=lambda x: -x.emotional_weight)
        heroes = [img for img in sorted_images
                  if img.emotional_weight > self.HERO_IMAGE_THRESHOLD]
        supporting = [img for img in sorted_images
                      if img.emotional_weight <= self.HERO_IMAGE_THRESHOLD]

        spreads = []
        used_images = set()

        # Opening spread: strongest hero image
        if heroes:
            spreads.append({
                "spread_num": 1,
                "layout": "full_bleed_single",
                "images": [heroes[0].image_id],
                "design_note": "Opening hero - full bleed"
            })
            used_images.add(heroes[0].image_id)

        # Build remaining spreads with paired images
        remaining = [img for img in sorted_images
                     if img.image_id not in used_images]

        for i in range(1, spread_count - 1):
            if not remaining:
                break

            primary = remaining.pop(0)
            used_images.add(primary.image_id)

            # Find best pairing partner
            partner = self._find_best_pair(primary, remaining)

            if partner and len(remaining) > spread_count - i:
                remaining.remove(partner)
                used_images.add(partner.image_id)
                layout = self._choose_pair_layout(primary, partner)
                spreads.append({
                    "spread_num": i + 1,
                    "layout": layout,
                    "images": [primary.image_id, partner.image_id],
                    "design_note": f"Paired by {self._pair_reason(primary, partner)}"
                })
            else:
                spreads.append({
                    "spread_num": i + 1,
                    "layout": "single_with_margin",
                    "images": [primary.image_id],
                    "design_note": "Solo feature image"
                })

        # Closing spread: second strongest hero
        closing_hero = next(
            (h for h in heroes if h.image_id not in used_images), None
        )
        if closing_hero:
            spreads.append({
                "spread_num": spread_count,
                "layout": "full_bleed_single",
                "images": [closing_hero.image_id],
                "design_note": "Closing hero - full bleed"
            })

        return {
            "total_spreads": len(spreads),
            "total_images_used": len(used_images),
            "spreads": spreads,
            "unused_images": len(images) - len(used_images)
        }

    def recommend_print_products(self,
                                  images: List[GalleryImage]) -> List[dict]:
        """Recommend specific print products per image."""
        recommendations = []

        for img in images:
            suitable_products = []

            for product in self.products:
                # Resolution check
                if (img.width_px < product.min_width_px or
                        img.height_px < product.min_height_px):
                    continue

                # Style matching
                match_score = 0
                if img.orientation in product.best_for:
                    match_score += 30
                if img.composition_type == "symmetrical" and "canvas" in product.name.lower():
                    match_score += 25
                if img.has_faces and "portrait" in product.best_for:
                    match_score += 20
                if img.emotional_weight > 70:
                    match_score += 15

                if match_score > 20:
                    suitable_products.append({
                        "product": product.name,
                        "price": product.price_usd,
                        "match_score": match_score,
                        "reason": self._product_reason(img, product)
                    })

            suitable_products.sort(key=lambda x: -x["match_score"])
            if suitable_products:
                recommendations.append({
                    "image_id": img.image_id,
                    "top_recommendation": suitable_products[0],
                    "alternatives": suitable_products[1:3]
                })

        return recommendations

    def generate_upsell_campaign(self,
                                  engagements: List[ClientEngagement],
                                  session_total: float) -> dict:
        """Create targeted upsell based on client gallery engagement."""
        favorited = [e for e in engagements if e.favorited]
        downloaded = [e for e in engagements if e.downloaded]
        high_dwell = [e for e in engagements if e.view_duration_sec > 10]

        interested_ids = set(
            e.image_id for e in favorited + high_dwell
        ) - set(e.image_id for e in downloaded)

        if not interested_ids:
            return {"action": "none", "reason": "No engagement signal"}

        bundle_size = min(len(interested_ids), 5)
        discount = 0.15 if bundle_size >= 3 else 0.10

        return {
            "action": "send_bundle_offer",
            "target_images": list(interested_ids)[:bundle_size],
            "bundle_size": bundle_size,
            "suggested_discount_pct": discount * 100,
            "trigger": "favorited_not_purchased",
            "estimated_revenue": round(
                bundle_size * 85 * (1 - discount), 2
            ),
            "send_after_days": self.UPSELL_DELAY_DAYS,
            "message_tone": "personal_recommendation"
        }

    def _find_best_pair(self, primary: GalleryImage,
                         candidates: List[GalleryImage]) -> Optional[GalleryImage]:
        if not candidates:
            return None
        scored = []
        for c in candidates:
            score = 0
            # Tonal contrast (pair light with dark)
            lum_diff = abs(primary.avg_luminance - c.avg_luminance)
            score += min(lum_diff / 2, 30)
            # Orientation complement
            if primary.orientation != c.orientation:
                score += 20
            # Color harmony
            shared_colors = set(primary.dominant_colors) & set(c.dominant_colors)
            score += len(shared_colors) * 10
            scored.append((c, score))
        scored.sort(key=lambda x: -x[1])
        return scored[0][0] if scored[0][1] > 15 else None

    def _choose_pair_layout(self, img1, img2) -> str:
        if img1.orientation == "portrait" and img2.orientation == "portrait":
            return "two_portrait_side_by_side"
        elif img1.orientation == "landscape" and img2.orientation == "landscape":
            return "two_landscape_stacked"
        return "mixed_layout_primary_large"

    def _pair_reason(self, img1, img2) -> str:
        if abs(img1.avg_luminance - img2.avg_luminance) > 60:
            return "tonal contrast"
        shared = set(img1.dominant_colors) & set(img2.dominant_colors)
        if shared:
            return "color harmony"
        return "compositional balance"

    def _product_reason(self, img, product) -> str:
        if "canvas" in product.name.lower() and img.composition_type == "symmetrical":
            return "Symmetrical composition works beautifully on canvas"
        if "metal" in product.name.lower() and img.avg_luminance > 150:
            return "High-contrast image pops on metallic surface"
        return f"Great match for {img.orientation} {product.name}"

4. Pricing & Revenue Optimization

Most photographers set prices once and forget about them, leaving significant revenue on the table. Demand for photography is highly seasonal (wedding season peaks in May-October, family portraits spike in September-November, headshot demand follows corporate hiring cycles) and varies by day of the week. An AI pricing agent implements dynamic pricing that adjusts session fees based on real-time demand signals: calendar saturation, historical booking patterns, competitor pricing, and even local event calendars that drive portrait demand.

Package optimization goes beyond simple price changes. The agent runs continuous A/B testing on package configurations, analyzing which combinations of coverage hours, deliverable counts, album inclusions, and add-ons generate the highest average order value. It detects when a package is consistently chosen as the cheapest option (indicating the mid-tier needs repricing) and when clients consistently upgrade (indicating room for a higher-priced top tier). Competitor price monitoring ensures your positioning remains intentional rather than accidental.

Second-shooter allocation is a revenue decision that most studios handle poorly. The agent calculates whether adding a second shooter at $500-800 cost enables booking an overlapping event at $3,000-5,000, whether the second-shooter fee should be absorbed or passed to the client based on package tier, and how to schedule second shooters across multiple events on peak weekends to maximize studio-wide revenue rather than per-event margin.

from dataclasses import dataclass, field
from typing import List, Dict, Optional, Tuple
from datetime import date, datetime, timedelta
from enum import Enum
import statistics

class Season(Enum):
    PEAK = "peak"          # May-Oct for weddings
    SHOULDER = "shoulder"  # Mar-Apr, Nov
    OFF = "off"            # Dec-Feb

@dataclass
class BookingHistory:
    session_date: date
    session_type: str
    package_price: float
    total_revenue: float     # including prints, albums, add-ons
    day_of_week: int         # 0=Monday, 6=Sunday
    lead_time_days: int      # how far ahead they booked
    competitor_quoted: bool
    second_shooter: bool

@dataclass
class CompetitorPrice:
    competitor_name: str
    session_type: str
    base_price: float
    collected_date: date
    market_tier: str          # "budget", "mid", "premium"

class PricingOptimizationAgent:
    """AI agent for dynamic pricing, package testing, and revenue optimization."""

    PEAK_MULTIPLIER = 1.25
    SHOULDER_MULTIPLIER = 1.0
    OFF_PEAK_MULTIPLIER = 0.85
    WEEKEND_PREMIUM = 1.15
    SHORT_NOTICE_PREMIUM = 1.10   # bookings < 14 days out
    HIGH_DEMAND_THRESHOLD = 0.75  # calendar saturation trigger

    def __init__(self, base_prices: Dict[str, float],
                 calendar_capacity: int = 2):
        self.base_prices = base_prices
        self.calendar_capacity = calendar_capacity
        self.booking_history = []
        self.competitor_data = []

    def calculate_dynamic_price(self, session_type: str,
                                 requested_date: date,
                                 booked_slots: int) -> dict:
        """Calculate session price with all dynamic factors applied."""
        base = self.base_prices.get(session_type, 500)

        # Season factor
        season = self._get_season(requested_date)
        season_mult = {
            Season.PEAK: self.PEAK_MULTIPLIER,
            Season.SHOULDER: self.SHOULDER_MULTIPLIER,
            Season.OFF: self.OFF_PEAK_MULTIPLIER
        }[season]

        # Day-of-week factor
        dow = requested_date.weekday()
        weekend_mult = self.WEEKEND_PREMIUM if dow >= 5 else 1.0

        # Demand factor based on calendar saturation
        saturation = booked_slots / self.calendar_capacity
        demand_mult = 1.0
        if saturation >= self.HIGH_DEMAND_THRESHOLD:
            demand_mult = 1.15
        elif saturation >= 0.5:
            demand_mult = 1.05

        # Lead time factor
        days_until = (requested_date - date.today()).days
        notice_mult = self.SHORT_NOTICE_PREMIUM if days_until < 14 else 1.0

        # Calculate final price
        raw_price = base * season_mult * weekend_mult * demand_mult * notice_mult
        final_price = round(raw_price / 25) * 25  # round to nearest $25

        return {
            "session_type": session_type,
            "requested_date": requested_date.isoformat(),
            "base_price": base,
            "season": season.value,
            "factors": {
                "season": round(season_mult, 2),
                "weekend": round(weekend_mult, 2),
                "demand": round(demand_mult, 2),
                "short_notice": round(notice_mult, 2)
            },
            "calendar_saturation": round(saturation * 100, 0),
            "final_price": final_price,
            "price_change_pct": round(
                (final_price - base) / base * 100, 1
            )
        }

    def optimize_packages(self,
                           history: List[BookingHistory]) -> dict:
        """Analyze package performance and suggest improvements."""
        by_type = {}
        for h in history:
            by_type.setdefault(h.session_type, []).append(h)

        recommendations = []
        for session_type, bookings in by_type.items():
            prices = [b.package_price for b in bookings]
            revenues = [b.total_revenue for b in bookings]
            upsell_rate = sum(
                1 for b in bookings if b.total_revenue > b.package_price
            ) / len(bookings) if bookings else 0

            avg_price = statistics.mean(prices)
            avg_revenue = statistics.mean(revenues)
            price_std = statistics.stdev(prices) if len(prices) > 1 else 0

            # Detect pricing issues
            issues = []
            if price_std < avg_price * 0.1:
                issues.append("Low price variance - clients always pick same tier")
            if upsell_rate < 0.3:
                issues.append("Low upsell rate - review add-on pricing")
            if avg_revenue / avg_price > 1.5:
                issues.append("High add-on revenue - consider bundled packages")

            recommendations.append({
                "session_type": session_type,
                "total_bookings": len(bookings),
                "avg_package_price": round(avg_price, 0),
                "avg_total_revenue": round(avg_revenue, 0),
                "upsell_rate_pct": round(upsell_rate * 100, 1),
                "revenue_per_hour": round(
                    avg_revenue / 3, 0   # assume avg 3 hours
                ),
                "issues": issues,
                "suggested_action": self._package_suggestion(
                    avg_price, avg_revenue, upsell_rate, price_std
                )
            })

        return {"package_analysis": recommendations}

    def allocate_second_shooters(self, weekend_bookings: List[dict],
                                  second_shooter_cost: float = 600,
                                  max_shooters: int = 2) -> dict:
        """Optimize second-shooter allocation for maximum revenue."""
        # Sort by potential revenue if second shooter frees primary
        opportunities = []

        for booking in weekend_bookings:
            if booking.get("needs_second"):
                revenue_if_freed = booking.get("overlap_revenue", 0)
                net_gain = revenue_if_freed - second_shooter_cost
                opportunities.append({
                    "booking_id": booking["id"],
                    "event_date": booking["date"],
                    "primary_revenue": booking["price"],
                    "overlap_revenue": revenue_if_freed,
                    "second_shooter_cost": second_shooter_cost,
                    "net_gain": net_gain,
                    "recommend_second": net_gain > 0
                })

        opportunities.sort(key=lambda x: -x["net_gain"])
        allocated = opportunities[:max_shooters]

        total_cost = sum(
            o["second_shooter_cost"] for o in allocated if o["recommend_second"]
        )
        total_gained = sum(
            o["overlap_revenue"] for o in allocated if o["recommend_second"]
        )

        return {
            "allocations": allocated,
            "total_second_shooter_cost": total_cost,
            "total_additional_revenue": total_gained,
            "net_revenue_gain": total_gained - total_cost,
            "shooters_allocated": sum(
                1 for o in allocated if o["recommend_second"]
            )
        }

    def revenue_forecast(self, history: List[BookingHistory],
                          months_ahead: int = 3) -> dict:
        """Forecast revenue based on historical patterns."""
        monthly = {}
        for h in history:
            key = h.session_date.strftime("%Y-%m")
            monthly.setdefault(key, []).append(h.total_revenue)

        monthly_totals = {k: sum(v) for k, v in monthly.items()}
        monthly_counts = {k: len(v) for k, v in monthly.items()}

        if len(monthly_totals) < 3:
            return {"forecast": "Insufficient history", "confidence": "low"}

        avg_monthly = statistics.mean(monthly_totals.values())
        recent_3 = list(monthly_totals.values())[-3:]
        trend = (statistics.mean(recent_3) - avg_monthly) / avg_monthly

        forecasts = []
        for i in range(1, months_ahead + 1):
            future_month = (date.today().month + i - 1) % 12 + 1
            season = self._month_season(future_month)
            season_factor = {
                Season.PEAK: 1.3, Season.SHOULDER: 1.0, Season.OFF: 0.7
            }[season]

            projected = avg_monthly * season_factor * (1 + trend)
            forecasts.append({
                "month": future_month,
                "season": season.value,
                "projected_revenue": round(projected, 0),
                "projected_sessions": round(
                    statistics.mean(monthly_counts.values()) * season_factor, 0
                )
            })

        return {
            "monthly_average": round(avg_monthly, 0),
            "trend_pct": round(trend * 100, 1),
            "forecasts": forecasts,
            "confidence": "medium" if len(monthly_totals) > 6 else "low"
        }

    def _get_season(self, d: date) -> Season:
        return self._month_season(d.month)

    def _month_season(self, month: int) -> Season:
        if month in (5, 6, 7, 8, 9, 10):
            return Season.PEAK
        elif month in (3, 4, 11):
            return Season.SHOULDER
        return Season.OFF

    def _package_suggestion(self, avg_price, avg_revenue,
                             upsell_rate, price_std) -> str:
        if avg_revenue > avg_price * 1.4:
            return "Create premium all-inclusive package at current avg revenue level"
        if upsell_rate < 0.2:
            return "Lower add-on prices or bundle popular add-ons into mid-tier"
        if price_std < avg_price * 0.08:
            return "Increase price gap between tiers to drive mid-tier selection"
        return "Current package structure performing well - monitor quarterly"

5. Marketing & Social Media

A photography business lives and dies by its portfolio visibility. The challenge is not taking great photos but consistently selecting, formatting, and publishing the right images across the right platforms at the right times. An AI marketing agent automates the entire pipeline from portfolio curation through social media scheduling, SEO optimization, and email campaign management. It selects the statistically strongest images from each session based on engagement prediction models trained on your historical social media performance.

Platform-specific optimization is critical and tedious to do manually. Instagram requires square or 4:5 crops, Twitter/X performs better with 16:9 images, Pinterest demands vertical compositions, and Google Business Profile photos need to be high-resolution horizontals. The agent automatically generates platform-optimized versions of each selected image, applies appropriate watermarks, writes captions tuned to each platform's algorithm (hashtag strategy for Instagram, conversational hooks for X, keyword-rich descriptions for Pinterest), and schedules posts at optimal engagement windows based on your audience analytics.

Local SEO is the highest-ROI marketing channel for most photography businesses, yet it is consistently underinvested. The agent optimizes your Google Business Profile with fresh images weekly, generates location-specific blog content that targets "[city] wedding photographer" and "[neighborhood] family portraits" search queries, manages review solicitation timing (requesting reviews when client satisfaction is highest, typically 24 hours after gallery delivery), and monitors your local search ranking against competitors. Email marketing ties it together by maintaining segmented client lists and sending styled campaigns for seasonal mini-sessions, portfolio highlights, and referral incentives.

from dataclasses import dataclass, field
from typing import List, Dict, Optional, Tuple
from datetime import datetime, timedelta, date
from enum import Enum
import statistics
import hashlib

class Platform(Enum):
    INSTAGRAM = "instagram"
    TWITTER_X = "twitter_x"
    PINTEREST = "pinterest"
    FACEBOOK = "facebook"
    GOOGLE_BUSINESS = "google_business"

@dataclass
class PortfolioImage:
    image_id: str
    session_type: str
    tags: List[str]
    engagement_score: float      # predicted engagement 0-100
    technical_quality: float     # 0-100
    width: int
    height: int
    has_model_release: bool
    location: str
    shot_date: date

@dataclass
class SocialPost:
    platform: Platform
    image_id: str
    caption: str
    hashtags: List[str]
    crop_spec: Dict[str, int]    # {width, height, x_offset, y_offset}
    scheduled_time: datetime
    status: str = "scheduled"

@dataclass
class EmailCampaign:
    campaign_id: str
    segment: str
    subject: str
    preview_text: str
    featured_images: List[str]
    cta_text: str
    cta_url: str
    send_date: datetime

class MarketingAgent:
    """AI agent for portfolio curation, social media, SEO, and email marketing."""

    PLATFORM_SPECS = {
        Platform.INSTAGRAM: {"aspect": (4, 5), "max_hashtags": 30, "best_hours": [9, 12, 17, 20]},
        Platform.TWITTER_X: {"aspect": (16, 9), "max_hashtags": 3, "best_hours": [8, 12, 17]},
        Platform.PINTEREST: {"aspect": (2, 3), "max_hashtags": 5, "best_hours": [14, 21]},
        Platform.FACEBOOK: {"aspect": (1, 1), "max_hashtags": 5, "best_hours": [10, 13, 16]},
        Platform.GOOGLE_BUSINESS: {"aspect": (16, 9), "max_hashtags": 0, "best_hours": [10]}
    }

    def __init__(self, business_name: str, location: str,
                 session_types: List[str]):
        self.business_name = business_name
        self.location = location
        self.session_types = session_types
        self.post_history = []
        self.portfolio_scores = {}

    def curate_portfolio(self, images: List[PortfolioImage],
                          max_per_category: int = 20) -> dict:
        """Select strongest images for portfolio display."""
        by_category = {}
        for img in images:
            by_category.setdefault(img.session_type, []).append(img)

        curated = {}
        for category, imgs in by_category.items():
            scored = sorted(
                imgs,
                key=lambda x: (x.engagement_score * 0.6 +
                               x.technical_quality * 0.4),
                reverse=True
            )
            # Ensure variety: no more than 3 from same session
            selected = []
            session_counts = {}
            for img in scored:
                session_key = f"{img.location}_{img.shot_date}"
                if session_counts.get(session_key, 0) >= 3:
                    continue
                if not img.has_model_release:
                    continue
                selected.append(img.image_id)
                session_counts[session_key] = session_counts.get(session_key, 0) + 1
                if len(selected) >= max_per_category:
                    break

            curated[category] = {
                "selected": selected,
                "count": len(selected),
                "avg_engagement_score": round(
                    statistics.mean(
                        img.engagement_score for img in imgs
                        if img.image_id in selected
                    ) if selected else 0, 1
                )
            }

        return {
            "total_curated": sum(c["count"] for c in curated.values()),
            "by_category": curated,
            "refresh_date": date.today().isoformat()
        }

    def schedule_social_posts(self, images: List[PortfolioImage],
                                platforms: List[Platform],
                                posts_per_week: int = 5) -> List[dict]:
        """Generate and schedule platform-optimized posts."""
        schedule = []
        post_date = datetime.now() + timedelta(hours=1)

        # Distribute images across platforms and days
        daily_posts = max(1, posts_per_week // 5)
        image_queue = sorted(
            images, key=lambda x: -x.engagement_score
        )

        for i, img in enumerate(image_queue[:posts_per_week * 2]):
            platform = platforms[i % len(platforms)]
            spec = self.PLATFORM_SPECS[platform]

            # Calculate crop for platform aspect ratio
            crop = self._calculate_crop(
                img.width, img.height,
                spec["aspect"][0], spec["aspect"][1]
            )

            # Generate platform-specific caption
            caption = self._generate_caption(img, platform)
            hashtags = self._generate_hashtags(img, platform)

            # Schedule at optimal time
            best_hour = spec["best_hours"][i % len(spec["best_hours"])]
            post_time = post_date.replace(
                hour=best_hour, minute=0, second=0
            ) + timedelta(days=i // daily_posts)

            schedule.append({
                "platform": platform.value,
                "image_id": img.image_id,
                "caption": caption,
                "hashtags": hashtags[:spec["max_hashtags"]],
                "crop": crop,
                "scheduled_time": post_time.isoformat(),
                "predicted_engagement": img.engagement_score
            })

        return schedule

    def generate_local_seo_content(self, session_type: str,
                                     locations: List[str]) -> List[dict]:
        """Generate SEO-optimized content for local search visibility."""
        content_pieces = []

        for location in locations:
            slug = f"{session_type}-photographer-{location}".lower().replace(" ", "-")
            title = f"Best {session_type.title()} Photographer in {location} | {self.business_name}"
            meta_desc = (
                f"Looking for a {session_type} photographer in {location}? "
                f"{self.business_name} delivers stunning {session_type} photography "
                f"with {self._session_usp(session_type)}. Book your session today."
            )

            keywords = [
                f"{session_type} photographer {location}",
                f"{location} {session_type} photography",
                f"best {session_type} photographer near {location}",
                f"affordable {session_type} photos {location}",
                f"{session_type} photography packages {location}"
            ]

            content_pieces.append({
                "slug": slug,
                "title": title,
                "meta_description": meta_desc,
                "target_keywords": keywords,
                "content_sections": [
                    f"Why Choose {self.business_name} for {session_type.title()} Photography",
                    f"Our {session_type.title()} Photography Packages",
                    f"Popular {session_type.title()} Locations in {location}",
                    f"What to Expect at Your {session_type.title()} Session",
                    "Client Reviews and Testimonials"
                ],
                "internal_links": [
                    f"/portfolio/{session_type}",
                    "/booking",
                    "/reviews"
                ],
                "schema_type": "LocalBusiness"
            })

        return content_pieces

    def plan_email_campaign(self, segment: str,
                             campaign_type: str,
                             featured_images: List[str]) -> dict:
        """Design targeted email campaign for client segment."""
        templates = {
            "mini_session": {
                "subject": f"Limited spots: Fall Mini Sessions are here!",
                "preview": "15-minute sessions, 10 edited images, special pricing",
                "cta": "Book Your Mini Session",
                "urgency": True
            },
            "portfolio_highlight": {
                "subject": f"New work: See our latest {segment} sessions",
                "preview": "Fresh portfolio updates you will love",
                "cta": "View Full Portfolio",
                "urgency": False
            },
            "referral": {
                "subject": "Give $100, Get $100 — Refer a Friend",
                "preview": "Share the love and save on your next session",
                "cta": "Share Your Referral Link",
                "urgency": False
            },
            "reengagement": {
                "subject": f"It has been a while! Time for new family photos?",
                "preview": "Your family has grown — let us capture the new chapter",
                "cta": "Book Your Session",
                "urgency": False
            }
        }

        template = templates.get(campaign_type, templates["portfolio_highlight"])

        return {
            "campaign_type": campaign_type,
            "segment": segment,
            "subject": template["subject"],
            "preview_text": template["preview"],
            "featured_images": featured_images[:4],
            "cta_text": template["cta"],
            "cta_url": "/booking",
            "send_timing": "tuesday_10am" if not template["urgency"] else "immediate",
            "estimated_open_rate": 0.35 if segment == "past_clients" else 0.22,
            "a_b_test": {
                "variant_a_subject": template["subject"],
                "variant_b_subject": template["subject"].replace("!", ""),
                "test_pct": 20
            }
        }

    def _calculate_crop(self, w: int, h: int,
                         target_w: int, target_h: int) -> dict:
        target_ratio = target_w / target_h
        current_ratio = w / h
        if current_ratio > target_ratio:
            new_w = int(h * target_ratio)
            return {"width": new_w, "height": h,
                    "x_offset": (w - new_w) // 2, "y_offset": 0}
        else:
            new_h = int(w / target_ratio)
            return {"width": w, "height": new_h,
                    "x_offset": 0, "y_offset": (h - new_h) // 2}

    def _generate_caption(self, img: PortfolioImage,
                           platform: Platform) -> str:
        if platform == Platform.INSTAGRAM:
            return (f"Loved capturing this {img.session_type} session "
                    f"in {img.location}. Every moment tells a story.")
        elif platform == Platform.TWITTER_X:
            return (f"New {img.session_type} session from {img.location}. "
                    f"Bookings open for the season.")
        elif platform == Platform.PINTEREST:
            return (f"{img.session_type.title()} Photography Inspiration | "
                    f"{img.location} | {self.business_name}")
        return f"Beautiful {img.session_type} session in {img.location}"

    def _generate_hashtags(self, img: PortfolioImage,
                            platform: Platform) -> List[str]:
        base = [
            f"#{img.session_type}photographer",
            f"#{img.location.replace(' ', '')}photographer",
            f"#{img.session_type}photography",
            f"#{self.business_name.lower().replace(' ', '')}"
        ]
        if platform == Platform.INSTAGRAM:
            base.extend([
                f"#{img.location.replace(' ', '')}",
                "#photographylovers",
                "#portraitphotography",
                f"#{img.session_type}session"
            ])
        return base

    def _session_usp(self, session_type: str) -> str:
        usps = {
            "wedding": "full-day coverage and cinematic storytelling",
            "portrait": "natural light portraits that capture your personality",
            "family": "relaxed family sessions the kids actually enjoy",
            "newborn": "safe, gentle newborn sessions in our cozy studio"
        }
        return usps.get(session_type, "professional results you will treasure")

6. ROI Analysis: 500-Session Photography Business

The bottom-line question for any photography studio is: what does AI agent automation actually return? Below is a detailed breakdown for a mid-size portrait and wedding studio handling 500 sessions per year across two photographers, with a current average session revenue of $1,800 and annual gross revenue of approximately $900,000.

Assumptions

• 500 sessions per year (350 portrait/family, 100 weddings, 50 commercial)
• Average 4 hours editing per portrait session, 20 hours per wedding
• Current average print/product revenue: $180 per session
• Inquiry-to-booking conversion rate: 35%
• Average hourly value of photographer time: $150
• Current marketing spend: $12,000/year

Implementation Cost vs. Return

from dataclasses import dataclass

@dataclass
class PhotographyROIModel:
    """Calculate ROI for AI agent deployment in a photography business."""

    sessions_per_year: int = 500
    portrait_sessions: int = 350
    wedding_sessions: int = 100
    commercial_sessions: int = 50
    avg_session_revenue: float = 1800
    edit_hours_portrait: float = 4
    edit_hours_wedding: float = 20
    photographer_hourly_value: float = 150
    current_print_revenue: float = 180
    current_conversion_rate: float = 0.35
    current_marketing_spend: float = 12000

    def calculate_editing_savings(self, ai_reduction_pct: float = 0.70) -> dict:
        """Time saved on culling and editing with AI automation."""
        total_edit_hours = (
            self.portrait_sessions * self.edit_hours_portrait
            + self.wedding_sessions * self.edit_hours_wedding
            + self.commercial_sessions * 6
        )
        hours_saved = total_edit_hours * ai_reduction_pct
        value_saved = hours_saved * self.photographer_hourly_value

        return {
            "current_annual_edit_hours": round(total_edit_hours, 0),
            "hours_saved": round(hours_saved, 0),
            "value_of_time_saved": round(value_saved, 0),
            "hours_per_week_freed": round(hours_saved / 50, 1),
            "extra_sessions_possible": round(hours_saved / 6, 0)
        }

    def calculate_booking_improvement(self,
                                       new_conversion_rate: float = 0.55) -> dict:
        """Revenue from improved inquiry-to-booking conversion."""
        current_inquiries = self.sessions_per_year / self.current_conversion_rate
        new_bookings = current_inquiries * new_conversion_rate
        additional_sessions = new_bookings - self.sessions_per_year
        additional_revenue = additional_sessions * self.avg_session_revenue

        return {
            "current_inquiries": round(current_inquiries, 0),
            "current_bookings": self.sessions_per_year,
            "projected_bookings": round(new_bookings, 0),
            "additional_sessions": round(additional_sessions, 0),
            "additional_revenue": round(additional_revenue, 0),
            "conversion_lift_pct": round(
                (new_conversion_rate - self.current_conversion_rate) * 100, 0
            )
        }

    def calculate_print_revenue_lift(self,
                                      new_print_avg: float = 450) -> dict:
        """Revenue increase from AI-driven product recommendations."""
        current_total = self.current_print_revenue * self.sessions_per_year
        new_total = new_print_avg * self.sessions_per_year
        lift = new_total - current_total

        return {
            "current_print_revenue_per_session": self.current_print_revenue,
            "projected_print_revenue_per_session": new_print_avg,
            "current_annual_print_revenue": round(current_total, 0),
            "projected_annual_print_revenue": round(new_total, 0),
            "annual_lift": round(lift, 0),
            "lift_pct": round((lift / current_total) * 100, 0)
        }

    def calculate_pricing_optimization(self,
                                        revenue_lift_pct: float = 0.15) -> dict:
        """Revenue from dynamic pricing and package optimization."""
        current_session_revenue = (
            self.avg_session_revenue * self.sessions_per_year
        )
        additional = current_session_revenue * revenue_lift_pct

        return {
            "current_session_revenue": round(current_session_revenue, 0),
            "dynamic_pricing_lift_pct": round(revenue_lift_pct * 100, 0),
            "additional_revenue": round(additional, 0),
            "new_avg_session_price": round(
                self.avg_session_revenue * (1 + revenue_lift_pct), 0
            )
        }

    def full_roi_analysis(self) -> dict:
        """Complete ROI model for photography AI agent deployment."""
        editing = self.calculate_editing_savings()
        booking = self.calculate_booking_improvement()
        prints = self.calculate_print_revenue_lift()
        pricing = self.calculate_pricing_optimization()

        # Implementation costs
        software_annual = 3600       # AI editing tools + CRM
        setup_integration = 2000     # initial setup and training
        marketing_tools = 1800       # social scheduling + SEO tools
        total_annual_cost = software_annual + marketing_tools
        total_year1_cost = total_annual_cost + setup_integration

        total_annual_benefit = (
            editing["value_of_time_saved"]
            + booking["additional_revenue"]
            + prints["annual_lift"]
            + pricing["additional_revenue"]
        )

        roi_year1 = (
            (total_annual_benefit - total_year1_cost) / total_year1_cost
        ) * 100
        payback_days = (total_year1_cost / total_annual_benefit) * 365

        return {
            "business_profile": {
                "sessions_per_year": self.sessions_per_year,
                "current_revenue": round(
                    self.avg_session_revenue * self.sessions_per_year, 0
                )
            },
            "annual_benefits": {
                "editing_time_saved": editing["value_of_time_saved"],
                "booking_conversion": booking["additional_revenue"],
                "print_revenue_lift": prints["annual_lift"],
                "pricing_optimization": pricing["additional_revenue"],
                "total": round(total_annual_benefit, 0)
            },
            "costs": {
                "year_1_total": total_year1_cost,
                "annual_recurring": total_annual_cost
            },
            "returns": {
                "roi_year_1_pct": round(roi_year1, 0),
                "payback_days": round(payback_days, 0),
                "net_benefit_year_1": round(
                    total_annual_benefit - total_year1_cost, 0
                ),
                "hours_freed_per_week": editing["hours_per_week_freed"]
            }
        }

# Run the analysis
model = PhotographyROIModel(sessions_per_year=500)
results = model.full_roi_analysis()

print(f"Business: {results['business_profile']['sessions_per_year']} sessions/year")
print(f"Current Revenue: ${results['business_profile']['current_revenue']:,.0f}")
print(f"Total Annual Benefits: ${results['annual_benefits']['total']:,.0f}")
print(f"Year 1 Cost: ${results['costs']['year_1_total']:,.0f}")
print(f"Year 1 ROI: {results['returns']['roi_year_1_pct']}%")
print(f"Payback Period: {results['returns']['payback_days']} days")
print(f"Hours Freed Per Week: {results['returns']['hours_freed_per_week']}")

Getting Started: Implementation Roadmap

You do not need to automate everything at once. Start with the highest-impact module and expand as each layer proves its value:

1. Week 1-2: AI culling and editing. Integrate an AI culling tool into your Lightroom workflow. Import your style presets as training data. Process 5 sessions side-by-side (manual vs AI) to calibrate quality thresholds and build confidence in the output.
2. Week 3-4: Automated inquiry response. Connect your contact form to the booking agent. Set up package recommendations, availability checking, and contract generation. Monitor responses for 2 weeks before going fully autonomous.
3. Month 2: Gallery delivery and upsell. Implement product recommendations in your delivery platform. Set up engagement tracking and automated follow-up campaigns. A/B test bundle offers against your current approach.
4. Month 3: Dynamic pricing and marketing. Analyze 12 months of booking data to establish seasonal patterns. Activate dynamic pricing for new inquiries. Launch platform-specific social media scheduling and local SEO content.
5. Month 4+: Optimization and scaling. Review all agent performance metrics. Fine-tune pricing models, editing presets, and upsell triggers based on accumulated data. Consider expanding capacity with second-shooter optimization.

The photographers who thrive in 2026 are not the ones who resist technology or adopt it blindly. They are the ones who use AI agents to eliminate the work they hate (culling, emailing, invoicing) so they can spend more time on the work they love (shooting, creative direction, client relationships). The business grows because the bottleneck shifts from administrative overhead to creative capacity.