Skip to content

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 five-axis tunable trade-off space — Speed, Intelligence, Cost, Risk, Predictability — with project-profile bias points

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

  1. Identify your project profile (above).
  2. Pick a starting operating preset (Toggles → Operating presets) that matches the profile.
  3. Run one cycle. Observe where it hurts — too slow? too expensive? an escape got through?
  4. Tune the one or two dials that address the pain, deliberately spending the axis you can most afford.
  5. 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


Next: Axis declarations →