The best open-source LLM evaluation frameworks in 2026

The best open-source LLM evaluation framework depends on what you are testing. As of November 2026: Promptfoo for comparing prompts and models from a config file, and for red teaming; DeepEval for ready-made quality metrics inside pytest; Inspect AI for agent evals in sandboxes with error bars; Pydantic Evals for typed, code-first evals with deterministic tool-call checks; Ragas for RAG metrics, with a caveat about its maintenance below; and vitest-evals if your stack is TypeScript. For one narrow job, comparing two models on the same recorded agent runs, EvalShift.

Lists of these frameworks mostly compare features. This one also checks four things that decide whether an open-source framework is safe to build on: what the license covers and what sits outside it, whether the project is still being released, what the tool sends off your machine by default, and which of its checks need a paid model call. Several of the names on most lists failed the second check this year, and one was archived the day before I wrote this.

A disclosure: I build EvalShift, which is on the list, and it is the smallest project here by a wide margin. Every fact about another project links to its repository or docs, read on November 10, 2026.

Open-source LLM evaluation frameworks at a glance

Release dates come from PyPI and npm, star counts from GitHub, both on November 10, 2026.

What counts as an LLM evaluation framework

Three different kinds of software get called an LLM evaluation framework, and they are not substitutes for each other.

Application test frameworks are libraries or CLIs you run in your own code. You write test cases, pick or write checks, and run the suite on your machine or in CI. Nothing needs a server. Every tool in the table above is one of these, and they are what this post compares.

Platforms with an evaluation feature start from tracing. Your app sends its requests to a server, and evals run over the stored traces. Langfuse, Opik, MLflow and Arize Phoenix are the open ones. They need a database and a deployment, and they answer a different question: what is production doing. They get a section below, and the LLM evaluation tools comparison covers them in depth.

Model benchmark harnesses run a model against public benchmarks: lm-evaluation-harness, HELM, lighteval. They test a model, not your application, and are covered at the end.

What I checked in each framework

1. +The license, and what sits outside it. Most of these projects are the free half of a company's product. The library is open; the dashboard, the history and the team features are often not.
2. +Whether it is still being released. A star count is cumulative and says nothing about this year. The date of the latest release does.
3. +What leaves your machine by default. Usage telemetry, uploads to a hosted dashboard, and the model calls a judged metric makes.
4. +Which checks are deterministic. A check written in code is free and repeatable. A judged metric costs a model call per case and can disagree with itself between runs.
5. +Agent support and CI. Whether it can check which tools an agent called and with which arguments, and whether a failing eval can fail a pull request.

Promptfoo

Promptfoo ↗ is a command-line tool driven by a YAML file. You list prompts, providers and test cases, and promptfoo eval runs every prompt against every model:

# promptfooconfig.yaml
prompts:
  - 'Reply to this support message in one sentence: {{message}}'
providers:
  - openai:gpt-6-luna
tests:
  - vars:
      message: Where is my order 4417?
    assert:
      - type: icontains
        value: '4417'
      - type: llm-rubric
        value: Does not promise a delivery date

npx promptfoo@latest eval

