Run your first evaluation.

What variA/Bly does, how the scoring works, and where to start depending on why you are here.

Create an account and a project, generate an API key, install the SDK, set two environment variables.

Run the same platform inside your own infrastructure, so evaluation data never leaves your network. Available on Enterprise.

What you can evaluate, which guide fits the shape of your application, and how measuring turns into deciding.

Install the SDK, set two environment variables, and get your first score in about five minutes.

Pass your retrieved context so grounding can be scored instead of reported as not-applicable.

Give your retriever and your generator their own scores, so a bad answer points at the component that caused it.

Link turns into a session and get coherence, contradiction and quality trend scored across them.

A complete setup for agentic systems: trajectory, tool-call correctness, cross-step coherence and aggregation grounding, scored across every step.

Instrument every node in a StateGraph with one call, and keep it working when you add a node.

Score the things your app is actually for, and weight the ones that decide whether you ship.

Build the number you actually ship on, from the dimensions you choose and the weights you give them.

What the six categories mean, why determinism matters, and why N/A is not zero.

Observe tells you where you stand. BYOR tells you whether a change helped — same traffic, same moment, attributable.

Run both against the same traffic and get a statistical verdict rather than an impression.

Tell a real difference from noise, a big difference from a trivial one, and a current result from a stale one.

Keep every prompt version so a score change can be traced to a diff.

Collect real prompts and the answers you would want, so prompt generation is shaped by your domain.

What a gate is, the two credentials, and what a flag actually evaluates to.

Read flags on your server and in the browser, bootstrap the first paint, and update live.

Read flags on a Node server, with streaming updates and start-up validation.

One flag, a different answer per environment — and per tenant, if that is how you are organised.

Flags in the browser, bootstrapped for the first paint and updating live.

Who gets what, the order it is decided in, and why a rule is not firing.

Read flags from Python, including the config shape that is easy to get wrong.

Read flags from Go, with typed accessors and an explicit not-found error.

The endpoint every SDK wraps, both credential forms, and what each reason means.

Every field on a gate — key, type, default value, client-side visibility, rules and overrides.

Set a threshold on any dimension and get told when quality drops.

Mark what each LLM call is, so grounding is reported as not-applicable on routers and classifiers instead of scored as zero.

Canonical names that let a failing dimension be linked to the setting behind it, grouped by the dimension each one informs.

Zero grounding scores, missing evaluations, key confusion, and the rest of the usual suspects.

Short answers on integration, agent and RAG evaluation, determinism, N/A versus zero, and self-hosting.