Hiring Agent Scoring Categories: The Four Evaluation Dimensions Explained

Hiring Agent scoring categories comprise Open Source (35 points), Self Projects (30 points), Production Experience (25 points), and Technical Skills (10 points), totaling a maximum of 100 base points for résumé evaluation.

InterviewStreet's hiring-agent is an open-source résumé evaluation engine that automatically assesses developer candidates using a structured, code-based scoring system. The repository analyzes GitHub profiles and professional experience to assign quantitative scores across four distinct dimensions. Understanding these Hiring Agent scoring categories helps hiring managers interpret evaluation results and enables developers to optimize their technical profiles.

The Four Hiring Agent Scoring Categories

The evaluation model defined in models.py (lines 24-28) divides assessments into four weighted categories, each represented as a CategoryScore object within the Scores model.

Open Source (35 points)

This category measures contributions to public open-source projects, including merged pull requests, maintained repositories, and sustained community involvement. It carries the highest weight because sustained open-source activity demonstrates collaborative coding skills and commitment to code quality visible in public repositories.

Self Projects (30 points)

Personal side projects, hobby repositories, and independent codebases fall under this dimension. The evaluator assesses project complexity, documentation quality, and technical diversity to determine the candidate's initiative and passion for software development outside professional obligations.

Production Experience (25 points)

Professional work history and production-grade contributions are evaluated here. This includes employment at technology companies, shipped features in commercial products, and enterprise-level code contributions that demonstrate real-world engineering maturity and scalability experience.

Technical Skills (10 points)

The breadth and depth of programming languages, frameworks, and tools appear in this category. While it carries the lowest weight, it ensures candidates possess the baseline technical competencies required for specific engineering roles.

How the Scoring Model Works in Code

In models.py, the Scores class aggregates four CategoryScore instances. Each category contains three fields: score (actual points awarded), max (maximum possible), and evidence (explanatory text justifying the rating).

The calculation logic resides in score.py (lines 81-85), specifically within the print_evaluation_results function. According to the source code, the system sums the capped category scores, adds bonus points for exceptional achievements, and subtracts deductions for negative indicators. The maximum possible score across all Hiring Agent scoring categories is 100 points before modifications.

Accessing Category Scores Programmatically

Developers integrating the hiring-agent into their pipelines can extract individual category scores using the EvaluationData model and its nested Scores attribute.

Retrieve specific category scores:

from models import EvaluationData

def show_category_scores(evaluation: EvaluationData):
    # Access each category directly

    print("Open Source score:", evaluation.scores.open_source.score)
    print("Self Projects score:", evaluation.scores.self_projects.score)
    print("Production Experience score:", evaluation.scores.production.score)
    print("Technical Skills score:", evaluation.scores.technical_skills.score)

# Example usage after running the evaluator

evaluation = main("example_resume.pdf")  # returns an EvaluationData object

show_category_scores(evaluation)

Convert scores to dictionary format for reporting:

# Converting the scores to a dictionary for further reporting

def scores_to_dict(evaluation: EvaluationData) -> dict:
    return {
        "open_source": evaluation.scores.open_source.model_dump(),
        "self_projects": evaluation.scores.self_projects.model_dump(),
        "production": evaluation.scores.production.model_dump(),
        "technical_skills": evaluation.scores.technical_skills.model_dump(),
    }

Summary

• Hiring Agent scoring categories comprise four weighted dimensions: Open Source (35 points), Self Projects (30 points), Production Experience (25 points), and Technical Skills (10 points).
• The Scores model in models.py structures these as CategoryScore objects containing actual scores, maximum values, and evidence strings.
• Total evaluation caps at 100 points before bonuses or deductions are applied in score.py via the print_evaluation_results function.
• Programmatic access is available through the EvaluationData.scores attribute using dot notation for each category (e.g., evaluation.scores.open_source.score).

Frequently Asked Questions

What is the maximum possible score in Hiring Agent?

The maximum base score is 100 points, distributed across the four categories: 35 for Open Source, 30 for Self Projects, 25 for Production Experience, and 10 for Technical Skills. The final score may exceed 100 if bonus points are awarded for exceptional achievements or fall below if deductions apply for negative indicators.

How does Hiring Agent calculate the final evaluation score?

According to the print_evaluation_results function in score.py, the system sums the capped scores from all four categories, then adds bonus points for exceptional achievements and subtracts deductions for red flags. Each category score is capped at its defined maximum before being included in the total.

Which category carries the most weight in Hiring Agent evaluations?

Open Source carries the highest weight at 35 points, reflecting the tool's emphasis on public code contributions and collaborative development experience. This is followed by Self Projects (30 points), Production Experience (25 points), and Technical Skills (10 points), as defined in the Scores model.

Can I modify the scoring weights in the Hiring Agent source code?

Yes, the maximum point values are hardcoded in the Scores model definition within models.py and referenced in the calculation logic in score.py. You can adjust these constants to customize evaluation criteria for specific hiring needs, though this requires forking the repository and redeploying your modified instance.

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