One decision tree to place your idea in a type, and which rules the code actually blocks.
Is it "one symbol, a fixed interval, one position (long / short / flat)"? Yes → Type A (signal).
Is it "a basket of symbols, each with a weight, rotated and reweighted on a schedule"? Yes → Type C (portfolio).
The rest (screeners, grid bots, arbitrage, one-off runs, alert bots) → Type B.
When A and C blur, check that two things hold at once: how many symbols (one vs several) and the shape of the position (a single long/short/flat vs a set of weights). Multi-symbol rotation and portfolio rebalancing are Type C, not Type B.
| Item | Type A — signal | Type C — portfolio | Type B — the rest |
|---|---|---|---|
| Symbols | 1 | N | No limit |
| Position shape | One position, may be fractional | Weight vector, by design summing to ≤ 1 | No fixed shape |
| Template | Yes | Yes | None, written from scratch |
| Backtest | The agent always runs one first | The agent always runs one first | Not run |
| Auto-trading | Supported | Capital allocation not supported yet | You write the order logic |
| Backtest report | Full, with Sortino, Omega and an MCPT p-value | Lighter: no Sortino / Omega, no automatic MCPT | None |
Because it does not exist. The three types are a way of classifying strategies as you write them, not a state the system keeps.
On the machine side the type comes from what the signal function returns: return a single series and it takes the Type A path, return a weight matrix and it takes the Type C path — no type constant is read anywhere. On the platform side the type is inferred back from the shape of the backtest result, and the one place a type is ever handed out carries just two values: portfolio and signal.
So the system does not separate a Type B from a Type A that has not been backtested yet. Picking the wrong type is neither blocked nor flagged — typing earns its keep by pointing the agent at the right shape of code and the right checks, not by making the system track it for you.
The signal function returns a number on every bar (every interval):
| Return value | Meaning |
|---|---|
Positive (1.0, 0.6…) | Long; the number is the position fraction |
Negative (-1.0, -0.6…) | Short; the number is the position fraction |
0.0 | Flat |
nan | Keep the current position unchanged |
A signal fills at the open of the next bar; a futures settlement exit fills at the close of that same bar.
The number is not clipped: 0.5 is half size, 2.0 is double leverage, and the code sizes it that way. Volatility targeting produces fractional signals of its own accord, and its exposure ceiling is a parameter default, not a system limit.
A Type A strategy that has been backtested can join the auto-trading portfolio: give it an amount in Trading setup and it writes its position state, then the reconciler sums the targets of every strategy and adjusts positions at the exchange (see Live Trading Portfolio). A strategy with no amount gets no orders.
The signal function returns a weight matrix (the target weight for every symbol at every point in time) plus the matching price data. The rebalance interval can be daily, weekly or monthly and the strategy implements it itself — both ready-made examples (a foreign-net-flow z-score picking from 100 Taiwan stocks, and a momentum Top-30) rebalance weekly.
A weight sum of ≤ 1 is a design convention, and the code does not check it. A sum above 1 raises no error; it goes straight into the return as leverage.
Type C does not support putting capital into the auto-trading portfolio today. The root cause is that the path is not there: a Type C strategy writes no position-state file, so the reconciler does not see it, and capital assigned to it still produces no orders. The workspace locks the amount field for Type C, but treat a Type C backtest as something to read and share, not something to fund.
Type C also has no automatic MCPT — that test runs one price series against one position series, a portfolio has several, and flattening them into one amounts to resampling realized returns. The strategy library marks this gate "not applicable", which is not the same as failed.
Type B has no template, is written from scratch and runs no backtest. And a strategy only reaches the auto-trading selection list with a non-empty backtest result, so Type B never shows up there.
It still places orders — calling the ready-made order libraries itself, on its own schedule. Blave Agent is not a "signals only, hands off" product: Type A goes through auto-trading reconciliation, Type B sends its own orders.
| Item | What actually happens |
|---|---|
Backtest end date left off None | Refuses to run the backtest |
| A TAIEX futures strategy with no settlement mask applied | Refuses to run the backtest |
| Signal function missing, or returning nothing | Refuses to run the backtest |
| Fee set to 0, or written as an expression | Marked as a problem, runs anyway |
| An indicator-style Type A that declares no series to plot | Reminder, runs anyway |
| Type C weights summing above 1 | No check; counted straight as leverage |
The bottom three rows are conventions, not gates. The agent reminds you of the practice, but no code stands behind it — which is also why the avoiding overfitting checks come down, in the end, to whether you decide to run them.
| What you assume | What is true |
|---|---|
| Multi-symbol rotation is Type B | Weights plus a periodic rebalance make it Type C |
| A Type C that passed its backtest can go live on auto-trading | The backtest is there to show performance; there is no funding path today |
| The backtest report has a win rate | There is no win-rate field; you work a win rate out yourself from the per-trade entries and exits, and a Type C backtest report carries no per-trade detail (see How to Read a Backtest) |
| The system blocks you if you pick the wrong type | It does not; the platform cannot hold a type. The wrong type only gets you a shape of code and a set of checks that do not fit |
With the type settled, the next thing is seeing what it looks like running. The official strategies in the Strategy Library all come with a real backtest and a stated backtest period, free to read; picking one and running it tells you which type you want to write faster than finishing this page does.
