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

> Understand the maximum achievable score in hiring-agent. Learn how the 120-point cap works with category limits and overall ceilings for fair candidate assessments.

- Repository: [HackerRank/hiring-agent](https://github.com/interviewstreet/hiring-agent)
- Tags: internals
- Published: 2026-07-19

---

**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`](https://github.com/interviewstreet/hiring-agent/blob/main/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`](https://github.com/interviewstreet/hiring-agent/blob/main/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:

```python

# 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`](https://github.com/interviewstreet/hiring-agent/blob/main/score.py), the logic checks against `max_score + 20` (where `max_score` equals the 100-point category total):

```python

# 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:

```python
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:

```bash
$ 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`](https://github.com/interviewstreet/hiring-agent/blob/main/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`](https://github.com/interviewstreet/hiring-agent/blob/main/models.py)**: Defines `CategoryScore`, `Scores`, `BonusPoints`, and `Deductions` data structures with maximum constraints
- **[`evaluator.py`](https://github.com/interviewstreet/hiring-agent/blob/main/evaluator.py)**: Runs the LLM evaluation producing raw scores that feed into the capping logic
- **[`transform.py`](https://github.com/interviewstreet/hiring-agent/blob/main/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`](https://github.com/interviewstreet/hiring-agent/blob/main/score.py) lines 45-50.
- **Overall cap** limits the final total to `max_score + 20` (120) at lines 65-70 of [`score.py`](https://github.com/interviewstreet/hiring-agent/blob/main/score.py).
- Deductions reduce the final score but cannot increase it beyond the cap.
- The `CategoryScore` and `EvaluationData` models in [`models.py`](https://github.com/interviewstreet/hiring-agent/blob/main/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`](https://github.com/interviewstreet/hiring-agent/blob/main/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`](https://github.com/interviewstreet/hiring-agent/blob/main/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.