Feature Flag Platforms in 2026: LaunchDarkly vs. Unleash vs. GrowthBook vs. Flagsmith

Three days before this guide was written, LaunchDarkly shipped Release Autopilot — software that assesses a pull request, decides whether the change needs a flag, adds the flag, rolls the change out progressively, watches your guardrail metrics, rolls back on regression, then files the cleanup PR and archives the flag on its own. GA is November 16. In the same window, Unleash rebranded around Autonomous Feature Management, GrowthBook 5.2 shipped human-in-the-loop approval gates for AI agents, and Flagsmith shipped an MCP server that lets an agent manage flags in natural language.

The feature flag category has stopped being a toggle library with a UI. It is now bidding to become the runtime control layer for AI-built software — the thing that stands between a code-generation agent and your production traffic. And that repositioning comes with the most consequential pricing shift the category has seen: LaunchDarkly, the market incumbent, no longer sells seats. It sells seven usage meters.

This guide is written for the engineer or architect who is about to spend real money here. Every number below was pulled from live vendor pricing pages and product documentation on November 7, 2026 — not from a Gartner quadrant, not from a cached comparison site, and not from a vendor deck. We model what you will actually pay at three company sizes, we name the failure modes that will bite you in production, and we tell you who should not buy any of these.

Executive Scorecard

The short version, for readers who will not make it past this table: LaunchDarkly is the most capable platform and the most dangerous bill — its meters compound with your server-side replica count and your end-user growth, not with the platform's cost to serve you. Unleash is the conservative enterprise choice: $75/seat, unlimited connections and MAU, an AGPL open-source core you can audit and self-host. GrowthBook is the cheapest way to get serious statistics ($40/seat) if you already run BigQuery, Snowflake, or Databricks. Flagsmith is the one to call when compliance says the data cannot leave your VPC — it is the only one of the four that publishes a self-hosted, air-gapped path with an OpenShift operator.

What Actually Changed in 2026

Four things moved this category this year, and every one of them affects what you pay:

1. LaunchDarkly stopped selling seats and started selling meters

LaunchDarkly's pricing page now leads with "Unlimited seats, no per-seat fees" and bills seven usage meters: service connections, client-side MAU, AgentControl AI runs, session replays, errors captured, trace spans, and log lines. This is not a feature-flag price list anymore. It is an observability price list — and that is not accidental.

LaunchDarkly acquired Highlight, the session-replay and error-tracking vendor, announcing the deal on its own blog; Highlight's standalone product was subsequently sunset (its old blog domain now redirects to launchdarkly.com), and the replays/errors/logs/traces meters on today's pricing page are that acquisition's fingerprints. The company also picked up Houseware, a warehouse-native product analytics and experimentation vendor — a deal reported by trade press covering the Highlight acquisition. The pattern is the one Datadog perfected: acquire adjacent telemetry products, unify the platform, and convert every feature into a meter. If you buy LaunchDarkly in 2026, you are not buying a flag tool — you are buying into a metered runtime platform with flags as the wedge.

There is a real discount hook in the model: billing annually saves 17% on usage rates ($10 per connection yearly vs. $12 monthly; $8.33 per 1K MAU yearly vs. $10 monthly), and LaunchDarkly's own worked example — 10 service connections and 2K client MAU — lands at $58.33/month billed yearly. We reproduce that number independently in our cost model below; it checks out.

2. Every vendor repositioned around AI agents within the same two weeks

• November 3 — GrowthBook 5.2: Human-in-the-Loop mode for agent API keys (agents propose risky changes, humans approve in-app), agent permission scoping, and a note that agents can now act on behalf of named teammates.
• November 4 — LaunchDarkly Release Autopilot: agents assess PR risk, add flags, roll out progressively, and roll back automatically. LaunchDarkly says its own teams now ship over 20% of pull requests directly to production via agent-driven release, with automation handling 42% of flag removals.
• Same month — Unleash pushes Autonomous Feature Management: AI assistants create and wrap flags per governance policy, through an MCP server that plugs into GitHub Copilot and Claude Code. Wayfair's SRE team supplies the customer quote: "AI doesn't just accelerate development — it accelerates risk."
• Also live — Flagsmith's MCP server markets "push code to production in 0 clicks" and natural-language flag management, with AI wired into its change-request approval workflows.

