# Hiring Agent Evaluation Scoring Criteria and Weighting: Complete Guide

> Discover the hiring agent's evaluation system! Learn about the scoring criteria and weighting for Open Source, Self Projects, Production Experience, and Technical Skills. Optimize your résumé score today.

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

---

**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`](https://github.com/interviewstreet/hiring-agent/blob/main/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`](https://github.com/interviewstreet/hiring-agent/blob/main/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`](https://github.com/interviewstreet/hiring-agent/blob/main/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`](https://github.com/interviewstreet/hiring-agent/blob/main/score.py) implements a cap-and-sum algorithm that ensures no category exceeds its maximum weight.

The calculation follows this formula:

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

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

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

```python
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`](https://github.com/interviewstreet/hiring-agent/blob/main/score.py) using the `category_maxes` dictionary.
- Data validation occurs through Pydantic models in [`models.py`](https://github.com/interviewstreet/hiring-agent/blob/main/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`](https://github.com/interviewstreet/hiring-agent/blob/main/score.py).

### Where are the scoring weights defined in the codebase?

The weights are defined in the `category_maxes` dictionary located in [`score.py`](https://github.com/interviewstreet/hiring-agent/blob/main/score.py), with corresponding data structures enforced by the `EvaluationData` model in [`models.py`](https://github.com/interviewstreet/hiring-agent/blob/main/models.py).