Braintrust vs Langfuse: Open Source, Self-Hosting and Evals

Braintrust vs Langfuse: License, Hosting, Evals and Pricing at a Glance

Every cell below comes from the Langfuse GitHub organization, the Braintrust GitHub organization or the two vendors' documentation and pricing pages, read on 2026-10-19 (UTC). The sections after the table name the file or page behind each row.

The same questions for other pairs are covered in LangSmith vs Langfuse, LangSmith vs Braintrust and Langfuse vs Phoenix.

Open Source Status: Langfuse's MIT Core and Braintrust's Proprietary Platform

Langfuse is open core. Its LICENSE file says content outside the "ee/", "web/src/ee/" and "worker/src/ee/" directories is under the MIT Expat license, while content inside them falls under the license in "ee/LICENSE". The same file now reads "Copyright (c) 2023-2026 ClickHouse, Inc."

GitHub's license detection does not match that file to a single license, so its API returns NOASSERTION for the repository. A script run on 2026-10-19 downloaded the main branch and counted files per folder; this excerpt of its output shows how much of the code the carve-out covers:

langfuse/langfuse @ bde307305a1b
GitHub licence (spdx_id): NOASSERTION
LICENSE: MIT except 3 ee dirs named
  files in repository             7216
  in the 3 ee dirs LICENSE names   128  1.8%
  in other ee dirs                  12  0.2%
  outside any ee dir              7076  98.1%
    ee/                                             9
    web/src/ee/                                   102
    worker/src/ee/                                 17
    packages/shared/src/server/ee/ (not named)     12

In the script's output, the three folders the LICENSE names hold 128 of 7,216 files (1.8%), most of them in web/src/ee/. A fourth folder, packages/shared/src/server/ee/, holds 12 more files, but the LICENSE text, read on 2026-10-19, does not name it, so check with Langfuse before relying on how those files are licensed.

Braintrust publishes its SDKs, scorers and deployment code, while the platform itself stays closed. The braintrust-sdk-python LICENSE is the Apache License 2.0, as is the AWS Terraform module. The package metadata in the same repository's py/pyproject.toml sets MIT, and the braintrust package on PyPI shows that value, so the LICENSE file and the package disagree.

• Public - the Python, JavaScript, Go and other SDKs, the autoevals scorer library, the GitHub eval action, the Helm chart and the Terraform modules for AWS, GCP and Azure.
• Not public - the web application, the control plane and Brainstore, which the AWS example will not deploy without a brainstore_license_key from the Braintrust UI.
• Vendor framing - Braintrust's own Langfuse comparison article, dated 27 October 2025, lists Braintrust as proprietary and Langfuse as MIT-licensed.

How to Self-Host Langfuse Step by Step

The langfuse/langfuse repository README gives a local start that needs Git and Docker:

git clone --depth=1 \
  https://github.com/langfuse/langfuse.git
cd langfuse
docker compose up

That command reads the docker-compose.yml at the repository root. The same script parsed it on 2026-10-19 and printed each service, its image and whether its ports are published on all interfaces or bound to localhost:

langfuse/langfuse @ bde307305a1b
docker-compose.yml services:
  langfuse-worker  langfuse-worker:4        localhost
  langfuse-web     langfuse:4               public
  clickhouse       clickhouse-server:25.12  localhost
  minio            minio                    public
  redis            redis:7                  localhost
  postgres         postgres:17              localhost
  named volumes: 5   CHANGEME markers: 14
  TELEMETRY_ENABLED default: true

• Replace the defaults - the word CHANGEME appears 14 times in the file: once in the header note that explains it, and 13 more times beside a default password, secret, salt, encryption key or connection string.
• Limit what is reachable - only langfuse-web on port 3000 and MinIO on port 9090 listen beyond localhost, and the file's header recommends restricting inbound traffic on the host to those two.
• Decide on telemetry - TELEMETRY_ENABLED defaults to true, and the README says self-hosted instances report basic usage statistics to PostHog unless you set it to false; it states raw traces, prompts and scores are not included.
• Move to a production layout - Langfuse's self-hosting documentation describes the Compose setup as a "Single VM without high availability, scaling, or backups", and the README calls Kubernetes with Helm the preferred production deployment, with Terraform templates for AWS, Azure and GCP.

No license key is needed for any of this. Langfuse's license-key page, read on 2026-10-19, says "All core Langfuse features and APIs are available in Langfuse OSS (MIT licensed) without any limits" and lists the Enterprise features that do need a key, among them protected prompt labels, data retention policies and the Instance Management API.

How to Self-Host the Braintrust Data Plane Step by Step