Read that list again as a buyer. The entire category is converging on the same claim — we are the control plane for AI-generated change — and the differentiation is collapsing into pricing model and deployment posture. That is precisely when a comparison like this one matters, because the vendors are no longer selling different features. They are selling different bill shapes.

3. The pricing models are now in open collision

Four vendors, four incompatible meters:

• LaunchDarkly meters infrastructure and users: server-side connections (replicas count) and client-side MAU.
• Unleash meters people: $75/seat with unlimited connections, unlimited client-side MAU, and a 53M API-requests/month cloud allowance.
• GrowthBook meters people at $40/seat, with an events meter ($30 per million after 2M/month) only if you use its managed Event Forwarder.
• Flagsmith meters requests: 50K/month free, 1M on Start-Up, 5M+ on Scale-Up, then $50 per million, decreasing with volume.

Which model is cheapest depends almost entirely on your shape: how many services and replicas you run, how many monthly active end users you serve, and how big your platform team is. Section "Modeled Bills at Three Company Sizes" runs the numbers.

4. The kill-switch question got a real answer — and it varies by vendor

A feature flag platform is an availability dependency. The unglamorous question nobody asks during the sales call: what happens to flag evaluations when you blow a quota or a billing limit? The vendors' own published behavior diverges sharply:

• Statsig is the most defensible: on the free Developer tier, exceeding the 2M monthly metered events stops Metric Lift computations — but gate and config targeting continue to work. The kill switch keeps switching.
• PostHog is the most dangerous: its pricing FAQ states that on the free plan, over-limit events are permanently dropped and "feature flags will return a default quota limited response". Your flags return defaults — at billing time, your targeting rules stop mattering. For a platform whose job is fail-safe behavior, returning defaults is the failure mode you bought the product to prevent.
• LaunchDarkly simply stops ingesting over-limit telemetry (observability data) on lower tiers — "Ingestion stops at 5K" for errors on the Developer plan — while flag evaluation continues; the Developer plan's stance is "Never billed. Upgrade when you hit a limit."
• Unleash never exposes this cliff on PAYG at all: connections and client-side MAU are unlimited, so there is no quota to hit — only the 53M API request allowance, beyond which the cloud charges $5 per million rather than degrading.

Put that column in your evaluation matrix. A flag platform that degrades into default-flag behavior because a card expired is not a control plane; it is a liability.

Pricing, Verified Line by Line (November 7, 2026)

Every figure in this section comes from the vendor's live pricing page, fetched directly on 2026-11-07. Rates are the billed-yearly variants where the vendor offers both (monthly billing runs higher). Free allowances are monthly.

LaunchDarkly: three plans, seven meters

LaunchDarkly's Developer plan is genuinely free, forever, with no credit card: unlimited seats, unlimited flags with targeting, unlimited experiments and multi-armed bandits, agent configs and LLM-as-judge evals, observability (replays, errors, logs, traces), and Release Autopilot — which is free until February 1, 2027, at which point one assumes it joins the meter set.

The free monthly usage allowances, and the Foundation-plan rates beyond them:

Two definitions on that page deserve to be printed in full, because they are where the bill hides:

"Service connections: one server-side SDK connected to one environment, counted by time and averaged over the month. Every replica, worker and dev or staging environment counts."

"Client-side MAU: each unique client-side user or device counts as one monthly active user."

The first is the replica trap. If you deploy 20 microservices with an average of 6 replicas each, that is 120 connections — not 20. The "averaged over the month" clause softens the peak (a scale-up event does not bill as if it ran all month), but the steady-state bill scales with your fleet, and every staging environment you wire up counts too. Horizontal scaling — the thing Kubernetes exists to do — is the cost driver.

