Built for machines

Your agent's new favorite tool

Structured JSON. Schema introspection. Git-diff previews. Two integration levels: git or CLI. Built for the machines that build your software.

Two levels

Meet your agent where it is

Every agent has different capabilities. Quonfig works with all of them — from editing JSON files directly to a structured CLI that returns parseable output.

Level 1

JSON Files

The Open Source Path

Your agent already knows how to edit files. That's enough. Edit a JSON config, commit the change. Validation hooks ensure the structure is correct. No CLI needed.

git-workflow.sh

# Create a feature flag — no CLI needed
$ cat > feature-flags/checkout-v2.json << 'EOF'
{
  "key": "checkout-v2",
  "type": "feature_flag",
  "valueType": "bool",
  "default": {
    "rules": [{
      "criteria": [{ "operator": "ALWAYS_TRUE" }],
      "value": { "type": "bool", "value": false }
    }]
  }
}
EOF
$ git add feature-flags/checkout-v2.json
$ git commit -m "Create checkout-v2 feature flag"
$ git push
# Pre-receive hooks validate the JSON structure

Level 2

qfg CLI

The Sweet Spot

Structured output. Validation. Every command returns JSON when piped. Your agent parses it, reasons about it, and acts on it.

qfg-cli

# Create a flag, default off
$ qfg create checkout-v2 --type boolean-flag --value=false
{
  "data": {
    "key": "checkout-v2",
    "path": "feature-flags/checkout-v2.json",
    "valueType": "bool"
  },
  "meta": { "action": "created" }
}
# Roll it out to 20% of production
$ qfg set-rollout checkout-v2 --environment production --true-percent 20
{
  "data": { "key": "checkout-v2", "truePercent": 20 },
  "meta": { "action": "updated", "environment": "production" }
}

Structured output

JSON your agent can actually parse

No more regex. No more table-scraping. Every response is a typed JSON envelope with data and metadata.

Typical CLI output

other-tool

NAME           TYPE    ENV         VALUE
checkout-v2    bool    production  true
new-pricing    string  staging     $39
dark-mode      bool    production  false
api-limits     int     staging     1000
onboarding     bool    production  true

Quonfig output

qfg list --json

{
  "data": [
    { "key": "checkout-v2", "valueType": "bool", "value": true },
    { "key": "new-pricing", "valueType": "string", "value": "$39" },
    { "key": "dark-mode", "valueType": "bool", "value": false },
    { "key": "api-limits", "valueType": "int", "value": 1000 },
    { "key": "onboarding", "valueType": "bool", "value": true }
  ],
  "meta": { "count": 5, "environment": "production" }
}

Preview every change before it ships

Because config is just JSON files in git, every change the agent makes is a diff you can read before it lands. The agent edits the config, opens a pull request, and the exact before/after is right there in the review — no opaque mutation, no guessing what changed.

A human (or another agent) approves the diff, the change merges, and it propagates. The same review workflow you already use for code now covers what your users actually see.

review-the-diff.sh

# The agent edits the JSON, then shows the diff before committing
$ git diff feature-flags/checkout-v2.json
diff --git a/feature-flags/checkout-v2.json
--- a/feature-flags/checkout-v2.json
+++ b/feature-flags/checkout-v2.json
@@ rules ...
-          "value": { "type": "bool", "value": false }
+          "value": { "type": "bool", "value": true }
# Exact before/after — reviewable like any code change
$ git commit -am "Enable checkout-v2 in production"
$ git push   # or open a PR for a human to approve the diff
# Pre-receive hooks validate the JSON structure

Self-describing

Your agent never needs to Google the docs

Every command describes itself. Every schema is queryable. Your agent discovers what it can do at runtime.

Discover available operators

qfg schema operators

{
  "data": [
    { "name": "ALWAYS_TRUE", "description": "Matches all contexts" },
    { "name": "PROP_IS_ONE_OF", "description": "Property in list" },
    { "name": "IN_SEG", "description": "In segment" },
    { "name": "IN_INT_RANGE", "description": "Integer in range" },
    { "name": "PROP_ENDS_WITH_ONE_OF", "description": "Property ends with" },
    { "name": "HIERARCHICAL_MATCH", "description": "Namespace match" }
  ]
}

Describe any command

qfg create --help --json

{
  "command": "qfg create",
  "requiredArgs": ["name"],
  "options": {
    "--type": {
      "values": ["boolean-flag", "string", "int", "double",
                 "json", "string-list", "duration", "log_level"]
    },
    "--value": {
      "description": "Default value"
    },
    "--env-var": {
      "description": "Environment variable to read the value from"
    },
    "--secret": {
      "description": "Encrypt the value locally (zero-knowledge)"
    }
  }
}

git-escape-hatch.sh

# Create a feature flag — no CLI needed
$ cat > feature-flags/dark-mode.json << 'EOF'
{
  "key": "dark-mode",
  "type": "feature_flag",
  "valueType": "bool",
  "default": {
    "rules": [{
      "criteria": [{ "operator": "ALWAYS_TRUE" }],
      "value": { "type": "bool", "value": false }
    }]
  }
}
EOF
$ git add feature-flags/dark-mode.json
$ git commit -m "Create dark-mode feature flag"
$ git push
# Pre-receive hooks validate the JSON structure

The file-based escape hatch

Your agent can manage feature flags the same way it manages code. JSON is the schema. Every tool that works with files works with Quonfig.

No CLI to install. No SDK to learn. No API keys to manage. Just JSON files with validation hooks that ensure correctness.

Agent context file

Ship a .qf/agent-context.md in your repo. Your agent auto-discovers it and follows the invariants, workflows, and guardrails you define.

Encode your team's policies as instructions your agent actually reads. No dashboards to configure. No RBAC policies to maintain. Just a markdown file in version control.

.qf/agent-context.md

# Quonfig Agent Context
## Invariants
- Open a PR on the JSON diff before changing a production flag
- Never delete a flag without checking it's no longer read in code
- Inspect targeting by reading the rules in the flag's JSON file
## Common Workflows
- Create flag: qfg create <key> --type boolean-flag --value=false
- Roll out: qfg set-rollout <key> --environment production --true-percent 20
- Inspect a flag: qfg get <key> --environment production
- Complex targeting: qfg pull, edit the JSON, git push
## Guardrails
- Production changes go through a reviewable git diff first
- Retire finished flags: qfg cleanup list
- Operator reference: qfg config-schema

Give your agents real tools

Two integration levels: git or CLI. Structured JSON everywhere. Safety rails built in. Everything an agent can do via CLI, a human can do via the UI. Agent-first doesn't mean agent-only.

Install the CLI