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
Feature-flag platform
The problem
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.
closed · could-not-reproduce
support → engineering
P1 · blocked
incident · unresolved
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
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
loglune · replay
3 flags · folded to 2026-08-22
materialisedYour dev / CI
closed · could-not-reproduce
one command · your machine
How it works
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 →The console
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
“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.
| Aspect | Reproduced exactly | Not |
|---|---|---|
| Rule version | Targeting is evaluated against the ruleset that was live at T | not today’s rules |
| Bucketing | Percentage rollout hashes on flag key + context, identically live and in replay | not a re-rolled dice |
| Time-dependent rules | Date and schedule conditions are evaluated at the reproduced moment T | not the replay wall-clock |
| Prerequisites | Flag-to-flag dependencies resolve in the log’s causal order | not an arbitrary order |
Data handling
We act as a processor for your flag data. What we hold is configuration — flag rules, targeting and versions — not the people behind them.
Pricing
FAQ
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.
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.
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.
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.
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.
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.
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.