Tunables Overview — the 5-axis trade-off¶
Five axes in tension. No combination optimizes all of them. Tuning is choosing where to give.
[TUNABLE]
New here? This page is your map to the dials you can turn when you set up CompassAlpha — and it explains why turning one up usually turns another down, so you choose on purpose rather than by accident.
TL;DR¶
The short version: you get five things to balance, and you can't max out all of them at once — so tuning means deciding which one you're willing to give up. CompassAlpha exposes a tunable design space along five primary axes: speed, intelligence, cost, risk, predictability. They pull against each other. Every tuning decision spends one axis to buy another. The framework's job is to make the trade explicit so you choose deliberately instead of discovering the cost after the fact. The structural rules behind the dials remain [INVARIANT] no matter where you set them.
The customization surface as a trade-space: every preset is a point on these five axes; the invariants underneath them never move.
The five axes¶
| Axis | Definition | High means |
|---|---|---|
| Speed | Wall-clock time from cycle activation to deliverable. | Fast turnaround; less waiting. |
| Intelligence | Depth, correctness, coverage of the deliverable — the federation's "IQ floor." | Catches more; specializes better; fewer escapes. |
| Cost | Compute (tokens, API calls) + founder cognitive load + maintenance burden. | Expensive to run and maintain. |
| Risk | Chance of pollution, hallucination, drift, replay, or stale-snapshot decisions. | More chance of a costly mistake. |
| Predictability | How accurately cycle duration and deliverable scope can be estimated up front. | Reliable estimates; few surprises. |
Note the asymmetry: high speed, high intelligence, and high predictability are good; high cost and high risk are bad. The tension is that the good ones trade against each other and tend to drag in the bad ones.
Why no combination wins everywhere¶
The dials are coupled. The most common couplings:
- Speed ↑ → risk ↑, intelligence ↓. Running dispatches in parallel, skipping verification, or using concise digests shaves wall-clock time but raises the chance of pollution or a missed defect.
- Intelligence ↑ → cost ↑, speed ↓. Top-tier models, wide context, strict provenance, and many invariants raise the quality floor but burn more tokens and take longer.
- Cost ↓ → founder load ↑ or risk ↑. Cheaper models or fewer toolings shift verification onto the founder, or simply let more defects through.
- Predictability ↑ → speed ↓. LAYGO (one unit at a time) makes cycles estimable but slow; parallelism makes them faster but harder to forecast.
You cannot collapse all five into a single optimum. Tuning is choosing a bias point appropriate to the project.
Bias points by project profile¶
Different projects sit naturally at different points on the surface:
| Profile | Biases toward | Accepts more |
|---|---|---|
| Regulated multi-tenant SaaS (financial, academic, health-adjacent) | Intelligence + low risk | Cost, slower speed |
| Compliance-critical (medical, financial-core) | Risk-aversion above all | Cost, speed |
| Small source-available project | Speed + cost-optimization | More risk |
| Research / high-churn doctrine | Predictability + low founder load | Modest intelligence trade |
| Brand-new adoption (first cycle) | Intelligence + low risk while learning | Speed, until rhythm proves |
The framework's conservative defaults bias hard toward intelligence + low risk — the right bias for a regulated multi-tenant profile where doctrine errors are expensive to roll back. A small source-available project can legitimately choose the opposite bias. Neither is "wrong"; they're different points on the same surface.
When an axis is a constraint, not a dial¶
The bias points above assume you're free to choose where to give. Sometimes you're not. An external mandate — a regulator, a contract, a compliance regime — can make one axis non-negotiable, and that changes the nature of the problem: the axis stops being a dial you turn and becomes a constraint that shrinks the reachable surface. The presets that violate the constraint are simply off the menu; you tune only among what's left.
The sharpest case is provability. If every change must be audit-ready and traceable to an immutable source (provenance law, read-back side), then:
- Provenance verification is pinned to strict — it is no longer a speed-vs-correctness dial you can relax.
- Risk tolerance is pinned low — the risk-tolerant presets that buy speed by skipping verification are unreachable.
- You are pinned to the conservative bias (intelligence + low risk), regardless of how much you'd prefer to move fast.
The practical consequence: you cannot have "ship-fast" and "prove-everything" at the same time. A move-fast startup and a mandatory-audit obligation are in direct tension — not because the framework forbids speed, but because provability removes the fast/cheap region of the surface entirely. Speed and cost then trade only against each other within the conservative envelope that remains.
This is why the very first tuning question is not "what do I prefer?" but "what is actually mandated?" Identify hard constraints before you pick a preset: a constraint deletes options, a preference merely biases among them. Choosing a fast preset and then discovering an audit obligation is the expensive way to learn this.
The dials, mapped to axes¶
Each tunable in this section moves the federation along one or more axes. The summary:
| Tunable | Page | Primary trade |
|---|---|---|
| Concurrency mode | Concurrency modes | Speed ↑ vs Risk ↑ |
| Mentor lifecycle | Context patterns | Cost ↓ vs Continuity / Pollution |
| Doer effort level | AI model choices | Intelligence ↑ vs Cost ↑ |
| Doer context scope | Context patterns | Intelligence ↑ vs Cost ↑ |
| Doer model tier | AI model choices | Intelligence ↑ vs Cost ↑ |
| Provenance verification | Guardrails → hallucination defense | Correctness ↑ vs Speed ↑ |
| Founder involvement | Constitution → founder role | Cost ↓ vs Founder load ↑ |
| Memory accumulation rate | Memory policy | Learning ↑ vs Noise ↑ |
| Rotation cadence | Context patterns | Pollution ↓ vs Continuity ↓ |
| Cycle-tail acceptance | Stage taxonomies | Predictability ↑ vs Speed ↑ |
| Audit/digest verbosity | Context patterns | Audit depth ↑ vs Cost ↑ |
| Cross-tier visibility | Context patterns | Containment ↑ vs Continuity ↓ |
| Enrichment (invariants/toolings/agents) | Invariants, toolings & agents | Intelligence ↑ vs Cost ↑ |
| Work granularity lane | Work granularity lanes | Ceremony ↔ change size |
The invariant floor under all of it¶
The load-bearing rules — firewall, hard labour, bus protocol, persistence law, dual validation — are [INVARIANT] across every point on the surface. They are not on any axis. You cannot trade them for speed or cost, because they are what make the federation's state trustworthy in the first place. Tuning happens on top of a fixed correctness floor.
This is the single most important thing to internalize about tunables: the dials are real and consequential, but they never reach below the floor.
How to choose¶
- Identify your project profile (above).
- Pick a starting operating preset (Toggles → Operating presets) that matches the profile.
- Run one cycle. Observe where it hurts — too slow? too expensive? an escape got through?
- Tune the one or two dials that address the pain, deliberately spending the axis you can most afford.
- Re-observe. Tuning is iterative, not one-shot.
Do not tune every dial up front. Most adopters touch three or four parameters in their first year.
Remember this¶
- There is no perfect setting. Every dial you turn up spends one of the other five axes — speed, intelligence, cost, risk, or predictability. Tuning is choosing where to give, not how to win everywhere.
- Start from a preset that matches your project, run one cycle, then adjust only the one or two dials that actually hurt. Don't tune everything up front.
- The dials sit on top of a fixed correctness floor — the invariant rules never move, no matter where you set the dials.
- If the trade-offs feel abstract, the mental model shows where these dials sit in the bigger picture.
How this connects¶
- The full parameter matrix lists every dial with defaults and ranges.
- Operating presets bundle dial settings into named starting points.
- The GitAI category explains why the correctness floor (git-backed state) is non-negotiable.