Built for machines

Your agent's new favorite tool

Structured JSON. Schema introspection. Dry-run safety rails. Three integration levels. Built for the machines that build your software.

Three levels

Meet your agent where it is

Every agent has different capabilities. Quonfig works with all of them — from a basic git client to a full MCP-native tool caller.

Level 1

Git + JSON

The Foundation

Your agent already knows git. That's enough. Edit a JSON file, commit, push. Pre-receive hooks validate the structure. 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

qf CLI

The Sweet Spot

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

qf-cli

$ qf flag create checkout-v2 --type bool --default false --dry-run
{
  "action": "create",
  "path": "feature-flags/checkout-v2.json",
  "validation": "passed",
  "wouldCommit": true,
  "preview": {
    "key": "checkout-v2",
    "type": "feature_flag",
    "valueType": "bool"
  }
}
# Looks good — apply it
$ qf flag create checkout-v2 --type bool --default false
{
  "data": {
    "key": "checkout-v2",
    "path": "feature-flags/checkout-v2.json",
    "commitSha": "e7f8a9b"
  },
  "meta": { "action": "created" }
}

Level 3

MCP Server

Zero Friction

Typed JSON-RPC. No shell escaping. No output parsing. Your agent calls functions, not commands.

mcp-tool-definition

{
  "name": "qf_flag_create",
  "description": "Create a new feature flag",
  "inputSchema": {
    "type": "object",
    "properties": {
      "key": { "type": "string", "description": "Flag key" },
      "valueType": {
        "type": "string",
        "enum": ["bool", "string", "int", "double", "json"]
      },
      "default": { "description": "Default value" },
      "dryRun": { "type": "boolean", "default": true }
    },
    "required": ["key", "valueType"]
  }
}

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

qf flag list

{
  "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" }
}

Dry-run safety rails

Every mutation supports --dry-run. The agent sees exactly what would change, validates the diff, checks for production warnings, and only then commits.

The agent sees the production warning, verifies it's intentional, and proceeds. No incident. No rollback. No pager going off at 3am.

dry-run

$ qf flag set checkout-v2 --env production --value true --dry-run
{
  "action": "update",
  "path": "feature-flags/checkout-v2.json",
  "validation": "passed",
  "diff": {
    "before": { "value": false },
    "after": { "value": true }
  },
  "wouldCommit": true,
  "warning": "This changes a flag in the production environment"
}
# Agent sees the warning, verifies intent, then applies
$ qf flag set checkout-v2 --env production --value true
{
  "data": { "key": "checkout-v2", "commitSha": "a7f3c2d" },
  "meta": { "action": "updated", "environment": "production" }
}

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

qf 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

qf flag create --describe

{
  "command": "qf flag create",
  "requiredArgs": ["key"],
  "options": {
    "--type": {
      "values": ["bool", "string", "int", "double", "json", "string_list"]
    },
    "--default": {
      "description": "Default value"
    },
    "--env": {
      "description": "Target environment"
    },
    "--dry-run": {
      "description": "Preview without applying"
    }
  }
}

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 git escape hatch

Your agent can manage feature flags the same way it manages code. Git is the API. 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 files in a repo with pre-receive hooks that validate the JSON structure.

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
- Always --dry-run before production mutations
- Never delete flags without checking evaluation stats
- Use qf eval to verify targeting before deploying
## Common Workflows
- Create flag: qf flag create <key> --type bool --default false
- Enable for segment: qf flag update <key> --json '...'
- Check who's affected: qf eval <key> --env production --context '...'
## Guardrails
- Production changes require --dry-run first
- Flags with >1000 daily evaluations need team review
- Segment changes must be tested with qf eval

Give your agents real tools

Three integration levels. Structured JSON everywhere. Safety rails built in. Your agents deserve better than REST APIs and table scraping.

Install the CLI Read the MCP docs