AI Agent for Performance Reviews: Self-Assessment Assistance and Goal Tracking

The Performance Review Challenge

Performance reviews are universally disliked yet remain essential for growth, alignment, and compensation decisions. The pain points are predictable: employees struggle to recall accomplishments from months ago, managers give generic feedback, and goals set at the beginning of the cycle are forgotten until review time. An AI performance review agent addresses each of these by continuously tracking goals, prompting for progress updates, and helping craft specific, evidence-based self-assessments.

Goal Management Data Model

The foundation of effective performance reviews is a well-structured goal tracking system. Each goal has measurable outcomes, milestones, and progress history.

flowchart LR
    INPUT(["User intent"])
    PARSE["Parse plus<br/>classify"]
    PLAN["Plan and tool<br/>selection"]
    AGENT["Agent loop<br/>LLM plus tools"]
    GUARD{"Guardrails<br/>and policy"}
    EXEC["Execute and<br/>verify result"]
    OBS[("Trace and metrics")]
    OUT(["Outcome plus<br/>next action"])
    INPUT --> PARSE --> PLAN --> AGENT --> GUARD
    GUARD -->|Pass| EXEC --> OUT
    GUARD -->|Fail| AGENT
    AGENT --> OBS
    style AGENT fill:#4f46e5,stroke:#4338ca,color:#fff
    style GUARD fill:#f59e0b,stroke:#d97706,color:#1f2937
    style OBS fill:#ede9fe,stroke:#7c3aed,color:#1e1b4b
    style OUT fill:#059669,stroke:#047857,color:#fff

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 GoalStatus(Enum):
    NOT_STARTED = "not_started"
    ON_TRACK = "on_track"
    AT_RISK = "at_risk"
    COMPLETED = "completed"
    DEFERRED = "deferred"

@dataclass
class Goal:
    goal_id: str
    employee_id: str
    title: str
    description: str
    category: str  # "performance", "development", "stretch"
    key_results: list[str]
    target_date: date
    status: GoalStatus = GoalStatus.NOT_STARTED
    progress_percent: int = 0
    updates: list[dict] = field(default_factory=list)

@dataclass
class ReviewCycle:
    cycle_id: str
    name: str  # "H1 2026", "Annual 2026"
    start_date: date
    end_date: date
    self_assessment_due: date
    manager_review_due: date
    peer_feedback_due: date

GOALS_DB: dict[str, list[Goal]] = {}

Goal Tracking Tools

@function_tool
def get_employee_goals(employee_id: str, cycle: str = "") -> str:
    """Retrieve all goals for an employee, optionally filtered by review cycle."""
    goals = GOALS_DB.get(employee_id, [])
    if not goals:
        return json.dumps({"message": "No goals found. Consider setting goals with your manager."})

    result = []
    for g in goals:
        result.append({
            "goal_id": g.goal_id,
            "title": g.title,
            "category": g.category,
            "status": g.status.value,
            "progress": f"{g.progress_percent}%",
            "key_results": g.key_results,
            "target_date": str(g.target_date),
            "recent_updates": g.updates[-3:] if g.updates else [],
        })
    return json.dumps(result)

@function_tool
def update_goal_progress(
    employee_id: str,
    goal_id: str,
    progress_percent: int,
    update_note: str,
) -> str:
    """Log a progress update for a specific goal."""
    goals = GOALS_DB.get(employee_id, [])
    target_goal = next((g for g in goals if g.goal_id == goal_id), None)

    if not target_goal:
        return json.dumps({"error": "Goal not found"})

    target_goal.progress_percent = min(progress_percent, 100)
    if progress_percent >= 100:
        target_goal.status = GoalStatus.COMPLETED
    elif progress_percent > 0:
        target_goal.status = GoalStatus.ON_TRACK

    target_goal.updates.append({
        "date": str(date.today()),
        "progress": progress_percent,
        "note": update_note,
    })

    return json.dumps({
        "status": "updated",
        "goal": target_goal.title,
        "new_progress": f"{progress_percent}%",
    })

