Regressa
v0.1 · open source · MIT-friendly self-hosting

Catch AI regressions before your users do.

Regressa logs every LLM call, versions every prompt change, scores output quality automatically, and alerts you the moment quality drops, cost spikes or latency degrades.

Get started Architecture GitHub

OpenAI Anthropic OpenTelemetry Node Python Go Java

Prompt versioning

Every distinct template hash becomes a version. Compare quality, latency, error rate and cost across versions, with a line diff.

Automated evals

LLM-as-judge with rubrics, semantic similarity to a golden set, or your own sandboxed scoring function. Sampled per template.

Regression alerts

Thresholds, percent change, rolling-baseline anomaly detection and budget caps. Slack, signed webhooks, email.

CI gate

npx @regressa/node gate blocks a merge when a prompt change regresses against production. Ships as a GitHub Action.

Governance

PII redaction at ingest, per-project retention, budget-driven sampling, OIDC SSO, roles and a full audit log.

Any stack

SDKs for Node, Python, Go and Java that wrap OpenAI and Anthropic clients in two lines, plus native OpenTelemetry ingestion.

Two lines to instrument

Wrap the client you already use. Declare the template and Regressa does the rest.

import OpenAI from "openai";
import { Regressa, wrapOpenAI } from "@regressa/node";

const regressa = new Regressa();               // REGRESSA_API_KEY
const openai = wrapOpenAI(new OpenAI(), regressa);

await openai.chat.completions.create({
  model: "gpt-4o-mini",
  messages,
  regressa: { promptTemplate: { name: "support-agent", raw: TEMPLATE } },
});
from openai import OpenAI
from regressa import Regressa, wrap_openai

regressa = Regressa()                           # REGRESSA_API_KEY
openai = wrap_openai(OpenAI(), regressa)

openai.chat.completions.create(
    model="gpt-4o-mini",
    messages=messages,
    regressa_prompt_template={"name": "support-agent", "raw": TEMPLATE},
)
client := regressa.New(regressa.Options{})     // REGRESSA_API_KEY
defer client.Shutdown(ctx)

span := client.Start("gpt-4o-mini", regressa.OpenAI, msgs,
    regressa.WithTemplate("support-agent", template))
resp, err := provider.Call(ctx, req)
span.End(resp.Text, resp.PromptTokens, resp.CompletionTokens, err)
Regressa regressa = Regressa.builder().build();   // REGRESSA_API_KEY

Regressa.Span span = regressa.start("gpt-4o-mini", "openai")
    .message("system", prompt).message("user", question)
    .template("support-agent", TEMPLATE);
try { span.end(out, promptTokens, completionTokens); }
catch (Exception e) { span.fail(e); throw e; }

How it works

Stateless ingest, queued workers, TimescaleDB for time series, Next.js dashboard.

IngestSDKs batch traces to the ingest API. Keys are hashed, payloads validated item by item, budgets enforced.
Version and storeThe worker hashes the normalized template, detects new versions, redacts PII and writes to a hypertable.
ScoreSampled traces are scored by your evals. Results are stored per trace and aggregated per version.
Alert and gateRules run every minute. CI asks the gate for a verdict before a prompt change ships.
0SDKs · Node, Python, Go, Java
0eval types out of the box
0alert evaluation cadence
0to instrument a client

Run it locally in two minutes

git clone https://github.com/dwarka-prasad/regressa && cd regressa
cp .env.example .env && pnpm install
pnpm infra:up && pnpm db:migrate && pnpm db:seed
pnpm dev     # dashboard :3100 · ingest :4100 · worker

Ship prompt changes with confidence.

Self-host in minutes. Gate every prompt change in CI.

Set up the CI gate