The second is the growth tax. Client-side MAU has nothing to do with how much work LaunchDarkly does for you; an idle user who loads your app once counts the same as a power user. When your marketing team succeeds, your LaunchDarkly bill succeeds — at 5M MAU the meter alone is over $41K/month, as the cost model shows.

Foundation also adds flag and experiment approval requests (1–5 reviewers, though mandatory approvals require Enterprise), unlimited projects and environments, AWS and Vercel Marketplace billing, and the 17% annual discount. Enterprise is contract-priced and adds the things a security review will demand anyway: SCIM provisioning and IdP team sync, custom roles, unlimited audit history, required approvals with ServiceNow routing, bulk targeting, code references, and a named CSM.

One more meter to understand before you sign anything: an AgentControl AI run is "one LLM call your app makes through an AgentControl config, or one judge evaluation," and — the detail that will surprise your finance team — "an online eval scores a live response, so it uses two runs." Route your agent traffic through AgentControl and judge it, and you are billed twice per turn. 5,000 runs/month are free; beyond that it is $5 per 1,000. At modest agent volume (say 2M LLM calls/month through AgentControl, half of them judged), the runs meter alone is roughly $7.5K/month. Price the AI story before you buy it.

Unleash: $75 per seat, and the usage is unlimited

Unleash inverts LaunchDarkly's model: $75 per seat per month on the cloud Pay-As-You-Go plan, with unlimited client-side MAU, unlimited service connections, unlimited flags, projects, and environments, and a 90-day flag-metrics retention. The cloud plan includes 53M API requests per month, then $5 per million — the only usage meter on the plan, and the one Unleash Enterprise Edge exists to keep small (Edge is a read-replica proxy that absorbs SDK traffic so it never hits your central API). PAYG carries a 99.9% uptime commitment and standard support; the contract Enterprise plan (cloud, self-hosted, or hybrid) carries 99.99%, premium support, and a dedicated customer success manager at the top tier. Self-hosted trials note a five-seat minimum.

The plan matrix includes the governance features you would expect to pay Enterprise rates for elsewhere: four-eyes approvals for flag changes, change-request workflows, stale-flag dashboards, and — important for the exit analysis below — export/import of feature flags.

The open-source core is real and popular: the Unleash/unleash repository carries an AGPL-3.0 license and roughly 14.1K stars, with commits landing daily. AGPL deserves a careful read by your legal team: it is fine to run AGPL software internally, but if you redistribute or expose it as a service, the copyleft obligations attach — and some organizations have blanket policies against AGPL in the stack. If that is you, Unleash means the paid product, not the repo.

GrowthBook: $40 per seat, and the warehouse does the math

GrowthBook's Starter plan is free for up to 3 users and 1 project, with unlimited flags, experiments, and traffic. The Pro plan is $40 per seat per month, capped at 30 users and 3 projects, and adds the AI Visual Editor, multi-arm bandits, safe rollouts, advanced permissions, and premium support. Enterprise is contract-priced and adds custom environments, ramp schedules, approval workflows, SSO and SCIM, exportable audit logs, and a 99.99% SLA.

The number that is not in the headline: if you use GrowthBook's Event Forwarder or managed warehouse instead of connecting your own, Starter includes 1M events/month free and Pro includes 2M, then $30 per million. Flag evaluation traffic itself is unlimited — the events meter only governs the analytics pipeline feeding your experiment metrics.

GrowthBook's differentiation is statistical depth, and 5.2 (shipped November 3) extended it: 12 metric types including threshold metrics, CUPED and variance reduction, sequential testing, Bayesian and frequentist models, sample-ratio-mismatch detection, contextual bandits — and interleaving experiments in private beta for Enterprise customers, a Netflix/DoorDash/Airbnb-grade technique GrowthBook claims no other experimentation platform ships, which blends two ranking algorithms into one list to read a result 50–100x faster than a classic A/B split. If "which ranker is better" is a question your team asks weekly, this is a real capability gap, not a checkbox.

