AI Agent for Exit Interviews: Structured Departure Conversations and Analysis

Why AI Makes Exit Interviews Better

Exit interviews are one of the most underutilized feedback channels in HR. When conducted by a manager or HR representative, departing employees often self-censor — they do not want to burn bridges. An AI agent provides psychological safety: employees are more candid with a non-judgmental system that cannot retaliate or gossip. Research shows that AI-facilitated exit interviews yield 40% more actionable feedback compared to traditional face-to-face formats.

The other problem is analysis. Most organizations conduct exit interviews but never aggregate the data into actionable patterns. Individual exit interviews sit in filing cabinets or email threads. An agentic system captures structured data from every conversation and continuously surfaces trends.

Exit Interview Data Model

from dataclasses import dataclass, field
from datetime import date
from typing import Optional
from enum import Enum
from agents import Agent, Runner, function_tool
import json

class DepartureReason(Enum):
    COMPENSATION = "compensation"
    CAREER_GROWTH = "career_growth"
    MANAGEMENT = "management"
    WORK_LIFE_BALANCE = "work_life_balance"
    CULTURE = "culture"
    RELOCATION = "relocation"
    RETIREMENT = "retirement"
    OTHER = "other"

@dataclass
class ExitInterviewResponse:
    interview_id: str
    employee_id: str
    department: str
    role: str
    tenure_years: float
    departure_date: date
    primary_reason: DepartureReason
    secondary_reasons: list[DepartureReason] = field(default_factory=list)
    satisfaction_scores: dict[str, int] = field(default_factory=dict)
    open_responses: dict[str, str] = field(default_factory=dict)
    would_recommend: bool = False
    would_return: bool = False
    completed: bool = False

EXIT_INTERVIEWS_DB: dict[str, ExitInterviewResponse] = {}

Structured Interview Tool

The interview tool guides the conversation through a consistent set of topics while allowing natural follow-ups. Each section collects both quantitative scores and qualitative commentary.

INTERVIEW_SECTIONS = [
    {
        "section": "overall_experience",
        "question": "On a scale of 1-5, how would you rate your overall experience at the company?",
        "follow_up": "What contributed most to that rating?",
        "score_key": "overall",
    },
    {
        "section": "management",
        "question": "On a scale of 1-5, how would you rate your relationship with your direct manager?",
        "follow_up": "What could your manager have done differently?",
        "score_key": "management",
    },
    {
        "section": "growth",
        "question": "On a scale of 1-5, how satisfied were you with career growth opportunities?",
        "follow_up": "Were there specific roles or opportunities you wished were available?",
        "score_key": "career_growth",
    },
    {
        "section": "compensation",
        "question": "On a scale of 1-5, how fair did you feel your compensation was relative to your contributions?",
        "follow_up": "Was compensation a factor in your decision to leave?",
        "score_key": "compensation",
    },
    {
        "section": "culture",
        "question": "On a scale of 1-5, how well did the company culture align with your values?",
        "follow_up": "What aspects of the culture would you change?",
        "score_key": "culture",
    },
]

@function_tool
def get_interview_questions(section_index: int = 0) -> str:
    """Get the next exit interview section questions."""
    if section_index >= len(INTERVIEW_SECTIONS):
        return json.dumps({
            "status": "complete",
            "message": "All sections covered. Thank you for your candid feedback.",
        })

    section = INTERVIEW_SECTIONS[section_index]
    return json.dumps({
        "section": section["section"],
        "question": section["question"],
        "follow_up": section["follow_up"],
        "progress": f"{section_index + 1}/{len(INTERVIEW_SECTIONS)}",
    })

@function_tool
def record_interview_response(
    interview_id: str,
    section: str,
    score: int,
    comments: str,
) -> str:
    """Record a scored response for an exit interview section."""
    interview = EXIT_INTERVIEWS_DB.get(interview_id)
    if not interview:
        return json.dumps({"error": "Interview not found"})

    if score < 1 or score > 5:
        return json.dumps({"error": "Score must be between 1 and 5"})

    interview.satisfaction_scores[section] = score
    interview.open_responses[section] = comments

    return json.dumps({
        "status": "recorded",
        "section": section,
        "score": score,
    })

Departure Reason Classification

@function_tool
def classify_departure_reason(
    interview_id: str,
    primary_reason: str,
    secondary_reasons: list[str] = [],
) -> str:
    """Classify the primary and secondary reasons for departure."""
    interview = EXIT_INTERVIEWS_DB.get(interview_id)
    if not interview:
        return json.dumps({"error": "Interview not found"})

    valid_reasons = {r.value: r for r in DepartureReason}
    if primary_reason not in valid_reasons:
        return json.dumps({
            "error": f"Invalid reason. Options: {list(valid_reasons.keys())}"
        })

    interview.primary_reason = valid_reasons[primary_reason]
    interview.secondary_reasons = [
        valid_reasons[r] for r in secondary_reasons if r in valid_reasons
    ]

    return json.dumps({
        "status": "classified",
        "primary": primary_reason,
        "secondary": secondary_reasons,
    })

