Generated banner for Model Evaluation
Generated logo for Model Evaluation

Model Evaluation

AWS LabsOfficialPublished by AWS Labs

  • Skill
  • Workflow
  • Software development
  • Apache-2.0
  • Low risk
  • Has scripts

From the author

Generates python code that evaluates SageMaker models. Supports two evaluation types: LLM-as-Judge and Custom Scorer. Use when the user says "evaluate my model", "run a benchmark", "test model performance", "how did my model perform", "compare models", or other similar requests.
— the description by AWS Labs

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured workflow for evaluating SageMaker models, supporting both open-source and Nova models. It guides users through selecting an evaluation strategy—either LLM-as-Judge for qualitative assessment or a Custom Scorer for programmatic validation—and generates the necessary Python code or Jupyter notebooks to execute these benchmarks within the SageMaker environment.

What it does

  • Determines the appropriate evaluation type based on model architecture and user requirements.
  • Validates compatibility between the chosen evaluation method and the target model.
  • Generates Python scripts or Jupyter notebooks for model evaluation.
  • Supports LLM-as-Judge for OSS models.
  • Facilitates the creation and registration of Lambda-based custom scorers.
  • Integrates with SageMaker SDK for streamlined model benchmarking.

When to use it

  • When you need to benchmark the performance of a fine-tuned or base SageMaker model.
  • When you want to use an LLM to grade model outputs.
  • When you require custom programmatic logic to score model responses.
  • When you need to compare different model versions or configurations.

Advantages

  • Ensures consistent evaluation workflows through guided steps.
  • Prevents incompatible configurations by validating model types early.
  • Automates the generation of boilerplate code for evaluation tasks.
  • Provides flexibility by supporting both automated LLM grading and custom logic.

Usage examples

“Evaluate my model.”
The agent will initiate the evaluation workflow, asking you to choose between LLM-as-Judge or Custom Scorer, and verify your model type.
“How did my model perform?”
The agent will guide you through setting up a benchmark or custom scorer to generate performance metrics.
“Run a benchmark on my fine-tuned Llama model.”
The agent will confirm the model type and guide you through the LLM-as-Judge or Custom Scorer setup process.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/awslabs/model-evaluation/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip model-evaluation.zip -d .agents/skills

Documentation by AWS Labs

Model Evaluation

Generate code that evaluates a SageMaker model.

Prerequisites

  • The SDK environment has been verified (SDK version, region, execution role). If not done, activate the sdk-getting-started skill first.

Principles

  1. One thing at a time. Each response advances exactly one decision. Never combine multiple questions in a single turn.

  2. Confirm before proceeding. Wait for the user to agree before moving to the next step.

  3. Don't read files until you need them. Only read reference files when you've reached the step that requires them.

  4. Don't ask what you already know. If the answer is in conversation history, workflow_state.json, plan.md, or any file you've already read — use it. Confirm if unsure, but don't re-ask.

  5. No narration. Share outcomes and ask questions. Keep responses short.

  6. No repetition. If you said something before a tool call, don't repeat it after.

Scope

This skill supports the evaluation feature for SageMaker Serverless Model Customization. It can evaluate any base or fine-tuned model supported by SageMaker serverless model customization — both OSS models (Llama, Mistral, Qwen, etc.) and Nova models.

Tell the user when the skill is activated:

"I can help evaluate any base or fine-tuned model supported by SageMaker serverless model customization."

If the user requests help evaluating a model that isn't supported by SageMaker serverless model customization, explain that it is not supported by this skill.

Evaluation Types

There are two evaluation types:

  • LLM-as-Judge — an LLM grades your model's responses. (OSS models only — not supported for Nova.)

  • Custom Scorer — programmatic evaluation via Lambda function (includes built-in math and code scorers). Works with both OSS and Nova models.

Workflow

Step 1: Determine evaluation type

Do you already know which evaluation type to use?

Check conversation history, plan.md, workflow_state.json, or anything else you've already read.

If yes: confirm with the user.

"It sounds like you want to run [evaluation type]. Is that right?"

⏸ Wait for confirmation. If confirmed → go to Step 2.

If no: ask.

"What kind of evaluation would you like to run? I support:

  1. LLM-as-Judge — an LLM grades your model's responses

  2. Custom Scorer — programmatic scoring (math, code, or your own logic)

Pick one, or say 'help me decide' if you're not sure."