The repo is open-core: MIT Expat for the platform, with the enterprise directories (back-end, front-end, and shared enterprise modules) under a separate GrowthBook Enterprise License. Self-hosting the core is free; self-hosting the enterprise features is not — know which directory tree the feature you need lives in before you plan around the OSS edition.

Flagsmith: request tiers, and the most deployment options in the category

Flagsmith prices on API requests and team size, with yearly billing about 10% cheaper than monthly:

Overage is $50 per million requests, decreasing with volume, and the fine print on the pricing page is unusually honest about it: overage charges apply if you exceed your limit, full stop. Free and Start-Up include unlimited flags, environments, identities, and segments under fair-use; Scale-Up adds SAML/SSO, roles, permissions, change requests, audit logs, and bring-your-own experimentation warehouse. Enterprise adds the deployment story: managed cloud across eight regions (Ohio, California, London, Mumbai, Sydney, São Paulo, Seoul, Singapore), a private cloud in your choice of provider and region, or self-hosted on-premises — explicitly including air-gapped instances — with Postgres, MySQL, or Oracle under it and Helm plus an OpenShift operator for the install. Its LDAP/SCIM support is marked "soon" on the Enterprise tier, which matters if you were counting on it this quarter.

The Edge API uses latency-based DNS routing to the nearest of those eight regions with global failover, and there is a self-hosted Edge Proxy — a flag evaluation engine you run inside your own datacenter for local-evaluation latency. The repository is BSD-3-Clause with about 6.7K stars, which means no license-review meetings and no copyleft conversations: of the four OSS cores in this guide, Flagsmith's is the only permissively licensed one.

Two pricing-page quirks worth flagging to a buyer. First, the "5,000,000+" on Scale-Up requests is a floor, not a cap — the plus hides negotiated overage at the published $50/M rate. Second, team size is a hard gate on every plan up to Enterprise: a 22-person platform team cannot buy Scale-Up. You jump straight to a quote. Budget accordingly.

The also-rans, briefly: Statsig and PostHog

Statsig is the fifth name every shortlist eventually includes, and its pricing is the sleeper deal of the category: free Developer tier with 2M metered events and 50K session replays per month, then a $150/month Pro baseline that includes 5M events (overage at $0.05 per 1K), full product analytics, and unlimited retention for analysis. The failure mode is well-designed: past the free limit, targeting keeps working and only metric lift stops. If your need is "gates and configs at low cost, with competent experimentation," Statsig belongs on the shortlist — and GrowthBook publishing an explicit "why migrate from Statsig" page tells you who they consider their real competitor.

PostHog bundles feature flags into a broader product-analytics suite with per-product usage pricing: 1M feature flag requests per month free, experiments billed with feature flags, and hard billing limits you can set — with the caveat from the pricing FAQ noted above: at the limit, flags return defaults. As a flag platform for a platform-engineering team it is a footnote to its analytics business; as a bundled add-on for a team already paying for PostHog, it is cheap and coherent.

Modeled Bills at Three Company Sizes

List prices are marketing. Here is what the meters do to real fleet shapes. The model below uses Decimal arithmetic (no float rounding), LaunchDarkly's billed-yearly rates, and one shared assumption: every server-side service polls or streams flag state continuously, and every service replica counts as a connection — per LaunchDarkly's own connection definition. Client-side MAU counts unique users or devices. Poll interval assumptions for request-metered vendors are stated where used.

Scenario A — 10-engineer B2B SaaS. 12 server-side services, 3 replicas each (36 connections), 20K client-side MAU, 10 platform seats:

Scenario B — 120-engineer marketplace. 60 services, 8 replicas each (480 connections), 400K client-side MAU, 40 internal seats:

Scenario C — consumer product, 5M client-side MAU. 30 services, 5 replicas each (150 connections), 25 platform seats:

