Maximum Achievable Score in Hiring-Agent: How the 120-Point Cap Works

The hiring-agent evaluator caps all candidate assessments at 120 points (100 category points plus 20 bonus points), enforcing per-category limits via min() checks in score.py before applying an overall ceiling that allows deductions but prevents exceeding the maximum.

The interviewstreet/hiring-agent repository implements a structured resume evaluation pipeline that calculates candidate performance across four distinct dimensions. Understanding the maximum achievable score and its capping mechanism is critical for recruiters interpreting evaluation results, as the system implements strict enforcement at both the category level and the final aggregate to ensure scoring consistency.

Scoring Breakdown: From Categories to Maximum Total

The evaluator calculates scores from four weighted categories with defined maximums:

• Open Source: 35 points maximum
• Self Projects: 30 points maximum
• Production Experience: 25 points maximum
• Technical Skills: 10 points maximum

This creates a category subtotal of 100 points. The system then allows bonus points up to 20, yielding a maximum achievable score of 120 points regardless of raw AI-generated assessments.

Two-Level Capping Implementation

The capping mechanism operates at two distinct stages within the evaluation pipeline, as implemented in score.py.

Per-Category Score Limits

Each category score is independently constrained to its defined maximum before aggregation. In the print_evaluation_results function, the code enforces this using min(category_data["score"], category_data["max"]) at lines 45-50:

# From score.py, lines 45-50

capped_score = min(category_data["score"], category_data["max"])

This ensures that even if the AI evaluator assigns higher values (e.g., 40 points for Open Source), the stored and displayed value cannot exceed the 35-point limit for that category.

Overall Score Ceiling

After summing the capped category scores, the system adds bonus points and subtracts deductions, then compares the result against the absolute maximum. Located at lines 65-70 in score.py, the logic checks against max_score + 20 (where max_score equals the 100-point category total):

# Conceptual implementation from score.py, lines 65-70

if total_score > max_score + 20:
    total_score = max_score + 20
    print("Warning: Total score capped at maximum possible value")

Deductions are always subtracted from the total after bonus addition, meaning they reduce the final score but cannot be used to argue for a higher cap.

Practical Score Calculation Examples

When working with the scoring models directly, raw AI scores that exceed category limits are automatically restrained:

from models import CategoryScore, Scores, BonusPoints, Deductions, EvaluationData

# Raw AI scores that exceed category maximums

raw_scores = Scores(
    open_source=CategoryScore(score=40, max=35, evidence="..."),
    self_projects=CategoryScore(score=32, max=30, evidence="..."),
    production=CategoryScore(score=27, max=25, evidence="..."),
    technical_skills=CategoryScore(score=12, max=10, evidence="...")
)

bonus = BonusPoints(total=18, breakdown="...")   # Valid: ≤20

deductions = Deductions(total=5, reasons="...")

evaluation = EvaluationData(
    scores=raw_scores,
    bonus_points=bonus,
    deductions=deductions,
    key_strengths=["..."],
    areas_for_improvement=["..."]
)

# Processing applies caps automatically:

# Open Source → 35, Self Projects → 30, Production → 25, Technical Skills → 10

# Category sum = 100, + Bonus 18 = 118, - Deductions 5 = 113 (≤120)

When using the command-line interface, the capping warning appears in the output:

$ python score.py resumes/jane_smith.pdf
📊 RESUME EVALUATION RESULTS FOR: Jane Smith
...
🎯 OVERALL SCORE: 119.0/100
⚠️  Warning: Total score capped at maximum possible value

Key Source Files and Functions

The capping logic spans several modules:

• score.py: Contains the print_evaluation_results function implementing per-category caps (lines 45-50) and the overall ceiling check (lines 65-70)
• models.py: Defines CategoryScore, Scores, BonusPoints, and Deductions data structures with maximum constraints
• evaluator.py: Runs the LLM evaluation producing raw scores that feed into the capping logic
• transform.py: Converts evaluation responses into CSV rows using the final capped score values

Summary

• The maximum achievable score is 120 points, comprising 100 category points and 20 bonus points.
• Per-category caps enforce maximums (35/30/25/10) using min() in score.py lines 45-50.
• Overall cap limits the final total to max_score + 20 (120) at lines 65-70 of score.py.
• Deductions reduce the final score but cannot increase it beyond the cap.
• The CategoryScore and EvaluationData models in models.py support this enforcement structure.

Frequently Asked Questions

What happens if raw AI scores exceed category maximums?

The print_evaluation_results function automatically caps each category using min(category_data["score"], category_data["max"]) before aggregation. For example, a raw Open Source score of 40 is reduced to the 35-point maximum, ensuring no single category distortion affects the final result.

Can deductions cause the score to drop below zero?

While the analysis focuses on the upper cap, deductions are subtracted after bonus addition. The evaluator enforces logic at score.py lines 65-70 primarily concerning the upper bound of max_score + 20, but standard arithmetic subtraction applies to deductions, theoretically allowing scores to approach zero if substantial deductions are applied against minimal category scores.

Which parameter controls the maximum bonus points?

The bonus system allows up to 20 points maximum, defined within the BonusPoints model in models.py. This value is added to the 100-point category subtotal, creating the 120-point absolute ceiling enforced in the overall cap logic.

How can I identify when a score has been capped?

The evaluator prints a specific warning message when the overall cap triggers: "Total score capped at maximum possible value". Additionally, per-category capping occurs silently during the print_evaluation_results execution, visible only by comparing raw AI outputs against the final displayed scores in the evaluation results.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}