⏸ Wait for user.

  • If user picks one → go to Step 2.

  • If user indicates uncertainty, by saying something like "help me decide," "whatever you think," "I'm not sure" → read references/evaluation-type-guide.md and follow its instructions. It will guide the user to a choice and then return here. You MUST NEVER make a recommendation to the user on eval type without reading references/evaluation-type-guide.md.

Step 2: Validate and hand off to evaluation workflow

Before reading the reference file, validate that the chosen evaluation type is compatible with the user's situation. You may already know these answers from conversation context — don't ask if you don't need to.

LLM-as-Judge validation
  1. What model type are we evaluating? LLM-as-Judge is not supported for Nova models. To determine model type (if you don't already know it):

    • If you have the training job name or ARN, use the AWS MCP tool list-tags on the training job ARN and look for the sagemaker-studio:jumpstart-model-id tag. Contains "nova" → Nova. Anything else → OSS.

    • If you have a Model Package ARN, use the AWS MCP tool describe-model-package and check the model description or source tags.

    • If neither is available, ask the user.

  2. Does the user have an evaluation dataset? LLM-as-Judge requires one.

Custom Scorer validation
  1. Does the user have an evaluation dataset? Custom Scorer requires one. (Works with both OSS and Nova models, though for Nova only custom lambdas are supported.)


If validation fails, tell the user which requirement(s) aren't met and offer alternatives:

"[Evaluation type] won't work because [reason]."

If the failure reason was lack of an eval dataset, there's nothing we can do. Inform the user:

"Unfortunately all of the supported eval types require an eval dataset. I can't help you with model evaluation."

If the failure reason is something else, offer to help them pick a different evaluation type.

⏸ Wait for user.

If they say they do want help choosing a different eval type → read references/evaluation-type-guide.md.

If validation passes, read the corresponding reference file:

User choseRead
LLM-as-Judgereferences/llmaaj-evaluation.md
Custom Scorerreferences/custom-scorer-evaluation.md

Follow the reference file's instructions from the beginning.

Files

references/evaluation-type-guide.md

Evaluation Type Guide

Help the user decide which evaluation type to use based on their goals and constraints.

Evaluation types at a glance

TypeWhat it doesEval dataset?CostSupported models
LLM-as-JudgeAn LLM scores your model's responses on subjective qualities like helpfulness, correctness, coherence, and safety.YesHigherOSS only
Custom ScorerYour own scoring logic (or a built-in scorer) evaluates outputs programmatically — exact/near match, pattern checks.YesLowerAll

When to use which — in short:

  • To assess subjective qualities like tone, helpfulness, coherence, or faithfulness → LLM-as-Judge

  • When a programmatic approach can give a meaningful signal about output quality → Custom Scorer

Decision flow

Work through the steps below in order. For each, use what you already know from conversation history, plan.md, workflow_state.json, or other files you've read. Only ask the user if you genuinely don't know.

Step 1: Check for evaluation dataset

For this step, you need to know: whether the user has an evaluation dataset.

If you don't know from previous context, ask:

"Do you have an eval dataset?"

⏸ Wait for user.

If the user does not have one:

"All supported evaluation types require an evaluation dataset. Unfortunately, this skill can't help with model evaluation without one."

Stop here. Do not offer to help create or find a dataset, since our skills do not support this.

If the user has an evaluation dataset, continue.

Step 2: Check model compatibility

For this step, you need to know: what type of model is being evaluated (open source or Nova).

If you don't already know from conversation context, try to determine it:

  1. If you have the training job name or ARN, use the AWS MCP tool list-tags on the training job ARN and look for the sagemaker-studio:jumpstart-model-id tag.

    • Contains "nova" (e.g., nova-micro, nova-lite, nova-pro) → Nova

    • Anything else (Llama, Mistral, Qwen, GPT-OSS, DeepSeek, etc.) → OSS

  2. If you have a Model Package ARN, use the AWS MCP tool describe-model-package and check the model description or source tags for the same model ID.

  3. If neither is available, ask the user:

    "What model are you evaluating — is it a Nova model or an open-source model (like Llama, Mistral, Qwen, etc.)?"

If the model is Nova, LLM-as-Judge is not supported. Tell the user:

"Unfortunately, LLM-as-Judge isn't available for Nova models. Can we use Custom Scorer instead?"

If Nova -> Skip to step 4.

Else -> Continue to Step 3 with the remaining options.

Step 3a: Understand the task and data

For this step, you need to understand: what the model does, what the evaluation data looks like, and what "success" means for this task.

If you don't already have a clear picture from conversation context, ask:

"Can you tell me about the task you're focused on? Please explain what you want your model to do and what your evaluation dataset looks like."

You need enough context to reason about Steps 3b and 3c. If the user's answer is vague, ask a follow-up before moving on.

⏸ Wait for user.

Step 3b: Assess Custom Scorer signal strength

Based on what you know about the task and data, think about: how strong of a signal a custom (programmatic) scorer could give us about task success

Rate the signal strength as strong, medium, or weak:

  • Strong: A programmatic check can reliably tell you whether the output is correct. Examples include math problems with numerical answers, classification tasks with labels, or extraction tasks with exact ground truths.

  • Medium: The task has reference answers, and programmatic comparison gives a useful but imperfect signal. Examples include summarization or Q&A where text comparison against reference answers captures something meaningful, or format compliance checks where you can verify structure even if you can't verify content quality.

  • Weak: What matters about the output is hard to capture in code. There may be no reliable reference answer to compare against, or the reference doesn't capture what the user actually cares about.

Think broadly — even tasks that seem subjective may have a programmatic angle.

Step 3c: Assess LLM-as-Judge signal strength

Based on what you know about the task and data, think about: how strong of a signal an LLM judge could give us about task success

Rate the signal strength as strong, medium, or weak:

  • Strong: Key model quality metrics are inherently subjective — helpfulness, coherence, tone, etc.

  • Medium: The task has some subjective element, but also a clear factual or structural component that a programmatic approach could partially cover.

  • Weak: The task has a single objectively correct answer, and a judge model carries the risk of hallucinating, while a programmatic check would be more reliable.

Think broadly — LLM-as-Judge can surface issues that are hard to anticipate with code, but it's not always the best tool for the job.

Step 3d: Check cost sensitivity

For this step, you need to know: how important keeping costs low is to the user.

LLM-as-Judge invokes a model to score each sample, which adds cost. Custom Scorer runs your own code, which is cheaper.

If you already know from context, skip to Step 4. If not, ask:

"On a scale of 1-5, how important is it to you to keep evaluation costs low, even if it means less nuanced results? 5 means prioritize budget above all else."

⏸ Wait for user.

Step 4: Recommend an evaluation type

Use the signal strength assessments and cost sensitivity to make a recommendation:

  • Nova model → recommend Custom Scorer (only available option).

  • Custom Scorer signal is strong → recommend Custom Scorer. It's deterministic, reproducible, and cost-effective. A programmatic approach gives you a reliable signal for this task.

  • Cost sensitivity is very high (4-5) and Custom Scorer signal is weak but not totally absent → recommend Custom Scorer, but be upfront that the programmatic signal may be limited for this task. A partial signal at low cost may be preferable to a richer signal at higher cost.

  • LLM-as-Judge signal is strong and Custom Scorer signal is weak → recommend LLM-as-Judge. The task needs the kind of nuanced judgment that only an LLM can provide.

  • Both have medium or strong signal → Carefully weigh the customer's cost concerns with the benefits of each eval type. Recommend the one that you think fits all of their needs the best.

Present your recommendation with a brief reason:

"Based on what you've told me, I'd recommend [evaluation type] — [one sentence explaining why]. Want to go with that?"

⏸ Wait for user to confirm.

Once the user confirms, return to the main SKILL.md workflow (Step 2: Validate and hand off).


Custom Scorer: choosing the right scorer type

If the user chose Custom Scorer, use this logic to recommend the specific scorer:

ScorerRecommend when
Prime MathTask involves mathematical reasoning with verifiable numeric/symbolic answers
Prime CodeTask involves code generation that can be tested against input/output pairs
Custom LambdaAny task with custom scoring logic that doesn't fit Prime Math or Prime Code

Decision logic:

  1. If task is math with verifiable answers → recommend Prime Math.

  2. If task is code generation with testable I/O → recommend Prime Code.

  3. Otherwise → recommend Custom Lambda.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Python

Security

What our scanner noticed· Low risk

  • Instructions that use the network
  • Scripts that your agent may run

This skill includes scripts that your agent may run. Read them before you use it.

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by
AWS Labs
Publisher
AWS Labs (Official)
Source
awslabs/agent-plugins · plugins/sagemaker-ai/skills/model-evaluation · commit fbefb37
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • NOTICE (added by AutoGineer from NOTICE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by AWS Labs or AWS Labs.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download model-evaluation.zip