The spread in Scenario C is the entire argument of this guide in one row: $43,091.67 versus $1,090.00 — a 39x difference for the same functional job (flags, targeting, and safe rollout at 5M MAU), with GrowthBook under a thousand-and-change and Statsig at four hundred. LaunchDarkly's meter bills you in proportion to your user count; the others bill you in proportion to your team size. If you are a consumer product with thin margins, that is not a detail — it is a strategic decision about whether your control plane costs O(users) or O(engineers).

Here is the exact model, reproducible, in the shape we ran it. Rates are hard-coded from the pricing pages above; sanity-checked against LaunchDarkly's own worked example, which the model reproduces exactly:

from decimal import Decimal as D

# LaunchDarkly Foundation, billed-yearly rates (launchdarkly.com/pricing, 2026-11-07)
CONNECTION_RATE = D("10")        # per connection, after 5 free
MAU_RATE         = D("8.33")     # per 1K client-side MAU, after 1K free
CONNECTIONS_FREE = D(5)
MAU_FREE_K       = D(1)

def launchdarkly_bill(services, replicas, client_mau):
    connections = D(services) * D(replicas)
    conn_cost = max(D(0), connections - CONNECTIONS_FREE) * CONNECTION_RATE
    mau_cost  = max(D(0), D(client_mau) / D(1000) - MAU_FREE_K) * MAU_RATE
    return conn_cost + mau_cost

# Vendor's own example from the pricing page: 10 connections + 2K MAU
assert launchdarkly_bill(10, 1, 2000) == D("58.33")   # matches $58.33/mo billed yearly

# Scenario A: 12 services x 3 replicas, 20K MAU -> $468.27/mo
print(launchdarkly_bill(12, 3, 20_000))

# Scenario B: 60 services x 8 replicas, 400K MAU -> $8,073.67/mo
print(launchdarkly_bill(60, 8, 400_000))

# Scenario C: 30 services x 5 replicas, 5M MAU -> $43,091.67/mo
print(launchdarkly_bill(30, 5, 5_000_000))

# Per-seat comparisons: Unleash $75/seat, GrowthBook Pro $40/seat
unleash_c   = D(25) * D("75")     # Scenario C seats: $1,875.00
growthbook_c = D(25) * D("40") + (D(5_000_000) - D(2_000_000)) / D(1_000_000) * D("30")
print(unleash_c, growthbook_c)   # $1,875.00 vs $1,090.00 (plus Event Forwarder overage)

Unit policy, stated: all figures are monthly, in US dollars, at each vendor's published rates on 2026-11-07, with LaunchDarkly on billed-yearly rates (monthly billing adds 17–20%). Flagsmith request estimates assume one flag-state fetch per service per 60 seconds; GrowthBook event estimates assume one exposure event per client-side MAU; LaunchDarkly connection counts assume every replica runs continuously (their "averaged over the month" clause will soften burst-driven peaks below these figures — the steady state holds). Where a plan cap forces a contract (GrowthBook 30-user cap, Flagsmith 20-member cap), the bill is unknowable without a quote — which is itself a finding worth having before the vendor picks your number.

Architecture: Where Each Platform Sits in Your Stack

