settings.yaml

# TangleBrain global settings — knobs that are NOT per roster entry.
#
# The roster (roster.yaml) is a list of routable backends; per-entry policy lives there. The few
# truly global switches live here.
#
# api_billing_enabled — THE PAID-API BILLING GATE. This is the durable safety contract: paid
# billing is OFF unless this is explicitly `true`.
#
#   false (default) → every `tier: api` roster entry still parses and is inspectable, but is
#                     NEVER routable — the adapter factory refuses to build it. Inert.
#   true            → enabled `tier: api` entries become routable (still last-resort), each
#                     fronted through a budget-scoped key (key_ref) on an OpenAI-compatible gateway.
#
# The durable rule: *no paid billing without this explicit toggle.* Keep it false unless you mean it.

api_billing_enabled: false

# classifier_gate_enabled — the LOCAL CLASSIFIER GATE (default false = normal frontier-first).
#
#   false (default) → every request goes through the frontier-first router (orchestrator rotation).
#   true            → a cheap local classify runs FIRST: trivial requests are handled directly by
#                     the free local backend and never reach an orchestrator; only frontier requests
#                     do. Per CLI run, `--gate` / `--no-gate` overrides this.
#
# Classification fails safe to "frontier" — it never traps a hard task on local.

classifier_gate_enabled: false

# delegate_max_concurrency — cap on how many sub-tasks `delegate_many` fans out AT ONCE.
#
#   unset (default) → TangleBrain derives the cap from this machine (os.cpu_count()).
#   <positive int>  → pin the cap. The TRUE limit is your backend's parallelism, which TangleBrain
#                     can't portably detect — set this to match it (e.g. your local model server's
#                     OLLAMA_NUM_PARALLEL, or your provider's safe concurrent-request budget).
#
# A per-call `max_concurrency` argument may LOWER this but never exceed it. Left unset below so the
# derived default applies out of the box.
#
# delegate_max_concurrency: 4