Self-hosting Braintrust starts with a contract: Braintrust's self-hosting documentation, read on 2026-10-19, limits self-hosting to the Enterprise plan. Under that plan the customer operates the data plane, which the same page says "consists of the Braintrust API, a PostgreSQL database, Redis cache, object storage, and Brainstore", while Braintrust keeps hosting the control plane that supplies the UI, authentication and metadata.

The documentation says the SDKs and the browser send trace data straight to your data plane, and that the two planes "communicate only for authentication and metadata synchronization." Braintrust's own Langfuse comparison article says "Hybrid deployment is available for enterprise customers"; the current documentation does not use that word and offers a separate BYOC option, "where Braintrust operates the deployment."

On AWS, the work runs through the terraform-aws-braintrust-data-plane module. The production example's README sets out the order:

• Copy the example - put examples/braintrust-data-plane in your own repository and point provider.tf at your account and terraform.tf at your state backend.
• Fetch the license key - copy the Brainstore key from Settings, then Data Plane, in the Braintrust UI, ideally into AWS Secrets Manager.
• Prepare a new account - on a fresh AWS account, run scripts/create-service-linked-roles.sh once.
• Apply and connect - run terraform apply, read api_url from terraform output, and paste it into the same Data Plane settings page; for a trial, the README recommends a new Braintrust organization so live users are not affected.

# sketch of the steps in the module's README
cp -r examples/braintrust-data-plane ../bt-plane
cd ../bt-plane
# edit provider.tf, terraform.tf and main.tf
terraform init
terraform apply
terraform output api_url

The script that read Langfuse's files also downloaded this module's main branch on 2026-10-19 and counted what it declares. Its output, unedited:

braintrustdata/terraform-aws-
  braintrust-data-plane @ a96de1d766b1