Its assertions ↗ split cleanly into deterministic ones (contains, regex, is-json, javascript, python, latency, cost, and trajectory checks on an agent's tool calls) and model-assisted ones (llm-rubric, g-eval, factuality, embedding similarity). Red teaming is built in, and there is an official GitHub Action.

• +License: MIT. Promptfoo has been part of OpenAI since the acquisition announced on March 9, 2026 ↗, and the README ↗ says it remains open source. A commercial Enterprise edition sits beside it.
• +What leaves your machine: usage telemetry ↗ is on by default. It records which commands and assertion types ran, not prompts or outputs, and PROMPTFOO_DISABLE_TELEMETRY=1 turns it off. Results stay local until you run promptfoo share.
• +Worth knowing: provider responses are cached on disk by default ↗. A second run replays the first unless you pass --no-cache, which matters when you use --repeat to measure how much outputs vary.

Choose it when you are picking between models or prompts, you need red teaming, or you want tests in a config file that non-Python teammates can edit.

DeepEval

DeepEval ↗ treats an eval as a pytest test. You build a test case, attach metrics, and deepeval test run fails the test when a metric misses its threshold:

# test_refunds.py
from deepeval import assert_test
from deepeval.metrics import GEval
from deepeval.test_case import LLMTestCase, SingleTurnParams

def test_refund_answer():
    correctness = GEval(
        name="Correctness",
        criteria="Is the actual output correct, given the expected output?",
        evaluation_params=[SingleTurnParams.ACTUAL_OUTPUT, SingleTurnParams.EXPECTED_OUTPUT],
        threshold=0.5,
    )
    case = LLMTestCase(
        input="What if these shoes don't fit?",
        actual_output="You have 30 days to get a full refund at no extra cost.",
        expected_output="We offer a 30-day full refund at no extra cost.",
    )
    assert_test(case, [correctness])

deepeval test run test_refunds.py

It ships more than 50 metrics across RAG, agents, conversations and safety. Its metrics page ↗ says almost all of them are LLM-as-a-judge. The documented exceptions are exact match, pattern match and JSON correctness. So a DeepEval suite needs a model key and pays for a judge call per metric per case; the judge defaults to an OpenAI model and can be pointed at another provider or a local Ollama model.

• +License: Apache-2.0 for the library. Dashboards, run comparison and production tracing live in Confident AI, the proprietary platform from the same team. Its free plan covers 2 seats and 5 test runs a week.
• +What leaves your machine: telemetry ↗ goes to PostHog by default: event names, metric names, an anonymous ID and your public IP address. DEEPEVAL_TELEMETRY_OPT_OUT=1 turns it off. Test results upload to Confident AI only after deepeval login.

Choose it when your team already lives in pytest and would rather pick a metric than write one.

Inspect AI

Inspect AI ↗ comes from the UK AI Security Institute. An eval is a task made of a dataset, a solver (the prompt chain or agent) and a scorer:

# capitals.py
from inspect_ai import Task, task
from inspect_ai.dataset import Sample
from inspect_ai.scorer import match
from inspect_ai.solver import generate

@task
def capitals():
    return Task(
        dataset=[Sample(input="What is the capital of France?", target="Paris")],
        solver=generate(),
        scorer=match(),
    )

inspect eval capitals.py --model openai/gpt-6-luna

It has a built-in agent loop, tools, and sandboxes in Docker or Kubernetes, so an agent can act in an environment that is reset between samples. It is the framework here that takes variance most seriously: --epochs repeats every sample, reducers turn the repeats into a mean or a pass-at-k, and results carry standard errors. Response caching is off unless you ask for it, so repeats are real calls.

• +License: MIT, with no commercial edition. Nothing is held back.
• +What leaves your machine: logs are written to ./logs. Its docs describe no usage telemetry.
• +Worth knowing: with a model-graded scorer, the grader defaults to the model being evaluated ↗ unless you name one with --model-role grader=.... Set it, or the model marks its own homework.

Choose it when you are running agent or safety evals in sandboxes, or reproducing public benchmarks. It is not built as a pull-request gate.

Pydantic Evals

Pydantic Evals ↗ is the eval package from the Pydantic AI repository. It installs on its own, and an eval is plain typed Python: a dataset of cases, a list of evaluators, and the function under test.

from pydantic_evals import Case, Dataset
from pydantic_evals.evaluators import Contains, EqualsExpected

dataset = Dataset(
    name="uppercase_tests",
    cases=[Case(name="basic", inputs="hello world", expected_output="HELLO WORLD")],
    evaluators=[EqualsExpected(), Contains(value="HELLO", case_sensitive=True)],
)

def uppercase_text(text: str) -> str:
    return text.upper()

report = dataset.evaluate_sync(uppercase_text)
report.print()

What sets it apart is that its agent evaluators ↗ are deterministic: ToolCorrectness, TrajectoryMatch, ArgumentCorrectness, MaxToolCalls and MaxModelRequests read the OpenTelemetry spans of a run and make no model call. They need the logfire SDK installed, with no Logfire account. Two limits from that page: they see only tools that Pydantic AI executes itself, and when no spans were captured they report a failure, not an error.

• +License: MIT. Pydantic Logfire, the hosted UI for results, is the paid product.
• +What it lacks: its docs describe no pytest plugin, CLI or exit-code gate. You call evaluate_sync from your own test and assert on the report.

Choose it when your agent is already built on Pydantic AI, or you want evals as typed Python with no config format to learn.

Ragas

Ragas ↗ is the metric library most RAG evaluations are built on: faithfulness, context precision, context recall, answer relevancy. Other tools wrap its metrics, MLflow among them. It also has a handful of no-LLM metrics (BLEU, ROUGE, exact match, string presence) and four agent metrics.

The caveat is maintenance. The latest release ↗, 0.4.3, is from January 13, 2026, and the last commit ↗ to the repository is from February 24, 2026. Neither the README nor the repository carries a notice, and the project is not archived. It has simply been quiet for most of a year, in a field where the judge models it calls change every few months.

• +License: Apache-2.0. I found no paid product around it.
• +What leaves your machine: usage analytics are on by default, and the README ↗ gives RAGAS_DO_NOT_TRACK=true to turn them off.

Choose it when you need the standard RAG metrics and are comfortable pinning a version. If you are starting fresh and want the same metrics under active release, DeepEval's RAG metrics are the closest substitute.

openevals

openevals ↗ is LangChain's library of evaluator functions, in Python and TypeScript: LLM-as-a-judge evaluators built from prompt templates, and trajectory evaluators that match an agent's tool calls against a reference in strict, unordered, subset or superset mode. An evaluator is a function you call with inputs and outputs, so it runs anywhere.

The trajectory evaluators used to live in a separate package, agentevals ↗. That package's last PyPI release is from July 2025, and its recent commits are dependency bumps. Start from openevals.

• +License: MIT. The documented way to run evaluators as CI tests goes through LangSmith's pytest, Vitest or Jest integration, which needs a LangSmith API key. LangSmith is proprietary.

Choose it when you already use LangSmith and want its evaluators as code, or you need trajectory matching in TypeScript.

Giskard

Giskard ↗ changed shape in 2026. Version 3 is a rewrite built around multi-turn scenario tests for agents, plus a vulnerability scan, and the repository moved to Giskard-AI/giskard-oss. The README says version 2, the one most older articles describe, is no longer actively maintained. Scenarios run as pytest tests. The judge defaults to openai/gpt-4o-mini.

• +License: Apache-2.0. Giskard Hub is the commercial platform.
• +What leaves your machine: the core README ↗ describes usage analytics sent to PostHog unless DO_NOT_TRACK or GISKARD_TELEMETRY_DISABLED is set. It says prompts and outputs are not included.

Choose it when you want scenario-style tests and a security scan in one Python library, and you are on Python 3.12 or newer.

TruLens

TruLens ↗ combines OpenTelemetry tracing with judged metrics for RAG and agents. Its site says Snowflake maintains it in open source. It has seven agent metrics, among them tool selection, tool calling and plan adherence, and all of them are scored by a judge model. I found no documented test-runner or CI gate.

• +License: MIT, with no paid edition on its site.

Choose it when you want tracing and judged metrics together in one MIT-licensed library.

vitest-evals

For TypeScript the picture changed this month. Evalite ↗, the framework most TypeScript lists recommend, was archived on November 9, 2026. Its README says it is no longer maintained and points to Langfuse, noting that Langfuse needs a server.

vitest-evals ↗, from Sentry, is the active local option. Evals are Vitest tests. You assert on an agent's tool calls with ordinary matchers, for example that the call names equal ["lookupInvoice", "createRefund"], and add judges for the text. There is no default judge model: you configure one. A GitHub Action reads the results and can gate the job on a minimum pass rate.

• +License: Apache-2.0.

Choose it when your agent and your tests are in TypeScript. Promptfoo, openevals and Braintrust's autoevals also run in Node.

EvalShift

EvalShift is the one I build. It does a narrower job than the frameworks above. They test one version of an application. EvalShift compares two: it replays the same recorded agent runs on the model you use today and on a candidate, scores tool selection, tool arguments and output structure on both sides, and tests whether the differences are larger than run-to-run noise. A migration policy turns the result into one verdict, and the GitHub Action can fail a pull request on it.

It has no red teaming, no RAG metrics and no library of quality metrics, and with 12 GitHub stars it has a fraction of the users of anything else here.

• +License: the CLI is Apache-2.0 ↗, and the capture SDK and GitHub Action are MIT. The hosted gate, with run history and baselines, is paid and starts at $49 a month.
• +What leaves your machine: the CLI has no telemetry. It calls your model providers with your keys, and it talks to the hosted API only when you log in or push a run.

Choose it when you are changing the model or the prompt under an agent that is already in production.

Also open source, with a narrower fit

• +autoevals ↗ (MIT, Python and TypeScript): Braintrust's scorer library, with LLM-judged, RAG, embedding and heuristic scorers and none for tool calls. Its README says judge requests go through the Braintrust gateway unless you set OPENAI_BASE_URL.
• +Evidently ↗ (Apache-2.0): text descriptors and LLM judges inside a broader ML monitoring library. No agent or tool-call checks.
• +azure-ai-evaluation ↗ (MIT): Microsoft's evaluator SDK. The quality evaluators run with an OpenAI or Azure OpenAI key; the safety evaluators call a closed Azure service and need an Azure project.
• +Google ADK evaluation ↗ (Apache-2.0): built into the Agent Development Kit. It scores an ADK agent's tool trajectory and final response against recorded cases, from pytest or adk eval.
• +openai/evals ↗: still on most lists. The repository is not archived, but its last PyPI release is from May 2024, and OpenAI's hosted Evals product shuts down on November 30, 2026 ↗, with OpenAI's migration guide pointing to Promptfoo. Not a base for a new project.

Open-source platforms with an evaluation feature

If you also need tracing, four platforms are open to self-host, and their licenses differ more than their feature lists:

What "open source" covers in each framework

The pattern to plan for: the part that runs a test is open almost everywhere, and the part that remembers last week's result usually is not. If you need history without a vendor, write results to a file in CI and keep the artifacts, or pick a self-hosted platform from the table above.

What an open-source framework sends by default

Open source does not mean offline. Three kinds of traffic leave your machine:

The projects that collect telemetry describe it as usage data, not prompts or outputs, and I have no reason to doubt them. Set the variable in CI anyway if your security review asks what a test tool sends.

The larger flow is the one the framework does not control. Every judged metric sends your test case to a model provider. If your cases come from production, that is customer data going to whichever model grades them. The options are a deterministic check where one will do, a judge on the provider you already have a data agreement with, or a local judge: Promptfoo, DeepEval and Inspect AI all document running the judge on Ollama.

The third flow is the upload to a hosted dashboard, and in every framework here it is opt-in: it starts when you log in or run a share command.

Is it still maintained?

A list written in 2024 is a poor guide to what is alive today. As of November 10, 2026:

Three checks take five minutes and are worth doing before you adopt anything. Look at the date of the latest release on PyPI or npm, not the star count. Look at whether the last three months of commits are features or dependency bumps. And find out who pays the maintainers: a company with a product around the library (Promptfoo, DeepEval, Pydantic Evals), a public body (Inspect AI), or one person.

Model benchmark harnesses are a different job

These run a model against public benchmarks. They are the right tool for comparing models in general and the wrong one for testing your application:

A model's score on these does not carry over to your agent, for reasons the LLM benchmarks post goes through with numbers.

How to choose

Then run two candidates on the same thirty cases of your own before committing. An afternoon with your data tells you more than any comparison table, this one included.

One gap is common to almost all of them. They report a score for one version, and a change needs a comparison of two, with some answer to whether the difference is real. Inspect AI gives you standard errors. For the others, run both versions on the same cases, repeat each case, and compare per case. LLM testing covers how, with any of these tools.

FAQ

What is an LLM evaluation framework? A library or command-line tool you run in your own code to test an application built on a language model. You write test cases, choose checks such as assertions, metrics or an LLM judge, and run the suite locally or in CI. It differs from an evaluation platform, which needs a server and scores stored traces, and from a benchmark harness, which tests a model on public tasks.

What is the best open-source LLM evaluation framework? It depends on the job. Promptfoo for comparing prompts and models and for red teaming, DeepEval for metrics inside pytest, Inspect AI for agent evals in sandboxes, Pydantic Evals for typed evals with deterministic tool-call checks, Ragas for RAG metrics, vitest-evals for TypeScript, and EvalShift for comparing two models on recorded agent runs.

Is Promptfoo still open source after the OpenAI acquisition? Yes. OpenAI announced the acquisition on March 9, 2026, and the repository remains MIT licensed, with a release on October 25, 2026. A commercial Enterprise edition exists beside the open-source CLI.

Is DeepEval open source? The DeepEval library is Apache-2.0, including its metrics and test runner. Confident AI, the platform that stores results, compares runs and traces production, is proprietary, with a free plan of 2 seats and 5 test runs a week.

Is Ragas still maintained? As of November 10, 2026 the latest Ragas release is 0.4.3 from January 13, 2026 and the last commit is from February 24, 2026. The repository is not archived and carries no notice. Pin the version if you depend on it.

Which open-source LLM evaluation frameworks work offline? Any of them, for deterministic checks. Judged metrics need a model, so offline means a local judge: Promptfoo, DeepEval and Inspect AI document running the judge on Ollama. Promptfoo, DeepEval, Ragas and Giskard also send usage telemetry by default, each with an environment variable to turn it off.

Which open-source framework is best for evaluating AI agents? One that checks the tool calls and not only the reply. Promptfoo and Pydantic Evals check tool selection, order and arguments deterministically, DeepEval and TruLens score them with a judge, openevals matches a trajectory against a reference, and Inspect AI runs the agent in a sandbox. EvalShift compares two models' tool calls on the same recorded runs.

What is the difference between an LLM evaluation framework and a benchmark harness? A framework tests your application with your own cases. A benchmark harness, such as lm-evaluation-harness or lighteval, runs a model against public benchmarks to compare models in general. A model that scores well in a harness can still fail your application's tests.

Keep reading

• +The best LLM evaluation tools in 2026: the same field including the commercial platforms, compared by the job each does.
• +LLM testing: the types of tests, and how to handle outputs that vary between runs.
• +LLM-as-a-judge: how accurate the judged metrics in these frameworks are, and how to check one.
• +Evaluating agent tool calls: what a framework has to check for an agent.