Almost every automated analysis system applies one criterion to the whole market. It works as long as the market resembles that criterion, and stops working when the regime changes — without anyone noticing, because there is no second point of view to contradict the first.
BO.I.A. starts from the opposite assumption. Six agents with structurally different readings — one following trends, one hunting excesses due for correction, one reading volume, one watching what company insiders do with their own money, one reasoning about the macroeconomy, one whose only job is to dismantle everyone else's case — are put into disagreement deliberately. The value is not in any single opinion: it is in how much they agree, and in what happens when they do not.
Every judgement carries a measure of how far the agents diverge. A unanimous consensus and one scraped together by a narrow majority are not worth the same, and the system does not present them as if they were.
The contrarian receives the stocks with the strongest consensus and must attack them. It does not vote: it produces a warning that stays attached to the final judgement. It is the structural brake against collective enthusiasm.
A forecast declares an action, a horizon and a confidence. At expiry the system checks whether it beat the index over the same window. The verdict is recomputed from raw data, never stored: nobody can retouch it.
Each agent is a language model driven by a versioned prompt and by a data selection different from the others. It does not produce free text: it produces a structured object validated against a schema. For every stock it returns an action (BUY / SELL / HOLD), a confidence, a reasoned thesis, a target price, a stop level and a time horizon declared in days.
That declared horizon is not a detail: it is the falsifiability condition of the forecast. An agent saying «it will go up» without saying by when cannot be proved wrong. Here every forecast carries its own expiry date, and at expiry it is judged.
Purely deterministic readings — whether one moving average sits above another, whether volume exceeds a threshold — are not delegated to the model. They are computed in code and handed to the agent already resolved. What is left to the model is judgement, not arithmetic: that is the part where a language model adds value, and the only part where it is used.
A goal that can be rewritten after the fact is not a goal. These are fixed in the project specification, together with the explicit condition that triggers its shutdown.
Portfolio return is a noisy measure of an agent's quality, because it also depends on how much capital goes into each position, on execution timing, on sector constraints and on cash left idle. An excellent agent inside a bad sizing rule produces a mediocre portfolio, and the reverse is equally true.
That is why the judgement on agents is anchored to the signal, not to profit and loss: hit rate at the declared horizon, average return against the benchmark over the same window, confidence calibration. The portfolio remains as a downstream reality check, but it is not the yardstick for deciding whether an agent is worth keeping.
The chain is deliberately asymmetric: almost all the work is deterministic and costs nothing, and artificial intelligence enters only at the point where judgement is genuinely required.
Closing prices and volumes, corporate events, derived technical indicators, macroeconomic series, transactions disclosed by executives to the US regulator. All from public sources, with continuity checks that flag gaps and discontinuities instead of ignoring them.
A mechanical filter, with no AI call whatsoever, cuts the index down to a few dozen candidates: the ones actually moving. It costs nothing and removes most of the downstream spend.
Each receives a data window built for its own specialisation and produces a structured judgement per stock. The contrarian goes last, once the others have spoken, and attacks the names with the highest consensus.
Deterministic aggregation, no AI: same input, same output, always. Out comes a consensus score, a disagreement measure, medians for target and horizon, and the contrarian's warning attached where applicable.
The four steps map onto four stacked layers. Information rises from the bottom; each layer is a separate package with the same internal structure — pure computation (no database, no network), persistence without commit, orchestration — so that the part which decides is always testable without touching real data.
The deterministic chain — price acquisition, events, macro, indicators, continuity checks, selection — is scheduled and automatic every night on a dedicated server, with external monitoring that raises an alert if a night is missed. The agent block and the portfolio chain are currently launched on command: that is the last link left to automate, and until it is, this page does not describe it as if it were.
These are not six variants of one line of reasoning. Each looks at a family of data the others ignore, and under different market conditions they reach opposite conclusions. That is precisely the intended effect.
The contrarian is the least intuitive architectural choice in the system, and the most important. Any engine that aggregates opinions tends to reward conformity: the more agents agree, the higher the score climbs. The contrarian exists to break that mechanism from the inside, and it is measured like everyone else — with the understanding that a low hit rate is its expected behaviour, not a defect.
All agents currently run on the same low-cost model to keep spend down. More capable models are a lever deliberately left unpulled: they will be brought in if and when the engine has proved it works, and the comparison will be made with everything else held constant.
Six further agents are specified but not in operation, and in no case as an aesthetic choice: each is blocked on a declared dependency. Three balance-sheet analysts are waiting on the ingestion of structured financial filings; a news analyst and a social sentiment analyst are waiting on their respective sources; a chart-pattern reader requires a multimodal model, at a value-to-cost ratio that does not currently justify it.
Why this matters when assessing the project. Squad composition is versioned. When a new agent joins, the historical performance series are not contaminated: every evaluation window stays bound to the squad active in that period. Without this, any apparent improvement would be indistinguishable from a change of line-up.
The point where most multi-agent systems insert yet another language model is, in BO.I.A., deterministic code. The reason is verifiability: an aggregation performed by a language model is not reproducible, not inspectable and not recomputable months later. This one is.
The arbiter receives the signals available for a stock and produces a consensus score between −1 and +1: the average of direction times confidence across the sources actually present. The final label follows the pure sign of that score. Alongside it, a disagreement score computed as the normalised entropy of the directions: high means the agents are deeply split, and that number travels with the judgement instead of being buried.
The design provides for reputational weights that reward historically more accurate agents. Today those weights are fixed at 1.0, deliberately. Estimating reputation from a few dozen outcomes means amplifying noise and calling it learning: a handful of lucky calls would be enough to let one agent dominate. Activation is gated on a minimum number of resolved outcomes, with shrinkage toward the neutral weight proportional to sample size.
The rule. Any adaptive mechanism that does not yet have enough data to work stays switched off and is declared switched off. The cost of this choice is a less spectacular page; the benefit is that no number published here is the product of fitting on a sample that could not support it.
This is the idea the whole evaluation rests on, and the reason the results below are harsher than the ones found elsewhere. The question is not «did it make money». It is: did it do better than sitting still in the index, over exactly the same window?
Every forecast has an entry date (the close of the day the analysis refers to) and an expiry (the horizon in calendar days the agent declared itself). At evaluation the system takes the last available close within the expiry, computes the return of the stock and of the benchmark across the same two dates, and the difference is the outcome. A BUY is correct if the excess is positive, a SELL if it is negative.
A forecast can be mature (the horizon has passed and prices exist), in progress, without horizon (the agent never declared one: it leaves every statistic), or not evaluable with an explicit reason. The distinction is not pedantry: collapsing these states into a boolean turns a missing datum into a zero, and a zero into a tie that never happened. HOLD positions stay outside the hit-rate denominator, because they express no direction to verify.
Outcomes are never stored anywhere: they are recomputed from raw prices on every request. This is a structural choice, not a convenience — a stored result can be corrected, updated or forgotten without anyone noticing. The guarantee is verifiable in the code: the module computing outcomes imports no module capable of writing. When the denominator is empty the hit rate is null, not zero per cent; when the sample falls below roughly thirty cases, the system prints its own statistical insufficiency warning.
Independent verification. Before any number was published, one outcome was recomputed by hand — direct database query and decimal arithmetic performed separately from the code — and compared field by field against the system output: prices, dates, returns, excess, verdict. Exact zero discrepancy on every field.
These are the first outcomes produced by the system on real forecasts, not on retrospective simulations. They are published in full, including the rows the project would rather not show.
| Agent | Matured | Hit rate | Reading |
|---|---|---|---|
| Volume Whisperer | 33 | 0.667 | Best of the group over this single window |
| Arbiter | 45 | 0.581 | 43 directional, two HOLDs outside the denominator |
| Trend Hunter | 44 | 0.545 | Above the coin toss, barely |
| Devil's Advocate | 45 | 0.450 | Only 20 directional: contrarian by construction |
| Reversion Sniper | 46 | 0.326 | Mean excess negative: over this window it subtracted value |
The most interesting row is the last one. An agent performing worse than chance, with a negative mean excess, is a candidate for removal — and the same architecture that produced it is the one putting that in writing, publicly. The second notable figure is that the arbiter beats every agent it aggregates except one: over this window, aggregation added something to its own ingredients.
This is a measurement, not evidence. A single sample, one market period, no statistical significance claimed or computed. A hit rate over a few dozen cases is entirely compatible with chance. These numbers are not used to rank the agents, to weight them in the arbiter or to remove any of them, and they should not be used that way by the reader either.
Three simulated portfolios start from the same notional capital of ten thousand and are compared continuously. A buys the index and holds it: the wall everything must be measured against. B follows a single agent. C follows the arbiter with the full squad. B against C is the direct test of the hypothesis the project rests on.
Four reasons not to draw conclusions from these numbers.
This is not a strategy in operation. Across the 43 sessions measured, no trade was executed: the portfolios held their opening positions from the first day to the last. What is observed is the quality of the initial selection, not the working of the system.
The protective stop was detected but not executed. Violations were recorded as a measurement, not acted on. A real portfolio would have closed those positions and the subsequent curves would differ, in a direction that cannot be determined after the fact.
Forty-three sessions are not a sample, least of all with one portfolio per strategy. They do not separate signal from noise in either direction.
The rebalancing was executed at the final point of the curve, so its effects have not yet entered any of these values.
The two blocks of numbers say apparently incompatible things. At the signal level, the arbiter does better than the single agent driving portfolio B. At the portfolio level, B beats C by five points. If the discrepancy held on a serious sample, the implication would be precise: the bottleneck would not be the squad but portfolio construction — the filter admitting only buy judgements, the ten-position limit, the three-per-sector cap, the fixed allocation per position.
That would be good news for the project, because portfolio construction is the deterministic part: change it, remeasure, compare. But it is exactly the kind of conclusion a sample this size cannot support, and so it is not drawn. It stays on record as a hypothesis to be tested when the data exist to test it.
How portfolio writes are verified. Every real rebalancing is validated with four arithmetic recomputations independent of the code that produced it — proceeds from closures, full sizing of openings, immutability of the fields that were not meant to change, manual reconstruction of cash — plus a check that cash and positions add back exactly to portfolio value. An exit code of zero is not treated as proof.
It is the first question anyone assessing an analysis system asks, and the answer is the most important part of this page: a backtest of the agents would be a false measurement, and it would be false in a predictable direction — upward.
Contamination. Language models are trained on text that includes how those years turned out. Asking an agent what it would have done in 2019 means asking someone who already knows the answer. No prompt engineering removes the problem.
Survivorship. A test built on the index's current members ignores the companies that left it because they failed, were delisted or acquired. The sample is already selected for having survived, and every result comes out inflated.
The consequence is uncomfortable and worth stating: the only honest evaluation runs forward, live, day by day. Time spent in operation is the project's critical resource, and there is no shortcut for accumulating it.
The exclusion applies to the agents, not to the whole engine. The deterministic components — selection criteria, position sizing, stop thresholds — are ordinary code and can be tested backwards without contamination, because they contain no model that has read history. On those, retrospective testing is useful for comparing parameterisations and for telling statistical variability apart from a structural defect.
The line is sharp and worth stating plainly: test backwards everything that has no memory of the future, and nothing else. Any system presenting brilliant retrospective curves on decisions taken by a language model is, knowingly or not, measuring the model's memory rather than its judgement.
The economics of the engine are the reason the architecture can afford six opinions instead of one — and the reason it will be able to afford twelve without changing order of magnitude.
Figures from a real run, not estimates: fifty stocks selected from the index, six agents plus the arbiter, two hundred and sixty executions in total. The distribution of final judgements that night — thirty-eight buys, seven holds, five sells — is itself a monitored datum: a skew toward buying is a known flaw of the category, and it is tracked over time rather than ignored.
The system runs on a dedicated server, with an isolated application database and an unprivileged role. The nightly deterministic chain is scheduled and completes in under an hour; an external monitoring service receives a heartbeat on every run and raises an alarm if a night is missed.
Backups are daily, encrypted and kept off the server, with thirty-day retention. The relevant difference is not that they exist: it is that the full restore chain — dump, archive, extract, load into an empty database — has been carried out end to end and verified to an identical cryptographic fingerprint, with tables and indexes counted. A backup that has never been restored is a hypothesis, not a guarantee.
The read interface is not exposed on the public internet. Data sources are public and free: prices and volumes, official macroeconomic series, corporate filings with the US regulator. There are no proprietary data subscriptions in the cost structure, and that is a scalability property rather than a compromise.
The dominant cost is not AI. At these volumes, model spend is negligible against engineering time. That is why the most promising lever is not reducing calls but increasing the quality of judgement per call — and why moving to more capable models remains an economically open option at any moment.
A project setting out to beat the market must state up front how unlikely that is. Here it is stated, together with the thresholds beyond which the system stops itself.
At the six-month review, if risk-adjusted return is below threshold or the shortfall against the index exceeds the set margin, the system opens its own assessment screen with a full attribution of where gains and losses came from. At twelve months, if the index has not been beaten in a statistically defensible way, the explicit recommendation is to archive.
In simulated portfolios the gains are clean. In reality commissions, slippage — the difference between the observed price and the one actually obtained — and taxation erode the margin, and they do so systematically, not randomly. A strategy earning three per cent gross on frequent trades can close at a net loss.
That is why the design provides for filtering out recommendations that would not be profitable net of costs, before they are ever presented. A theoretical gain that disappears after commissions and tax is not a gain: it is a measurement error.
On verification discipline. The project keeps an explicit register of its own open defects, numbered and dated, including the uncomfortable ones: metrics that depend on data freshness, components never exercised at runtime, checks that passed without their reason being understood. A recorded defect is one someone can ask to have closed; an unrecorded one is not.
The system today produces structured judgements, measures them against the benchmark and keeps the complete history of every forecast issued. What is missing is the public surface: a site where those analyses, and above all the outcomes of the previous ones, can be consulted by anyone.
The sequence is deliberate. Building the shop window first and the method afterwards would have produced a more impressive page and a weaker engine. The reverse order costs visibility and pays in credibility: when the analyses go public, they will come with the full record of the wrong ones, because the mechanism that computes it already exists and was built so that it cannot be tamed.
BO.I.A. does not sell a forecast. It builds an engine that produces falsifiable forecasts, declares in advance the standard for judging them, and publishes the result even when it is mediocre.
The open question is not whether it will work. It is whether twelve months of honest measurement will say something that twelve months of retrospective curves never could.