GitHub licence (spdx_id): Apache-2.0
  .tf files (no examples): 147   submodules: 21
  resource blocks: 371 of 86 types
    EC2 Auto Scaling groups          4
    ECS services                     5
    Lambda functions                 8
    Load balancers                   9
    S3 buckets                       4
    RDS instances (Postgres)         1
    ElastiCache (Redis)              2
    VPCs                             2
    IAM roles                       21
    Security groups                 21
  examples/*/main.tf  production       sandbox
    Brainstore nodes
      readers       2 x c8gd.4xlarge  1 x c8gd.xlarge
      fast readers  2 x c8gd.4xlarge  none
      writers       1 x c8gd.8xlarge  1 x c8gd.xlarge
    Postgres (RDS)  db.r8g.2xlarge    db.r8g.large
    Postgres GB     1000              100
    Redis           cache.r7g.large   cache.t4g.small
  example requires brainstore_license_key: yes

The 371 resource blocks in the script's output include optional ones that flags switch on, such as the Redis replication group, so one deployment need not create all of them. The module's README calls the default configuration "a large production-sized deployment", and the sandbox example trims Brainstore to one reader and one writer, which the sandbox example's README calls "not suitable for workload testing or performance evaluation".

Trace Storage: Brainstore in Braintrust, ClickHouse in Langfuse

Langfuse writes traces, observations and scores to ClickHouse, keeps transactional data in PostgreSQL, uses Redis for queues and cache, and persists incoming events and exports in S3-compatible storage, per its self-hosting documentation. ClickHouse's own acquisition post adds that "Langfuse's architecture runs entirely on ClickHouse, both in the cloud offering and for self-hosted deployments."

Langfuse's maintainers posted the "ClickHouse acquires Langfuse" announcement on GitHub on January 16, 2026, saying "Langfuse is joining ClickHouse", and ClickHouse's post says Langfuse stays "open-source under its existing MIT license for core features" and that "Langfuse Cloud continues operating as a standalone service". If you self-host, the database under your traces is now made by the company that owns the application.

Brainstore is Braintrust's own engine. Braintrust's architecture documentation describes it this way:

• Write path - "Every write appends to a WAL on object storage", and processing then assigns records to time-ordered segments.
• Stateless nodes - because object storage is the source of truth, Brainstore nodes "can be replaced without data loss."
• Node roles - writers ingest spans, readers serve API and BTQL queries, and fast readers serve predictable UI queries, which matches the three Brainstore pools in the module output above.
• PostgreSQL - stores the metadata the platform needs and "is not the primary store for your AI data."

The practical difference for an operator: Langfuse asks you to run and back up a ClickHouse server, while on AWS Braintrust asks you to run EC2 fleets that keep their durable state in S3.

Tracing and OpenTelemetry Support in Braintrust and Langfuse

Both platforms accept OpenTelemetry, from different starting points. The langfuse-python repository calls its SDK OpenTelemetry-based and marks the older v2 client API as deprecated.

Braintrust ships its own SDK and adds OpenTelemetry as an option. The braintrust pyproject.toml defines an otel extra that pulls in the OpenTelemetry API, SDK and OTLP HTTP exporter, and Braintrust's OpenTelemetry documentation gives an /otel/v1/traces endpoint that takes an x-bt-parent header naming the project or experiment.

• Instrumentation already on OpenTelemetry - both accept OTLP, so the choice of backend does not force a rewrite of your spans. Beyond spans, the OpenTelemetry GenAI metrics define histograms and counters for operation duration and token usage.
• Self-hosted Braintrust - the same endpoint path sits on your own data plane URL, per Braintrust's documentation.
• Agent traces - for which spans and attributes to record on tool calls and model calls, see AI agent tracing.

Evals, CI Gates and Prompt Management in Braintrust vs Langfuse

Braintrust's SDK quickstart opens with an eval, and the Langfuse Python SDK README lists tracing first, yet both now cover the other's ground. What still differs is how an eval is written and what happens to a pull request when scores drop.

How Braintrust and Langfuse Pricing Models Differ

The two clouds bill on different units, and neither pricing page, read on 2026-10-19, lists a per-seat price. What each one meters:

• Braintrust - Starter and Pro meter processed data in gigabytes, scores in thousands and model credits, with users, projects, experiments and datasets unlimited; Enterprise terms are custom.
• Langfuse Cloud - Hobby, Core, Pro and Enterprise meter units, and Langfuse's billable-units documentation says "Units are either traces, observations or scores". Only Hobby limits users.
• Self-hosting - the same documentation says self-hosted Langfuse OSS has no usage-based billing, while self-hosted Langfuse Enterprise uses billable units as one component of its price; Braintrust self-hosting sits inside an Enterprise contract on top of the cloud resources the data plane runs on.

Self-hosted Langfuse turns paid only for the ee features: the ee/LICENSE says that software "may only be used" with a valid Langfuse Enterprise License. Estimate trace volume first, because an agent run that logs many spans grows the Langfuse unit count and the Braintrust processed-data figure at different rates.

Braintrust and Langfuse Strengths by Area

Both ship Kubernetes charts for production, in the langfuse-k8s repository and the braintrustdata/helm repository.

Checking Agent Actions Beyond Braintrust and Langfuse Traces

A Braintrust score or a Langfuse trace describes the output an agent produced and the spans its code emitted. When the agent edits files, opens tickets or issues refunds, those records alone do not show whether the ticket system or the ledger really changed as reported.

TestMu AI's Agent Assurance is built for that question and runs before release. Given the agent's code, its PRD or spec, or an API spec for an agent whose code you cannot open, it drafts functional and adversarial scenarios, attaches acceptance criteria to each, and calls the real agent in a staging environment.

• Declared tools - the tool calls observed in a run are matched against the agent's declared tool list, so a call that a scenario rules out is caught.
• Profile paths - files written under the paths your profile names, plus any artifacts the run produced, count as evidence.
• Record checks - an MCP tool that you provide and approve, a status endpoint or a collect hook reads the affected record without changing it.
• Outcome per criterion - each criterion gets Pass or Fail, or Unable to Verify when it could not be checked; model judges handle the scoring for some of them, and the agent's own report of an action never counts as proof.

Agent Assurance reaches your terminal as Rook CLI. It is pre-alpha and publicly installable, with npm as the main route:

npm install -g @testmuai/rook

Node.js 20 or newer is required for the npm install, and the Rook CLI installation guide adds Homebrew and a shell installer, both limited to macOS and Linux. Taken together, the routes reach macOS and Linux, and 64-bit Windows through npm or WSL.

Only scenarios with a decided verdict enter the scenario pass rate, and the rook release repository README says anything it "could not verify is reported as unverifiable", with a count of its own. Point every run at staging, because anything the agent writes in a run stays written, and keep Braintrust or Langfuse for your traces and scores.

Questions to Answer Before a Braintrust or Langfuse Trial

Answer these in order before starting a Langfuse vs Braintrust trial.

• Data location - decide whether only trace data or every component must stay in your network; self-hosted Langfuse runs every component there, while Braintrust keeps the UI, login and metadata in its own control plane.
• License - if you need to read, patch or fork the application, check whether the features you need sit outside the ee folders, the largest being Langfuse's web/src/ee folder.
• Operations - price the Braintrust module's default fleets in your cloud, or the ClickHouse, PostgreSQL and Redis upkeep a Langfuse install brings.
• CI behavior - decide whether a score regression should fail the build or only be reported on the pull request.
• Billing unit - estimate monthly spans and scores, then compare Langfuse units with Braintrust processed data on the same volume.
• Actions - list the tools and records your agent touches, and decide how a release proves those changes happened.

For the last item, write the acceptance criteria for one tool-calling flow and run them on staging; run Agent Assurance in CI/CD shows how to gate a release on the JSON report.