Hiring Agent Evaluation Bonus Points and Deductions Criteria Explained

In the interviewstreet/hiring-agent system, bonus points add up to 20 points to category scores for exceptional achievements, while deductions subtract points for missing criteria, with both components defined in main/models.py and applied in main/score.py.

The hiring-agent repository by Interview Street implements a nuanced scoring algorithm that evaluates candidate résumés across four categories. This open-source tool combines capped category scores with adjustable bonus points and deductions to produce a final composite score. Understanding how these scoring modifiers work is essential for customizing the evaluation pipeline or interpreting results.

Bonus Points Criteria in Hiring Agent Evaluation

Data Model and Hard Limits

In main/models.py, the BonusPoints class defines the structure for extra credit. The total field accepts values between 0 and 20, establishing a hard cap of 20 bonus points regardless of achievement level. This limit ensures that bonus points augment but do not overwhelm the core category scores.

Documentation Requirements

The model includes a breakdown field—a free-form string that explains the specific achievements justifying the bonus. This documentation requirement ensures traceability, allowing reviewers to see exactly why a candidate received extra points for items like open-source leadership or exceptional technical depth.

Deductions Criteria in Hiring Agent Evaluation

Deduction Structure and Storage

Also defined in main/models.py, the Deductions class stores penalty values as positive integers in the total field, but applies them as negative values during calculation. The system accepts any value ≥ 0 for deductions, with no explicit upper cap mentioned in the source code.

Penalty Justification

The reasons field provides a free-form string describing why points were removed, such as missing portfolio links or incomplete documentation. This creates an audit trail for every point subtracted from the candidate's total.

Scoring Flow and Calculation Logic

The actual computation occurs in main/score.py within the print_evaluation_results function. The algorithm follows a strict four-step sequence:

1. Compute each category's capped score against category-specific maximums.
2. Add evaluation.bonus_points.total to the running sum.
3. Subtract evaluation.deductions.total from the combined total.
4. Clamp the final value to the maximum possible overall score (max_score + 20).

The maximum possible overall score is max_score + 20 because the bonus cap is fixed at 20 points. This ensures that even with full bonus points, the score cannot exceed the predefined ceiling.

Code Implementation Examples

Creating Evaluation Data Programmatically

When integrating the hiring agent into custom workflows or writing unit tests, you can construct EvaluationData objects with specific bonus and deduction values:

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

# Category scores (already capped to their max)

scores = Scores(
    open_source=CategoryScore(score=30, max=35, evidence="Contributed to 3 OSS projects"),
    self_projects=CategoryScore(score=25, max=30, evidence="Built 2 personal apps"),
    production=CategoryScore(score=20, max=25, evidence="2 years at Acme Corp"),
    technical_skills=CategoryScore(score=8, max=10, evidence="Proficient in Python, Go")
)

# Bonus points earned (max 20)

bonus = BonusPoints(total=12, breakdown="Extra points for open‑source leadership")

# Deductions applied (positive number, interpreted as negative)

deductions = Deductions(total=3, reasons="Missing portfolio link")

evaluation = EvaluationData(
    scores=scores,
    bonus_points=bonus,
    deductions=deductions,
    key_strengths=["Strong problem‑solving", "Team player"],
    areas_for_improvement=["Documentation", "Testing"]
)

Running Evaluations from the Command Line

For standard usage, the CLI tool extracts résumé content, invokes the LLM evaluator, and automatically applies the bonus and deduction logic:

python score.py path/to/candidate_resume.pdf

The output displays the composite score with clear indicators for bonus points and deductions:

🎯 OVERALL SCORE: 87.5/100
⭐ BONUS POINTS: 12
⚠️  DEDUCTIONS: -3

Summary

• Bonus points are capped at 20 points and defined in main/models.py via the BonusPoints class, requiring a total value between 0 and 20 plus a descriptive breakdown string.
• Deductions are stored as positive values in the Deductions class but subtracted during final calculation, with mandatory reasons documentation explaining each penalty.
• The final score calculation in main/score.py adds bonus points to category totals, subtracts deductions, and clamps the result to max_score + 20.
• Both components require free-form text explanations (breakdown for bonuses, reasons for deductions) to maintain evaluation transparency.

Frequently Asked Questions

What is the maximum number of bonus points in hiring agent evaluation?

The system enforces a hard limit of 20 bonus points. According to the BonusPoints class in main/models.py, the total field must be ≥ 0 and ≤ 20, ensuring that extra credit can never exceed this ceiling regardless of the candidate's achievements.

How are deductions represented in the hiring agent data model?

Deductions are stored as positive integers in the Deductions.total field but applied as negative values during score calculation. The main/models.py implementation requires the total to be ≥ 0, while the scoring logic in main/score.py explicitly subtracts this value from the running total.

Can bonus points exceed the maximum overall score in hiring agent evaluation?

No, the final score cannot exceed max_score + 20. The print_evaluation_results function in main/score.py clamps the final value to this ceiling, ensuring that even with maximum category scores and full 20-point bonus, the result respects the system's upper bound.

Where is the bonus and deduction logic implemented in the hiring agent repository?

The data structures are defined in main/models.py (BonusPoints and Deductions classes), while the application logic resides in main/score.py within the print_evaluation_results function. The evaluator.py file generates these values via LLM evaluation, passing them to the scoring function for final calculation.

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