LangWatch: Open Source Machine Learning Infrastructure

What is LangWatch?

What it is

LangWatch is an open-source TypeScript platform for LLM evaluations and AI agent testing, licensed under Apache-2.0. It lives in the machine-learning infrastructure ecosystem for teams that build LLM-powered agents and need to test, simulate, evaluate, and monitor agents before release and in production.

The problem it addresses is the gap between agent demos and reliable production systems. Teams need regression testing, simulations, trace analysis, prompt iteration, and cost governance, but custom tooling creates glue code and tool sprawl. LangWatch connects tracing, datasets, evaluation, prompt optimization, annotations, and an AI gateway in one loop.

Key capabilities

End-to-end agent simulations run scenarios against the full stack, including tools, state, a user simulator, and a judge, to pinpoint where an agent breaks down to each decision.
The evaluation loop links traces to datasets, offline evaluation, prompt and model optimization, and re-testing, reducing custom integration code between separate tools.
The platform is OpenTelemetry and OTLP native, and it is designed to be framework agnostic and LLM-provider agnostic, which supports open standards.
The AI Gateway provides an OpenAI-compatible and Anthropic-compatible proxy with virtual keys, hierarchical budgets, inline guardrails, automatic fallback across providers, and Anthropic cache_control passthrough; it ships as a separate Go binary in services/aigateway/ with a Helm sub-chart in charts/gateway/, and the README states about 700 ns hot-path overhead.
Collaboration features include run review, failure annotation, annotation queues, GitHub prompt integration, and links between prompt versions and traces, giving domain experts and engineers shared evidence.

Who uses it and how

Teams developing LLM agents use LangWatch to run regression tests and simulations before release, then monitor behavior and cost in production.
Prompt and model users trace runs, collect them into datasets, evaluate them, adjust prompts or models, and re-test the changed agent.
Domain experts and reviewers use annotations and queues to label edge cases, while engineering teams keep prompts in Git through the GitHub integration and link versions to traces.
Self-hosting and cloud teams run LangWatch locally with Node.js or Docker Compose, deploy it on Kubernetes with Helm, or use a free account and API key.

Getting started

The hosted path is to create a free account, create a project, and copy the API key. Local paths are npx @langwatch/server, Docker Compose from the repository, and Kubernetes Helm deployment, with the UI at http://localhost:5560.

When to use it — and when not to

LangWatch fits teams that want an open-source, self-hostable platform for agent evaluation, observability, prompt management, and LLM gateway governance. Self-hosters must operate Postgres, Redis, ClickHouse, the AI gateway binary, and optional evaluators or assistants. A weakness is that the project is young, the repository lists zero contributors and 939 open issues, and the local Langy assistant runs workers unsandboxed.

project readme (upstream, from github) — read inline

Website · Docs · Discord · Self-hosting

Why LangWatch?

The platform for LLM evaluations and AI agent testing. We help teams test, simulate, evaluate, and monitor LLM-powered agents end-to-end — before release and in production. Built for teams that need regression testing, simulations, and production observability without building custom tooling.

End-to-end agent simulations Run realistic scenarios against your full stack (tools, state, user simulator, judge) and pinpoint where your agents break, and why? down to each decision.
Eval + observability + prompts in one loop Trace → dataset → evaluate → optimize prompts/models → re-test. No glue code, no tool sprawl.
Open standards, no lock-in OpenTelemetry/OTLP-native. Framework- and LLM-provider agnostic by design.
AI Gateway for governance + cost control OpenAI/Anthropic-compatible proxy with virtual keys, hierarchical budgets, inline guardrails, automatic fallback across providers, and Anthropic cache_control passthrough. ~700 ns hot-path overhead. Ships as a separate Go binary (services/aigateway/) + Helm sub-chart (charts/gateway/).
Collaboration that doesn't slow shipping Review runs, annotate failures, and ship fixes faster. Let domain experts label edge cases with annotations & queues, keep prompts in Git with the GitHub integration, and link prompt versions to traces.

LangWatch gives you full visibility into agent behavior and the tools to systematically improve reliability, performance, and cost, while keeping you in control of your AI system

Getting Started

Cloud ☁️

The easiest way to get started with LangWatch.

Create a free account → create a project → get started/ copy your API key.

Local setup 💻

The fastest way to run LangWatch locally — only Node.js required:

npx @langwatch/server

The CLI installs uv, postgres, redis, clickhouse, the AI gateway binary, and the Langy assistant's runtime into ~/.langwatch/, scaffolds a .env with locally-generated secrets, then starts every service in parallel and opens http://localhost:5560. Everything lives under ~/.langwatch/; rm -rf ~/.langwatch is a clean reset.

Three pieces are yours to decide on, in ~/.langwatch/.env:

Variable	Default	What it changes
`LANGWATCH_ENABLE_LANGY`	`true`	The Langy assistant. Adds ~45MB for its runtime; the workers run unsandboxed as you, on your own machine.
`LANGWATCH_ENABLE_PRESIDIO`	`false`	The PII detection evaluator. Adds ~670MB of language model, larger than the rest of the evaluator environment put together. LangWatch's own secret and PII redaction of your traces does not depend on it.
`LANGWATCH_ENABLE_LINGUA`	`false`	The language detection evaluator. Adds ~95MB of language models.

Every other evaluator is installed either way. Change any of these in ~/.langwatch/.env and restart the server.

Prefer Docker? You can still use docker compose:

git clone https://github.com/langwatch/langwatch.git
cd platform/app
cp platform/app/.env.example platform/app/.env
docker compose up -d --wait --build

Once running, LangWatch will be available at http://localhost:5560, where you can create your first project and API key.

Deployment options ⚓️

Run LangWatch on your own infrastructure:

Docker Compose - Run LangWatch on your own machine.
Kubernetes (Helm) - Run LangWatch on a Kubernetes cluster using Helm.
OnPrem - Cloud-specific setups for AWS, Google Cloud, and Azure.

Hybrid (OnPrem data) 🔀

For companies that have strict data residency and control requirements, without needing to go fully on-prem.

🚀 Quick Start

Ship safer agents in minutes. Create a free account, then dive into these guides:

Run your first agent simulation - Test agents against realistic scenarios before production
Set up evaluations - Measure quality, performance, and reliability
Send your first traces - Integrate LangWatch with your stack
Get started with LangWatch MCP - Use LangWatch in Claude Desktop and other MCP clients

🗺️ Integrations

LangWatch builds and maintains several integrations listed below. Our tracing platform is built on top of OpenTelemetry, so we support any OpenTelemetry-compatible library out of the box.

Frameworks:
LangChain · LangGraph · Vercel AI SDK · Mastra · CrewAI · Google ADK

Model Providers:
OpenAI · Anthropic · Azure OpenAI · Google Vertex AI · AWS Bedrock · Groq · Ollama

Platforms

LangFlow · Flowise · n8n

and many more…

Are you using a platform that could benefit from a direct LangWatch integration? We'd love to hear from you, please [**fill out

Frequently asked questions

Is LangWatch free to use?

LangWatch is open source under the Apache-2.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does LangWatch do?

Simulation-based testing and evaluation for AI agents

What is LangWatch written in?

LangWatch is primarily written in TypeScript. Its source is publicly available at https://github.com/langwatch/langwatch, and it has 4,810 GitHub stars.