All four vendors sell the same logical architecture — a control plane holding flag state and targeting rules, an evaluation path close to your code, and an integration surface for CI/CD and now AI agents — but the topology you actually deploy, and who operates it, is the real difference:

                     YOUR PRODUCTION STACK
  +------------------+   +-------------------+   +----------------------+
  | Server-side SDKs |   | Client-side SDKs |   | CI/CD + AI agents    |
  | (per-replica)    |   | (browser/mobile) |   | (MCP / API / webhooks|
  +--------+---------+   +--------+----------+   +----------+-----------+
           |                      |                          |
           v                      v                          v
  +------------------------------------------------+-----------------------+
  |            EVALUATION PATH (latency-critical)                          |
  |  LaunchDarkly : streaming SDKs, persistent connections (metered!)      |
  |  Unleash      : SDKs poll -- or Unleash Enterprise Edge proxy           |
  |                 (read replica, streaming sync, 20K+ RPS)              |
  |  GrowthBook   : SDK local evaluation + GrowthBook Proxy / remote eval   |
  |  Flagsmith    : Edge API (8 regions, DNS routing) or self-hosted        |
  |                 Edge Proxy inside your own datacenter                   |
  +------------------------------------------------+-----------------------+
           |                                       |
           v                                       v
  +---------------------------+      +---------------------------------+
  |   CONTROL PLANE (UI/API)  |      |   METRICS / DECISION PATH       |
  |   targeting rules, tiers, |      |   LaunchDarkly: bundled stats  |
  |   segments, approvals      |      |   GrowthBook  : YOUR warehouse  |
  |   (HITL gates for agents)  |      |   Flagsmith   : BYO warehouse   |
  +---------------------------+      |   Statsig     : built-in       |
        |          |                 +---------------------------------+
        v          v
  billing     governance
  (meters     (RBAC, SCIM, audit,
   = shape)    four-eyes approvals)

Three architectural decisions fall out of that diagram:

• Who owns latency? LaunchDarkly's streaming connections push flag changes without polling and are the fastest path to a stopped SDK — but every persistent connection is a billable meter. Unleash's Edge and Flagsmith's Edge API/Proxy both move evaluation to a read replica near your users; GrowthBook's SDKs evaluate locally against data shipped to the SDK payload, which keeps client-side traffic free but grows with segment size — its 5.2 release added remote saved groups precisely so lists of millions of IDs do not bloat that payload.
• Who owns the truth about your metrics? GrowthBook is warehouse-native: experiment results are computed in your BigQuery, Snowflake, or Databricks, against 12 metric types, with a usage dashboard showing which queries drive warehouse cost. LaunchDarkly's experimentation and observability are bundled in-platform (the Houseware acquisition points at warehouse-native analytics arriving there too); Flagsmith Scale-Up lets you bring your own experimentation warehouse; Unleash's A/B testing is real but statistically simpler. If your data team has opinions about exposure logging, this axis eliminates half your shortlist.
• What does the agent integrate with? Every vendor now has an answer: Unleash and Flagsmith ship MCP servers; GrowthBook 5.2 ships an MCP OAuth server with human-in-the-loop approval gates on top; LaunchDarkly's AgentControl meters the LLM calls themselves through its config. The agent surface is where these platforms are racing, and it is also the least battle-tested layer of every one of them — treat all of it as early-adopter territory.

Vendor Profiles, Unvarnished

LaunchDarkly — the platform play with the Datadog bill

What you get: the most complete feature set in the category, full stop. Streaming evaluation at claimed scale (70 trillion flag evaluations a day, per the company), mature targeting and experimentation, release automation that no competitor matches yet (Release Autopilot's flag-the-PR, roll-out, watch-metrics, auto-rollback, clean-up loop), and a genuine agent governance product in AgentControl — adaptive triggers that escalate a failing agent config mid-conversation, offline evals with LLM judges, and agent graphs that map a multi-agent system. The free Developer tier is the most generous in the category for small teams.

Honest weaknesses: the meter set is the product. Service connections count replicas, so your bill scales with fleet size and autoscaler behavior; client-side MAU scales with user growth; AI runs bill double when a judge scores a live response; and every observability meter (replays, errors, traces, logs) is an invitation to move more of your telemetry onto their bill over time. The Highlight acquisition shows exactly how acquired products fold into meters — the standalone product was sunset. The Enterprise tier gates mandatory approvals, SCIM, and audit history, which are table-stakes controls for regulated shops — meaning regulated buyers should model Enterprise pricing from day one, not Foundation.

Who should skip: consumer-scale products with client-side MAU in the millions (Scenario C's $517K/year run-rate is indefensible against $1–2K alternatives), and any team that wants its control plane cost to be proportional to the engineering team rather than the customer base. Also skip if your org has a standing objection to consolidating flags with observability spend — you know exactly which budget meeting that becomes.

Unleash — the conservative enterprise pick

What you get: predictable per-seat pricing with zero meters on the things that scale (connections and MAU), an AGPL open-source core with a decade of production history, an Edge layer proven at 20,000+ RPS (Wayfair's Black Friday quote), four-eyes approvals and change requests in the standard plan matrix, and credible enterprise references — Prudential, Lloyds Banking Group, Lenovo, Mercadona Tech. The autonomous-feature-management story (agents create and wrap flags through the MCP server, governed by policy) is coherent, and the export/import tooling means your flag data is not hostage.

Honest weaknesses: $75/seat is the highest per-seat price in the guide, and it bills everyone who touches the platform, not just developers — a 60-person org with QA, PM, and SRE seats burns $4,500/month for flags. Experimentation is the weakest of the four (A/B/n with variants, no interleaving, no CUPED, no bandits worth writing home about). AGPL will cost you a legal review or an exception. And the API-traffic allowance (53M, then $5/M) means a polling architecture without Edge is a self-inflicted meter.

Who should skip: small teams under ~10 seats (LaunchDarkly's free tier or GrowthBook at $40/seat wins on price), teams whose primary need is advanced statistics (GrowthBook wins), and anyone with a blanket AGPL prohibition who does not intend to pay for Enterprise.

GrowthBook — the experimentation engine

What you get: the best statistics in the category, at the lowest per-seat price ($40/seat). Warehouse-native metric computation (your data never leaves for analysis), 12 metric types, CUPED, sequential testing, Bayesian and frequentist models, contextual and multi-arm bandits, and the only shipping interleaving experiments claim we can find. The 5.2 agent controls are the most thoughtful governance story in the guide: human-in-the-loop on API tokens, tokens scoped below their owner's permissions, expiry rules, and attribution showing which human an agent acted for. MIT-licensed core, self-hostable.

Honest weaknesses: GrowthBook assumes a warehouse. If you do not run BigQuery, Snowflake, or Databricks and do not have someone who thinks in SQL, half the product's value is out of reach — the Event Forwarder mitigates but does not remove this. The Pro plan's hard 30-user cap forces Enterprise contracts at mid-size orgs. Client-side experimentation at consumer scale bills through the Event Forwarder's event meter ($30/M after 2M) — cheap, but real. And the enterprise features are behind an open-core boundary, so a self-hosted deployment is not the full product.

Who should skip: teams with no warehouse and no data function, teams that need flag infrastructure without experimentation (Flagsmith's request tiers or Statsig's free tier do that job for less), and orgs whose platform headcount exceeds the Pro cap and who dislike forced contract negotiations.

Flagsmith — the compliance and deployment pragmatist

What you get: the most deployment options of any vendor here — managed cloud across eight regions, private cloud in your provider and region of choice, self-hosted with Helm or an OpenShift operator, and explicitly air-gappable. BSD-3-Clause core. SAML/SSO and change-request governance at the $250 Scale-Up tier rather than behind a contract. The MCP server with change-request approvals baked in is a quietly excellent design: the agent proposes, the workflow approves. Edge API with DNS routing plus a self-hostable Edge Proxy for local-evaluation latency inside your own perimeter.

Honest weaknesses: the request meter is the least predictable billing unit in the guide — your bill is a function of poll intervals, environment count, and SDK configuration, and the $50/M overage decrements only with volume you cannot audit in advance. The team-member caps are aggressive (3 members at Start-Up, 20 max at Scale-Up), pushing most real platform teams to a contract. Experimentation is BYO-warehouse on Scale-Up — no bundled statistics. And two Enterprise-tier items are still "soon" (LDAP/SCIM, data-driven releases) — check delivery dates before you depend on them in a compliance review.

Who should skip: teams above 20 members who will not negotiate, teams wanting a vendor-owned statistics stack, and anyone whose SDK fleet generates request volume they cannot confidently bound (or budget) — you want a seat- or MAU-shaped bill instead.

Lock-In and the Exit Question

The ugly secret of this category is that flags are the lock-in. The SDK calls are trivially swappable; the months of accumulated flag inventory, targeting rules, segments, and audit history are not. Evaluate exit cost before you buy, not during the migration:

• Data portability: Unleash publishes export/import for feature flags on its plan matrix — the only vendor of the four that puts migration tooling in the pricing table. Flagsmith's local-evaluation engine and open API make bulk export buildable. GrowthBook's configuration lives in its own database with an API surface (30 new endpoints in 5.2 alone). LaunchDarkly's API is complete but the flag graph (segments, approvals, code references) is the deepest to reconstruct.
• SDK abstraction: the CNCF's OpenFeature specification is the real exit hedge — an SDK abstraction layer that swaps flag providers without rewriting call sites. Flagsmith ships OpenFeature support; every major flag vendor maintains some OpenFeature story. Adopt OpenFeature in your golden path templates on day one and the migration cost falls from "rewrite the fleet" to "swap the provider." If your platform team has not standardized on it yet, this evaluation is the moment.
• License posture: Unleash's AGPL and GrowthBook's open-core both mean the free path is governed; Flagsmith's BSD is the only license that never surprises you. LaunchDarkly is proprietary, so your exit cost there is purely operational.
• Consolidation risk: the Highlight sunset is the lesson — vendors acquired into this category do not survive as products; their features become meters. Any standalone vendor you evaluate is either a future acquirer or a future acquisition, and either outcome reprices you.

The Decision Matrix

Who Should Skip This Entire Category

Integrity requires the other column too. Do not buy any of these platforms if:

• You have fewer than ~5 services and no experimentation program. A YAML file, an env var, and a config map give you kill switches for free. The platform tax only pays back with fleet size, targeting complexity, or release risk you can name.
• You deploy weekly or slower with mature canary tooling. If Argo Rollouts or a service mesh canary already covers your blast-radius control, a flag platform duplicates it with a new invoice and a new dependency. Flag-driven releases and deploy-based canaries solve the same problem; pick one system of record.
• Nobody will own flag hygiene. The dirty open secret of the category is that every platform above now markets "automated cleanup" because the average enterprise ends up with thousands of orphaned flags nobody dares remove. Flags are tech debt with an SDK. If no team owns the lifecycle, you are buying the debt with a monthly meter attached.
• You are buying the AI story alone. Release Autopilot is a week old; interleaving is a private beta; "0 clicks to production" is a slogan. Every agent feature in this guide is early-adopter territory, and two Flagsmith Enterprise items are still "soon." Buy the platform that is excellent at flags today, and treat the agent layer as a free option — never as the reason for the purchase order.

References & Further Reading

All pricing and product claims verified against primary sources on November 7, 2026. Release announcements dated as cited. GitHub repository statistics (stars, licenses) via the GitHub API on the same date.

• LaunchDarkly pricing — plans, meters, and free allowances
• Introducing Release Autopilot — LaunchDarkly blog, Nov 4, 2026
• LaunchDarkly AgentControl product page
• Welcome Highlight to LaunchDarkly — acquisition announcement
• Unleash pricing — PAYG and Enterprise plans
• Unleash Autonomous Feature Management
• Unleash Enterprise Edge — architecture and throughput
• Unleash/unleash — GitHub repository (AGPL-3.0)
• GrowthBook pricing — Starter, Pro, Enterprise
• GrowthBook 5.2 — interleaving experiments and Human in the Loop for agents, Nov 3, 2026
• GrowthBook/growthbook — GitHub repository (MIT Expat core, enterprise modules)
• Flagsmith pricing — Free through Enterprise tiers
• Flagsmith MCP Server for release management
• Flagsmith Edge API and self-hosted Edge Proxy
• Flagsmith/flagsmith — GitHub repository (BSD-3-Clause)
• DEVOPSdigest — LaunchDarkly acquires Highlight (and prior acquisition of Houseware)
• Statsig pricing — Developer, Pro, and Enterprise tiers
• PostHog pricing — per-product usage pricing
• GrowthBook: Why migrate from Statsig to GrowthBook