## The best open-source LLM evaluation frameworks in 2026

URL: https://www.evalshift.dev/blog/open-source-llm-evaluation-frameworks
Published: 2026-11-18
Tag: tools
Summary: Ten open-source LLM evaluation frameworks compared on license, maintenance, telemetry defaults, judge costs, agent checks and CI, as of November 2026.

Takeaways:
- The best open-source LLM evaluation framework depends on the job: as of November 2026, 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 and vitest-evals for TypeScript.
- Several open-source LLM evaluation projects went quiet or ended in 2026: Ragas has had no release since January 13 and no commit since February 24, Evalite was archived on November 9, HELM entered maintenance mode on June 1, and OpenAI's hosted Evals product shuts down on November 30.
- In most open-source LLM evaluation frameworks the library is open and the results dashboard is not: DeepEval is Apache-2.0 and Confident AI is proprietary, Pydantic Evals is MIT and Logfire is paid, openevals is MIT and LangSmith is proprietary. Inspect AI is MIT with no commercial edition.
- Open source does not mean offline: Promptfoo, DeepEval, Ragas and Giskard send usage telemetry by default, each with an environment variable to turn it off, and every LLM-judged metric sends the test case to a model provider unless the judge runs locally.
- Arize Phoenix and its evals package use the Elastic License 2.0, which is source-available and not an OSI-approved open-source license; Langfuse is MIT except for enterprise folders, and Opik and MLflow are Apache-2.0.

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

