Skip to content
LogluneStart free

Feature-flag platform

Loglune feature flags for a customer’s bug: Reproduce past flags.

Without Loglune: your team collects the targeting rules, rollout split and change history from the time of the report, then rebuilds the flag state by hand.

With Loglune: Loglune reproduces the flag evaluation at any past time from the recorded change history, without changing production.

Loglune is a feature-flag platform for B2B software teams that records every flag change and reproduces the flag evaluation from any past moment in dev, CI or staging, without touching production. Development teams at B2B software companies choose Loglune because they can trust its reproductions: each one matches production on the ruleset version, the percentage-rollout hash, the evaluation time and the prerequisite order.

REPRO
91%
of developers carry defects they cannot reproduce (Undo.io).
RATIO
1:1
one replay delivery equals one reproduction — no idle-hour charge.
INCL
100
reproductions included every month on every paid plan.
OVER
$1
per reproduction after the included 100.

The problem

The bug lives in their configuration, not your code path

A defect that only fires under one customer’s flag, plan, and config combination is one your team can’t recreate at their own desk. Support and engineering are left guessing at a state they can’t see.

  • “Works on my machine.”

    closed · could-not-reproduce

  • Which flags were on for this tenant?

    support → engineering

  • Can’t repro the customer’s plan state.

    P1 · blocked

  • Only fires for one account in prod.

    incident · unresolved

  • Their rollout is at 100, ours is off.

    config drift

Loglune closes every one of these: pick the customer’s flag state and reproduce it in your own environment in a single step.

The guide How to reproduce a bug that only happens for one customer walks through the steps.

Reproduce from production

From production to your dev environment.

Loglune already evaluated the flag for your production app and recorded the result. Point at that record — or any past moment — and the engine folds the event log to that version; your machine, your CI or your staging asks for that version and gets the answers production got. There is no new runtime to adopt — Loglune’s SDK is one HTTP call from the environment you already ship from.

Your production · @ T

acme-corp · ruleset v128

  • checkout-v2on
  • new-billing40% rollout
  • beta-dashboardoff

loglune · replay

ruleset v128

3 flags · folded to 2026-08-22

materialised

Your dev / CI

cannot reproduce

closed · could-not-reproduce

reproduced locally

one command · your machine

The benefit: the ticket that was closed “could-not-reproduce” now reproduces on your own machine in one command — no staging slot to book, no guessing which flags were on for that account.

How it works

Four steps, one reproduction

Loglune’s SDK sends each context to Loglune and shows the answer; the rules and the engine stay on our side. Pin a version and the same call replays it in your dev, CI or staging.

Run every step from your AI agent (MCP) or the loglune CLI →
  1. 01Define
  2. 02Publish
  3. 03Evaluate
  4. 04Reproduce
  1. Define

    Edit flags, config, targeting and segments in the console or API. Every change is appended as an immutable MutationEvent — the tenant’s log is the source of truth.

  2. Publish

    Freeze the draft into an immutable, numbered Ruleset version and materialise it to KV and R2 for Loglune’s evaluation endpoint to serve.

  3. Evaluate

    Your app sends the context through Loglune’s SDK; Loglune evaluates the live Ruleset and answers with the variation and a record of the version, context and variation it returned.

  4. Reproduce

    Pick a tenant and a moment — a timestamp or a bug’s recorded version. The engine folds the log to that point and replays the exact Ruleset into dev, CI or staging.

The console

This is the console you actually get

A JS-free, form-native workspace: pick a published version, read the flags that were live, and replay that exact ruleset into your own dev or CI — the reproduction meter counting each delivery. Below is the console exactly as it opens with no tenant selected, on an honestly-labelled example dataset. The real workspace opens when you sign in.

Exactness

A replay is bit-identical to what production returned

“Almost right” is worthless for a bug repro. A reproduction re-runs the engine that answered production against the folded ruleset, so four things that a snapshot or a rollback would get wrong are resolved exactly as they were at the moment the bug fired.

AspectReproduced exactlyNot
Rule versionTargeting is evaluated against the ruleset that was live at Tnot today’s rules
BucketingPercentage rollout hashes on flag key + context, identically live and in replaynot a re-rolled dice
Time-dependent rulesDate and schedule conditions are evaluated at the reproduced moment Tnot the replay wall-clock
PrerequisitesFlag-to-flag dependencies resolve in the log’s causal ordernot an arbitrary order

The bucketing hash is deterministic on flag key plus context, so a percentage rollout lands a given user in the same bucket in the live evaluation and in every replay — the reproduction never re-rolls the dice.

Data handling

What we hold, and what we don’t

We act as a processor for your flag data. What we hold is configuration — flag rules, targeting and versions — not the people behind them.

What we store
Your flag, config, targeting and segment definitions, the MutationEvent log, Ruleset versions and evaluation records — never end-user content.
Where
D1 for the event log and metadata, R2 for Ruleset blobs, KV for delivery. Isolated per tenant, egress $0.
Access
Only an authorized live or replay delivery reads a tenant’s data. Cross-customer access is forbidden.
Deletion
Retention follows your DPA and per-tenant settings; a deletion request removes the tenant’s events, versions and records — return or delete on exit.
Use
Your flag data drives the platform and reproductions only — no ads, no model training, no analytics.