Trend Analysis Tool

The analysis tool aggregates exit interview data to surface patterns across departments, tenure bands, and time periods.

@function_tool
def analyze_exit_trends(
    department: str = "",
    months_back: int = 12,
) -> str:
    """Analyze exit interview trends across the organization or a specific department."""
    interviews = list(EXIT_INTERVIEWS_DB.values())

    if department:
        interviews = [i for i in interviews if i.department.lower() == department.lower()]

    if not interviews:
        return json.dumps({"message": "No exit interviews found for the specified criteria"})

    # Departure reason distribution
    reason_counts: dict[str, int] = {}
    for interview in interviews:
        reason = interview.primary_reason.value
        reason_counts[reason] = reason_counts.get(reason, 0) + 1

    # Average satisfaction scores
    score_totals: dict[str, list[int]] = {}
    for interview in interviews:
        for section, score in interview.satisfaction_scores.items():
            score_totals.setdefault(section, []).append(score)

    avg_scores = {
        section: round(sum(scores) / len(scores), 2)
        for section, scores in score_totals.items()
    }

    # Tenure analysis
    tenure_groups = {"<1 year": 0, "1-3 years": 0, "3-5 years": 0, "5+ years": 0}
    for interview in interviews:
        if interview.tenure_years < 1:
            tenure_groups["<1 year"] += 1
        elif interview.tenure_years < 3:
            tenure_groups["1-3 years"] += 1
        elif interview.tenure_years < 5:
            tenure_groups["3-5 years"] += 1
        else:
            tenure_groups["5+ years"] += 1

    # Retention risk indicators
    recommend_rate = sum(1 for i in interviews if i.would_recommend) / max(len(interviews), 1)
    return_rate = sum(1 for i in interviews if i.would_return) / max(len(interviews), 1)

    sorted_reasons = sorted(reason_counts.items(), key=lambda x: x[1], reverse=True)

    return json.dumps({
        "total_departures": len(interviews),
        "department": department or "All",
        "top_departure_reasons": [
            {"reason": r, "count": c, "percentage": f"{c / len(interviews) * 100:.0f}%"}
            for r, c in sorted_reasons
        ],
        "average_satisfaction": avg_scores,
        "tenure_distribution": tenure_groups,
        "would_recommend_pct": f"{recommend_rate * 100:.0f}%",
        "would_return_pct": f"{return_rate * 100:.0f}%",
        "key_insight": (
            f"Top departure reason is '{sorted_reasons[0][0]}' "
            f"accounting for {sorted_reasons[0][1]} of {len(interviews)} departures. "
            f"Average overall satisfaction: {avg_scores.get('overall', 'N/A')}/5."
            if sorted_reasons else "Insufficient data for insights"
        ),
    })

exit_interview_agent = Agent(
    name="ExitBot",
    instructions="""You are ExitBot, an exit interview facilitator.
Guide departing employees through a structured exit interview.
Be empathetic and non-judgmental. Assure the employee their feedback is confidential.
Ask follow-up questions to understand the root causes behind their scores.
Never try to convince the employee to stay — focus on gathering honest feedback.
After the interview, classify the departure reason and record all responses.""",
    tools=[
        get_interview_questions, record_interview_response,
        classify_departure_reason, analyze_exit_trends,
    ],
)

FAQ

How do you ensure departing employees give honest feedback to an AI?

The agent establishes trust at the start by explaining that responses are anonymized before being shared with management and that no individual response is attributed to a specific person in trend reports. The conversational format also helps — employees share more in a dialogue than on a static form.

What do you do with the trend data?

The trend analysis tool surfaces actionable patterns: "Engineering has lost 8 people in the last quarter, with 6 citing career growth as the primary reason. Average management satisfaction in engineering is 2.3/5." This level of specificity enables targeted interventions rather than broad, unfocused retention programs.

Should exit interviews happen before or after the last day?

Conduct the structured interview during the notice period, ideally in the final week but before the last day. Employees who have already mentally moved on are more candid than those still negotiating their departure. The agent can follow up with a brief post-departure survey 30 days later to capture reflections after the emotional intensity has faded.

---

#ExitInterviews #EmployeeRetention #TurnoverAnalysis #HRAnalytics #AgenticAI #LearnAI #AIEngineering