| Framework | License | Language | Latest release | GitHub stars | Best for |
| --- | --- | --- | --- | --- | --- |
| [Promptfoo](#promptfoo) | MIT | Node CLI, YAML config | 0.125.1, Oct 25, 2026 | 27.0k | Comparing prompts and models; red teaming |
| [DeepEval](#deepeval) | Apache-2.0 | Python | 4.3.3, Nov 4, 2026 | 19.4k | Prebuilt metrics in a pytest suite |
| [Inspect AI](#inspect-ai) | MIT | Python | 0.3.289, Nov 10, 2026 | 3.2k | Agent evals in sandboxes, with error bars |
| [Pydantic Evals](#pydantic-evals) | MIT | Python | 2.66.0, Nov 4, 2026 | 21.1k (the pydantic-ai repo) | Typed, code-first evals; deterministic tool-call checks |
| [Ragas](#ragas) | Apache-2.0 | Python | 0.4.3, Jan 13, 2026 | 16.3k | RAG metrics |
| [openevals](#openevals) | MIT | Python, TypeScript | 0.2.2, Oct 22, 2026 | 1.3k | Evaluator functions, with LangSmith around them |
| [Giskard](#giskard) | Apache-2.0 | Python 3.12+ | 3.0.1, Oct 2, 2026 | 5.9k | Scenario tests and vulnerability scans for agents |
| [TruLens](#trulens) | MIT | Python | 2.16.0, Oct 19, 2026 | 3.6k | Judged RAG and agent metrics over OpenTelemetry traces |
| [vitest-evals](#vitest-evals) | Apache-2.0 | TypeScript | 0.18.1, Nov 7, 2026 | 0.4k | Evals as Vitest tests |
| [EvalShift](#evalshift) | CLI Apache-2.0, SDK and Action MIT | Python | 1.6.2, Oct 27, 2026 | 12 | Comparing two models or prompts on recorded agent runs |

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](#open-source-platforms-with-an-evaluation-feature),
and [the LLM evaluation tools comparison](/blog/best-llm-evaluation-tools) 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](#model-benchmark-harnesses-are-a-different-job).

## 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](https://www.promptfoo.dev/docs/getting-started/) 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:

```yaml
# 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
```

```bash
npx promptfoo@latest eval
```

Its [assertions](https://www.promptfoo.dev/docs/configuration/expected-outputs/) 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](https://techcrunch.com/2026/03/09/openai-acquires-promptfoo-to-secure-its-ai-agents/),
  and the [README](https://github.com/promptfoo/promptfoo) says it remains open source. A
  commercial Enterprise edition sits beside it.
- **What leaves your machine:** [usage telemetry](https://www.promptfoo.dev/docs/configuration/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](https://www.promptfoo.dev/docs/configuration/caching/). 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](https://deepeval.com/docs/getting-started) 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:

```python
# 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])
```

```bash
deepeval test run test_refunds.py
```

It ships more than 50 metrics across RAG, agents, conversations and safety. Its
[metrics page](https://deepeval.com/docs/metrics-introduction) 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](https://deepeval.com/docs/data-privacy) 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](https://inspect.aisi.org.uk/) 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:

```python
# 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(),
    )
```

```bash
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](https://inspect.aisi.org.uk/model-graded.html)
  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](https://github.com/pydantic/pydantic-ai/blob/main/docs/evals.md) 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.

```python
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](https://github.com/pydantic/pydantic-ai/blob/main/docs/evals/evaluators/agentic.md)
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](https://docs.ragas.io/en/stable/concepts/metrics/available_metrics/) 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](https://pypi.org/project/ragas/), 0.4.3, is from
January 13, 2026, and the [last commit](https://github.com/vibrantlabsai/ragas/commits/main/) 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](https://github.com/vibrantlabsai/ragas) 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](https://github.com/langchain-ai/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](https://github.com/langchain-ai/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](https://github.com/Giskard-AI/giskard-oss) 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](https://github.com/Giskard-AI/giskard-oss/blob/main/libs/giskard-core/README.md)
  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](https://github.com/truera/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](https://github.com/mattpocock/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](https://github.com/getsentry/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](/docs) 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](/docs/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](https://github.com/evalshift/evalshift-cli), 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](https://github.com/braintrustdata/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](https://github.com/evidentlyai/evidently)** (Apache-2.0): text descriptors and
  LLM judges inside a broader ML monitoring library. No agent or tool-call checks.
- **[azure-ai-evaluation](https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/evaluation/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](https://github.com/google/adk-docs/blob/main/docs/evaluate/index.md)**
  (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](https://github.com/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](https://developers.openai.com/api/docs/deprecations), 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:

| Platform | License | What sits outside it |
| --- | --- | --- |
| Langfuse | MIT, except its `ee` folders | [A license key](https://langfuse.com/self-hosting/license-key) unlocks audit logs, data retention policies, project-level roles and SCIM. Tracing, evaluations, experiments and prompt management are in the MIT part. |
| Opik | Apache-2.0 | The full platform is free to self-host; Comet sells the cloud. |
| MLflow | Apache-2.0 | Databricks runs a managed version, and a few judges exist only there. |
| Arize Phoenix | Elastic License 2.0 | Not an OSI-approved open-source license: you can run and modify it, but not offer it to others as a hosted service. The separate [`arize-phoenix-evals`](https://pypi.org/project/arize-phoenix-evals/) package carries the same license. |

## What "open source" covers in each framework

| Framework | Open | Paid or closed around it |
| --- | --- | --- |
| Promptfoo | CLI, assertions, red teaming, local viewer | Enterprise edition; owned by OpenAI |
| DeepEval | Metric library and test runner | Confident AI: dashboards, comparison, tracing |
| Inspect AI | Everything | Nothing |
| Pydantic Evals | Library | Logfire, the hosted results UI |
| Ragas | Library | Nothing found |
| openevals | Evaluator functions | LangSmith, including the documented CI path |
| Giskard | Checks and scan libraries | Giskard Hub |
| TruLens | Library | Nothing on its site |
| vitest-evals | Library and GitHub Action | Nothing found |
| EvalShift | CLI, capture SDK, GitHub Action | Hosted gate, run history, baselines |

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:

| Framework | Usage telemetry | How to turn it off |
| --- | --- | --- |
| Promptfoo | On by default | `PROMPTFOO_DISABLE_TELEMETRY=1` |
| DeepEval | On by default (PostHog) | `DEEPEVAL_TELEMETRY_OPT_OUT=1` |
| Ragas | On by default | `RAGAS_DO_NOT_TRACK=true` |
| Giskard | On unless disabled (PostHog) | `DO_NOT_TRACK=1` or `GISKARD_TELEMETRY_DISABLED=1` |
| Inspect AI | None described in its docs | |
| Pydantic Evals | None described in its docs | |
| EvalShift | None | |

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:

| Project | Status |
| --- | --- |
| Ragas | Latest release January 13, 2026; last commit February 24, 2026 |
| Evalite | Archived November 9, 2026 |
| openai/evals | Last PyPI release May 2024; the hosted product shuts down November 30, 2026 |
| agentevals | Last PyPI release July 2025; evaluators continue in openevals |
| Giskard 2.x | No longer actively maintained; version 3 is a rewrite |
| HELM | In [maintenance mode](https://crfm-helm.readthedocs.io/en/latest/maintenance_mode/) since June 1, 2026: no new features or leaderboard evaluations |

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:

| Harness | License | What it runs | Status |
| --- | --- | --- | --- |
| [lm-evaluation-harness](https://github.com/EleutherAI/lm-evaluation-harness) | MIT | More than 60 academic benchmarks with hundreds of subtasks | v0.4.13, August 2026 |
| [Inspect Evals](https://github.com/UKGovernmentBEIS/inspect_evals) | MIT | A library of benchmark implementations on Inspect AI | v0.28.0, November 2026 |
| [lighteval](https://github.com/huggingface/lighteval) | MIT | Hugging Face's toolkit, with more than 1,000 tasks | v0.13.0, November 2025 |
| [OpenCompass](https://github.com/open-compass/opencompass) | Apache-2.0 | More than 100 datasets | Active |
| [HELM](https://github.com/stanford-crfm/helm) | Apache-2.0 | Stanford CRFM's holistic evaluation suite | Maintenance mode |

A model's score on these does not carry over to your agent, for reasons
[the LLM benchmarks post](/blog/llm-benchmarks) goes through with numbers.

## How to choose

| If you need to | Start with |
| --- | --- |
| Compare prompts or models on your data before launch | Promptfoo |
| Red team an app | Promptfoo, or Giskard's scan |
| Add quality metrics to a pytest suite | DeepEval |
| Score a RAG pipeline | Ragas pinned to 0.4.3, or DeepEval's RAG metrics |
| Run agents in sandboxes, with repeats and error bars | Inspect AI |
| Check tool calls deterministically in Python | Pydantic Evals, or Promptfoo's trajectory assertions |
| Write evals in TypeScript | vitest-evals, or Promptfoo |
| Keep everything offline | Inspect AI or Promptfoo with a local judge, telemetry off |
| Decide whether a model or prompt change is safe to ship | EvalShift |

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](/blog/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](/blog/best-llm-evaluation-tools): the same field
  including the commercial platforms, compared by the job each does.
- [LLM testing](/blog/llm-testing): the types of tests, and how to handle outputs that vary
  between runs.
- [LLM-as-a-judge](/blog/llm-as-a-judge): how accurate the judged metrics in these frameworks
  are, and how to check one.
- [Evaluating agent tool calls](/blog/evaluating-agent-tool-calls): what a framework has to check
  for an agent.