Pricing

Usage-based. You pay for reproductions you run.

Choose who the plan is for

Free

$0/ month

  • 1 seat
  • 5 reproductions per month
  • Hard cap — no overage charge
  • 7-day history
  • 1 environment
  • Replay into dev, CI and staging
Start free

Plus

Most individuals

$20/ month

  • Everything in Free, plus
  • 100 reproductions per month, up from 5
  • $1 per reproduction past the included 100 — no hard cap
  • Unlimited history — time-travel to any past version, up from 7 days
  • Unlimited environments, up from 1
  • Live evaluation in production
  • MCP server — connect your own AI agent
Start with Plus

Pro

Coming soon

$100/ month

  • Everything in Plus, plus
  • Loglune-run AI — bug resolution and flag removal on our model account (coming soon)
  • 100 AI credits per seat per week, then $0.10 per credit up to your spend cap

Coming soon

Team Standard

Most teams

$20/ seat / month

  • 2–50 seats · $40 / month floor
  • 100 reproductions per month
  • $1 per reproduction past the included 100
  • Unlimited history — time-travel to any past version
  • Unlimited environments
  • Live evaluation in production
  • MCP server — connect your own AI agent
  • Member and role management
  • Single sign-on (SSO)
  • Audit log
  • Centralized billing
  • Usage analytics
Get started

Team Premium

Coming soon

$100/ seat / month

  • 2–50 seats · $200 / month floor
  • Everything in Team Standard, plus
  • Loglune-run AI — bug resolution and flag removal on our model account (coming soon)
  • 100 AI credits per seat per week, then $0.10 per credit up to your spend cap

Coming soon

Enterprise

Custom/ month

  • 50+ seats
  • Reproduction volume and pricing by agreement
  • Unlimited history — time-travel to any past version
  • Unlimited environments
  • Live evaluation in production
  • MCP server — connect your own AI agent
  • Member and role management
  • Single sign-on (SSO)
  • Audit log
  • Centralized billing
  • Usage analytics
  • Loglune-run AI — bug resolution and flag removal (coming soon)
  • SCIM provisioning
  • Encryption key management
  • Role-based access control
  • Custom retention policy
  • Encryption at rest and in transit
  • No training on your business data
  • Priority support
Contact sales

FAQ

Loglune FAQ

What is Loglune?

Loglune is a feature-flag platform for B2B software teams that records every flag change and reproduces the flag evaluation from any past moment in dev, CI or staging, without touching production. Development teams at B2B software companies choose Loglune because they can trust its reproductions: each one matches production on the ruleset version, the percentage-rollout hash, the evaluation time and the prerequisite order. Loglune reproduces the flag evaluation, not the root cause of an application failure.

Who is Loglune for?

Loglune is built for development teams at B2B software companies. Developers and product managers define and publish flags in Loglune, support engineers and developers use it to reproduce bugs that only one customer hits, and CI jobs and AI agents read the same flag state.

How does Loglune reproduce a past flag state exactly?

Loglune rebuilds the flag state at a past time T from its append-only change log and matches production on four conditions: targeting is evaluated against the ruleset version that was live at T, percentage rollouts are bucketed with the same MurmurHash3 (32-bit, seed 0) that flagd fractional uses, time-based conditions are evaluated at T rather than at the replay's wall-clock time, and prerequisite flags resolve in the causal order of the change log.

Is Loglune a feature-flag tool or an add-on to one?

Loglune is a feature-flag platform in its own right, not an add-on to another flag service: you define flags, targeting and config in Loglune, publish versions, and your app evaluates them through the Loglune SDK. Reproduction covers the flags Loglune serves, because the change log that makes it exact is the one Loglune records. The Loglune SDK includes an OpenFeature provider (@loglune/sdk/openfeature), so an app that uses the OpenFeature server SDK can evaluate Loglune flags through it.

How do AI agents work with Loglune?

Loglune hands the reproduced flag state to your own AI agents through an MCP server, listed in the official MCP Registry as com.loglune/mcp, and through the loglune CLI. Agents reproduce, inspect, diff and bisect rulesets and author flag changes with an operator token; every paid plan includes MCP access. Setup is in the Loglune docs for AI agents.

Is Loglune available today?

Yes. The Loglune console starts on the Free plan without a sales call, and the Loglune SDK and CLI install from npm as@loglune/sdk and@loglune/cli.

How much does Loglune cost?

Loglune Free is $0 for 1 seat with 5 reproductions a month,7-day history and 1 environment, without live flag evaluation in production. Plus is $20 a month for 1 seat and Team Standard is$20 per seat a month for 2 to 50 seats; every paid plan includes 100 reproductions a month, then $1 per reproduction. Pro ($100 a month) and Team Premium ($100 per seat a month) add AI operations run by Loglune and are coming soon, not sold yet. Enterprise is contact sales. Every plan is on the Loglune pricing page.

Get started

Bring us the flag state you can’t reproduce