Feature flags for the age of AI
The feature flag platform built for the age of AI-written code.
Everything your factory ships, behind a flag — auto-created when the agent commits, auto-retired when the rollout completes. Every step a git commit.
Roll out checkout-v2 to 25%
agent/checkout-v2 → main
Trusted by teams shipping to production
The flag lifecycle
When agents write the code, flags pile up faster than humans retire them.
Quonfig is built for the full lifecycle of a flag in that world — created when the agent ships work, retired when the rollout completes. Because config is git-native, every step is a reviewable commit.
A feature-flag lifecycle is the path a flag travels from creation to removal: a flag is created when work ships behind it, rolled out gradually with targeting rules, then retired once it reaches 100% and the code path is permanent. In Quonfig each step is a real git commit — a JSON file change with an author, a diff, and a timestamp — so the trail is auditable by default.
Agent ships work, flag is created
When an agent commits a feature, it lands behind a flag. In Quonfig that flag is a JSON file added to your workspace repo — so its creation is a commit you can review, not a row in someone else's database.
+ configs/checkout-v2.json
Roll out gradually with targeting
Move from 0% to 100% with percentage rollouts and targeting rules — by environment, cohort, or attribute. Every bump is another commit, evaluated locally and in-process by the SDK.
rollout: 25 → 100
Rollout hits 100%, flag is retired
Once the rollout is complete and the code path is permanent, the flag comes out. Deleting it is one more commit — a clean diff that closes the loop instead of leaving dead config behind.
- configs/checkout-v2.json
You can run this loop today: each stage is a git-native JSON file you change with the scriptable qfg CLI or plain git, evaluated through any of the nine SDKs or OpenFeature. A fully hands-off “auto-create on commit, auto-retire at 100%” pipeline is the direction we're building toward — assembled from these real primitives, not a one-click button.
Why Quonfig
Four reasons it holds up when agents are writing the config
Git-native by default, prompts you can ship without a deploy, local evaluation that survives an outage, and data you actually own.
It's just git
Every workspace is a real git repo, so every AI-generated config change is auditable by default — a JSON diff with a real author and timestamp. Clone it anytime. No lock-in, no export fees.
Prompts are config
Store LLM prompts in Quonfig, version them in git, change them without a deploy, and target by cohort. qfg generate turns Mustache prompts into type-safe render functions.
Never goes down
Backend SDKs evaluate locally, in-process, sub-millisecond — every flag check is a local function call. If our delivery service is unreachable, your app keeps serving on cached config.
Own your data, lowest TCO
Clone your repo anytime with `qfg pull` or plain git. Transparent, public pricing with a live calculator — roughly 10x cheaper than the major platforms at scale.
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, Python, Java, .NET) 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.
Get started
Choose how you want to use Quonfig
Start with the open-source SDK, or get the full platform with UI, delivery, and telemetry. Detailed pricing on the pricing page.
Open Source
Free forever
- •SDK reads JSON from a local directory
- •Sub-millisecond local evaluation
- •Edit files directly or with agents
- •No account needed
Platform
Free 30-day trial, then $5/mo + usage
- •Full UI for flags, config, log levels
- •Git-backed storage you own
- •Environments, targeting, segments
- •Global real-time delivery (usage pricing)
- •Telemetry & insights (usage pricing)
- •SSO & enterprise support (add-on)
Self-Hosted
Custom
- •Run Quonfig on your own infrastructure
- •Full data sovereignty
- •SSO & enterprise support
Curious how a real bill breaks down? See full pricing & the calculator →
Start managing feature flags in 5 minutes.
Full UI. Real-time delivery. Agent-ready from day one.