Introducing Quonfig

Feature flags, config, log levels, and secrets.

Agent-first. Built to never go down.

The complete configuration platform with a full UI, real-time delivery, and sub-millisecond local evaluation. Your app keeps working even if we don't. Manage config from the dashboard or the CLI — every change is tracked, auditable, and instantly reversible.

Get Started See how it works

~/my-project

Why Quonfig

The complete config platform, rebuilt from first principles

Feature flags, dynamic config, log levels, and secrets — one platform with targeting, environments, and a real audit trail.

Complete Platform

Feature flags, dynamic config, log levels, and secret management. One targeting engine, one set of SDKs, one audit trail. Manage everything from the UI or the CLI.

Reliable First

Sub-millisecond local evaluation. Your app keeps working even if Quonfig goes down — SDKs evaluate from cached config with zero network calls.

Agent-First

CLI with JSON output, schema introspection, dry-run safety rails on init and migrate. Just as powerful from the UI — agent-first doesn't mean agent-only.

It's just git. You own it.

Your config lives in a real git repo. Clone it with `qfg pull`, edit JSON, push it back with `qfg push` — or skip the CLI and use git directly. Your audit trail, your history, your data. No vendor lock-in, no export fees.

What's inside

One platform. Six capabilities.

Same targeting engine, same SDKs, same audit trail for everything.

Feature Flags

Boolean and multivariate flags, percentage rollouts, kill switches, segments, targeting rules.

Dynamic Config

Type-safe config values (strings, numbers, JSON) — change without deploying. Same targeting engine as flags.

Dynamic Log Levels

Change log verbosity at runtime. Debug a specific user in production without redeploying.

Secret Management

Manage secrets alongside your config. Same SDKs, same targeting, same audit trail.

Typesafe generated code

Run `qfg generate` and get type-safe accessors for every flag and config — node-ts, react-ts, and more. No more stringly-typed lookups.

Schema-validated JSON

Attach a JSON Schema to any config. The CLI, the UI, and `qfg push` all enforce it — invalid values never make it into your workspace.

Every feature uses the same JSON format, the same targeting rules, the same CLI, and the same local evaluation. Learn once, use everywhere.

Reliability

Your app doesn't go down if Quonfig goes down.

Local evaluation, always

Backend SDKs (Node, Go, Ruby) download the full config and evaluate in-process. Every flag check is a local function call — sub-millisecond, zero network latency. Not a paid add-on. Every backend SDK. Every tier.

Browser and React SDKs evaluate against our edge service instead — you can't ship rule data to the browser without leaking targeting logic to end users.

Graceful degradation

If the SDK can't reach our delivery service, it keeps using cached config. Background retry. Your application is completely unaffected. The worst case is stale config, never unavailable config.

Global edge delivery

Config changes propagate globally via edge CDN in under one second. Long-polling keeps SDKs fresh. ETag-based caching minimizes bandwidth.

See the difference

Your feature flag platform was built for a different era.

Quonfig is built for teams that ship with agents, not just dashboards.

Your current setup	Quonfig
Feature flags only	Flags + config + log levels + secrets
Dashboard → Feature Flags → Select → Edit → Save → Deploy	UI, CLI, or git — your choice
Export: "Contact sales"	Export: clone your git repo anytime
Audit log: "Paid add-on"	Audit log: built-in, powered by git history
Redeploy to change log levels	Change log levels at runtime, per user or environment
Agent integration: Build a custom API wrapper	Agent integration: CLI with JSON output, or plain git
Vendor SDKs only	Our SDKs or OpenFeature adapters
Per-seat pricing	Granular usage-based pricing for lowest TCO

It's just git

Your config, your repo, your data

Every workspace is a real git repository you can clone. Use the UI, the CLI (`qfg pull` / `qfg push`), or plain git — you stay in control of where your config lives and how it changes.

You own your data

Your config lives in a git repo you can clone anytime. No vendor lock-in. No export fees. Your data, your terms.

Real audit trail

Every change has an author, timestamp, and diff — automatically. Not a proprietary changelog, a real version history.

Disaster recovery

If Quonfig disappears tomorrow, your config doesn't. Clone the repo and you have everything — full history included.

Already using LaunchDarkly?

An agent reads your flags, translates them to Quonfig format, and migrates everything — flags, segments, environments. You review the changes and you're done.

Migrate from LaunchDarkly See all migrations

Get started