A confidence is easy to print and hard to earn

A strategy is a small, readable specification, not a model. It names a set of long conditions and, optionally, a set of short conditions. Each set is a conjunction, meaning every condition in it must hold. Each condition compares one reading from the cycle's saved market snapshot against a fixed threshold with one of six operators.

The engine evaluates both sets against the same snapshot. If every long condition holds, the side is LONG. Otherwise, if every short condition holds, the side is SHORT. Otherwise the side is NO_TRADE. There is no scoring, no weighting and no tie-break, because there is nothing to break a tie between, because the long and short sets are checked in that order and the first one that fully holds wins.

If a condition cannot be evaluated at all (the field it reads did not resolve from RYO), its group is neither satisfied nor refuted. The side falls to NO_TRADE and the decision is marked degraded.

apps/server/app/strategy.py, evaluate()

Every strategy declares a base confidence between 5 and 95. That number is a property of the strategy, chosen by whoever wrote it, and it is the same on every cycle. It is not derived from the market, so it carries no provenance mark, because it did not come from RYO. Everything after it is a fixed integer named by a rule.

apps/server/app/strategy.py, evaluate() and apps/server/app/llm.py, apply_veto()

Each adjustment rule names a field, an operator, a threshold and a fixed integer delta. When one holds, the receipt records “lower confidence by 10 points when Market Mood is above 60/100.” The technical receipt keeps the exact field key in decision.reasons, so the calculation can still be reproduced precisely.

Adjustments move a number that was already chosen; they never choose. An adjustment rule cannot create a side, cancel a side, or change which conditions were checked. If every adjustment rule in a strategy were deleted, every side on every receipt would stay exactly what it was.

After the rules have decided, an optional review runs. It is given the decision, the resolved field values, and a small set of extras from the RYO deep analysis. It is allowed to return exactly one of three actions, which are none, lower, and veto. It cannot return a side.

The reply is validated before it is allowed to touch anything, and every correction is written onto the receipt rather than hidden.

• An action outside those three is discarded and recorded as action 'x' not allowed; treated as none.
• A positive delta is not accepted as a rise. It is negated and the substitution is recorded.
• A citation naming a field the model was not given is dropped, and the dropped names are recorded.
• lower with a delta of zero is recorded and downgraded to none.

What survives validation is applied by one line of arithmetic, in which the confidence becomes max(5, confidence − |delta|), and a veto additionally forces the side to NO_TRADE. There is no branch anywhere in that function that can raise a confidence or set a side to LONG or SHORT.

apps/server/app/llm.py, validate_veto(), apply_veto()

What is running right now not read yet.

A confidence is a claim about one specific future check, not a general feeling of certainty. It says that at this receipt's horizon, the side recorded here will be graded correct.

The grading rule is arithmetic and fixed in advance, so it cannot be argued about afterwards.

threshold = 0.5 × atr14

Half the 14-period average true range recorded on the receipt. A move smaller than this counts as no move.

LONG is correct

when the exit price minus the entry price is greater than the threshold.

SHORT is correct

when the exit price minus the entry price is less than minus the threshold.

NO_TRADE is correct

when the move stays inside the threshold in either direction.

No atr14, no verdict

When the receipt was written without an ATR reading there is no band to judge the move against, so the outcome is recorded as not evaluable and carries no result. It is counted in neither the hit rate nor the Brier score. Substituting a zero-width band would have marked a NO_TRADE wrong the moment price moved at all, which is a verdict invented out of a measurement that was never taken.

Those last two rules are why the track record reports the directional calls separately from the abstentions. A NO_TRADE is graded on price staying inside the band and a LONG or SHORT on price leaving it the right way; they are different claims, and a strategy that abstains almost always can score well overall while never having a directional call tested. The pooled figure is kept, and the split beside it says which half produced it.

A receipt resolves at its creation time plus the smaller of the strategy horizon and the server-wide cap, which is currently not reported by the server. The exit price is read from a snapshot at or after that time, from the same field and the same tool the entry price came from.

apps/server/app/resolver.py, outcome_for(), resolve_due()

A confidence that is never checked is a decoration. The check is the Brier score, which is to take each resolved decision, subtract what actually happened (1 if it was graded correct, 0 if it was not) from the confidence that was stated as a fraction, square the difference, and average across all of them. Zero is perfect, and lower is better. It punishes being confidently wrong far harder than being unsure.

One average can hide where a strategy struggles, so Ambang also scores smaller comparison groups. Receipts belong to the same group when they share the same market regime, market phase, and confidence range such as 60–69%. For example, a strategy may be dependable at 70–79% confidence in a calm market but overconfident during a volatile transition. Both results stay visible instead of being blended into one flattering average.

Read that table before reading any confidence on this product. Until it loads, assume the grading is thinner than you would like, because this build is days old and outcomes resolve slowly.

The record as it stands , What this system cannot do , Which fields resolve