Self-Assessment Generator

The most valuable tool helps employees draft their self-assessments by pulling from their goal progress, accomplishments logged throughout the cycle, and structured prompts.

@function_tool
def generate_self_assessment_draft(employee_id: str) -> str:
    """Generate a self-assessment draft based on goal progress and updates."""
    goals = GOALS_DB.get(employee_id, [])
    if not goals:
        return json.dumps({"error": "No goals found to base assessment on"})

    sections = []

    # Accomplishments section
    completed = [g for g in goals if g.status == GoalStatus.COMPLETED]
    if completed:
        accomplishments = []
        for g in completed:
            evidence = " ".join(u["note"] for u in g.updates[-3:])
            accomplishments.append(
                f"- {g.title}: {evidence}" if evidence
                else f"- {g.title}: Completed successfully"
            )
        sections.append({
            "heading": "Key Accomplishments",
            "content": "\n".join(accomplishments),
        })

    # In-progress goals
    in_progress = [g for g in goals if g.status in (
        GoalStatus.ON_TRACK, GoalStatus.AT_RISK
    )]
    if in_progress:
        progress_items = [
            f"- {g.title} ({g.progress_percent}% complete): "
            f"{g.updates[-1]['note'] if g.updates else 'In progress'}"
            for g in in_progress
        ]
        sections.append({
            "heading": "Ongoing Work",
            "content": "\n".join(progress_items),
        })

    # Development areas
    dev_goals = [g for g in goals if g.category == "development"]
    if dev_goals:
        dev_items = [f"- {g.title}: {g.key_results[0]}" for g in dev_goals if g.key_results]
        sections.append({
            "heading": "Growth and Development",
            "content": "\n".join(dev_items),
        })

    return json.dumps({
        "draft_sections": sections,
        "note": "This is a starting draft. Add specific metrics, "
                "stakeholder feedback, and personal reflections.",
    })

Feedback Collection Tool

@function_tool
def request_peer_feedback(
    employee_id: str,
    peer_ids: list[str],
    focus_areas: list[str],
) -> str:
    """Send peer feedback requests for a performance review."""
    if len(peer_ids) < 2:
        return json.dumps({"error": "Minimum 2 peers required for 360 feedback"})
    if len(peer_ids) > 6:
        return json.dumps({"error": "Maximum 6 peer reviewers allowed"})

    return json.dumps({
        "status": "sent",
        "peers_notified": len(peer_ids),
        "focus_areas": focus_areas,
        "deadline": str(date.today() + timedelta(days=7)),
    })

from datetime import timedelta

review_agent = Agent(
    name="ReviewBot",
    instructions="""You are ReviewBot, a performance review assistant.
Help employees track goals, log progress, and prepare self-assessments.
When drafting assessments, emphasize specific outcomes and metrics.
Encourage employees to include challenges faced and lessons learned.
Never compare employees to each other or share others' review data.""",
    tools=[
        get_employee_goals, update_goal_progress,
        generate_self_assessment_draft, request_peer_feedback,
    ],
)

FAQ

How does the agent help employees who struggle to write about themselves?

The agent generates structured drafts using data from goal updates logged throughout the cycle. It prompts employees with specific questions: "What metrics improved?", "Who did you collaborate with?", "What was the biggest challenge?" This transforms the blank-page problem into a guided conversation.

Can the agent detect when goals need to be adjusted mid-cycle?

Yes. When progress updates show consistently low advancement or the employee marks a goal as "at risk," the agent can suggest a check-in with the manager. It can also flag goals whose target dates have passed without completion, prompting a conversation about whether to extend, descope, or defer.

How do you maintain confidentiality across manager and employee views?

The agent enforces role-based access. An employee can only see their own goals and self-assessment. A manager can see their direct reports' goals and progress but not other managers' teams. Peer feedback is anonymized before presentation. These access controls are enforced at the tool level, not just in the instructions.

#PerformanceReviews #GoalTracking #SelfAssessment #HRTech #AgenticAI #LearnAI #AIEngineering