Hiring Agent Evaluation Scoring Criteria and Weighting: Complete Guide

The hiring agent uses a 120-point evaluation system with four weighted categories—Open Source (35 points), Self Projects (30 points), Production Experience (25 points), and Technical Skills (10 points)—plus optional bonus points (up to 20) and deductions to calculate a final résumé score.

The interviewstreet/hiring-agent repository implements a structured LLM-powered evaluation system that scores technical résumés using specific hiring agent evaluation scoring criteria. Understanding these weights and how they combine with bonus points and deductions is essential for interpreting candidate assessments accurately according to the source code implementation.

The Four Core Scoring Categories

The evaluation system assigns maximum point values to four distinct experience categories, defined in score.py within the category_maxes dictionary.

Open Source Contributions (35 Points)

This category carries the highest weight, assessing contributions to open-source projects, community involvement, and overall impact. The maximum 35 points reflects the value placed on collaborative, public code contributions.

Self Projects (30 Points)

Personal side-projects, prototypes, and independently built applications are evaluated here. With 30 points available, this category rewards candidates who demonstrate initiative and practical application development outside professional contexts.

Production Experience (25 Points)

Professional, production-grade work experience and responsibilities are measured in this category. The 25-point weight emphasizes real-world deployment and maintenance of systems at scale.

Technical Skills (10 Points)

Mastery of relevant technologies, programming languages, and tools falls into this foundational category. The 10-point allocation provides baseline assessment of technical competency.

Bonus Points and Deductions

Beyond the core 100 points, the system applies adjustments through two additional mechanisms defined in models.py.

Bonus Points (Maximum 20 Points)

Standout achievements such as patents, awards, or exceptional leadership can earn up to 20 additional points. The BonusPoints model in models.py structures these additions, which are added to the base score.

Deductions (Negative Adjustments)

Points are subtracted for gaps, inconsistencies, or other negative factors identified in the résumé. The Deductions model handles these subtractions, which reduce the total score without exceeding the accumulated points.

How the Final Score Is Calculated

The scoring logic in score.py implements a cap-and-sum algorithm that ensures no category exceeds its maximum weight.

The calculation follows this formula:

final_score = sum(min(category.score, category.max) for each category)
               + bonus_points.total
               – deductions.total

This implementation guarantees that the overall maximum possible score is 120 points (100 points from categories plus 20 bonus points).

Implementation in the Codebase

The scoring architecture relies on three key files that define the data structures and calculation logic.

score.py

Located at the repository root, score.py contains the category_maxes dictionary defining the weighting limits and the print_evaluation_results function that aggregates scores. This file serves as the CLI driver for running evaluations.

models.py

The EvaluationData Pydantic model enforces the structure and numeric limits for scores, bonuses, and deductions. It includes nested models for CategoryScore, Scores, BonusPoints, and Deductions that validate the incoming evaluation data.

evaluator.py

The ResumeEvaluator class handles LLM interactions, sending résumé data to the language model and parsing the structured JSON response into the EvaluationData schema.

Working with the Scoring System Programmatically

You can interact with the hiring agent evaluation scoring criteria directly through the Python API or command-line interface.

Running Evaluations via CLI

Execute a complete résumé evaluation using the command:

python score.py path/to/resume.pdf

This extracts the résumé text, optionally augments it with GitHub data, and prints the weighted breakdown including bonus points and deductions.

Accessing Scores in Python

Import the evaluator to process résumés programmatically:

from evaluator import ResumeEvaluator
from models import EvaluationData

evaluator = ResumeEvaluator()
evaluation: EvaluationData = evaluator.evaluate_resume(resume_text)

# Access individual weighted scores

print(evaluation.scores.open_source.score)   # e.g., 28.0 / 35

print(evaluation.bonus_points.total)        # e.g., 12.0 / 20

print(evaluation.deductions.total)          # e.g., 5.0

Manual Score Calculation

To compute the final score manually using the category weights:

def compute_final_score(eval_data):
    category_maxes = {
        "open_source": 35,
        "self_projects": 30,
        "production": 25,
        "technical_skills": 10,
    }

    total = 0
    for cat, max_val in category_maxes.items():
        cat_score = getattr(eval_data.scores, cat).score
        total += min(cat_score, max_val)

    total += eval_data.bonus_points.total
    total -= eval_data.deductions.total
    return total

final = compute_final_score(evaluation)
print(f"Final score: {final:.1f}/120")

Summary

• The hiring agent uses four weighted categories totaling 100 points: Open Source (35), Self Projects (30), Production Experience (25), and Technical Skills (10).
• Bonus points can add up to 20 additional points for exceptional achievements.
• Deductions subtract points for résumé gaps or inconsistencies.
• The final score caps at 120 points and is calculated in score.py using the category_maxes dictionary.
• Data validation occurs through Pydantic models in models.py, including EvaluationData, BonusPoints, and Deductions.

Frequently Asked Questions

What is the maximum possible score in the hiring agent evaluation system?

The maximum possible score is 120 points, comprising 100 points from the four core categories plus up to 20 bonus points. Deductions can reduce this total but cannot result in a negative score.

Which category has the highest weight in the evaluation?

Open Source carries the highest weight at 35 points, reflecting the system's emphasis on collaborative development and community contribution. Self Projects follows at 30 points.

How are bonus points and deductions calculated?

Bonus points are added from the BonusPoints model (maximum 20), while deductions are subtracted based on the Deductions model. Both are applied to the base category sum in the final calculation defined in score.py.

Where are the scoring weights defined in the codebase?

The weights are defined in the category_maxes dictionary located in score.py, with corresponding data structures enforced by the EvaluationData model in models.py.

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