The platform under TrendBrain
Thousands of virtual players only pay off if each one costs almost nothing. So the platform is built around one research question – how much AI capability fits into each watt – plus open models on our own machines and cloud bursts where they run out.
Research: intelligence per watt
TrendBrain's simulations need thousands of virtual players and audiences. That only works if each agent costs almost nothing. So we research how to get the most AI capability out of the least compute.
We route easy work to small models, distil one small specialist per role, swap lightweight adapters on a single base model, quantize simple agents hard, and let scripted bots handle routine moves while a language model steps in only at real decisions.
Every simulated player climbs a ladder
A scripted or reinforcement-learning bot makes the routine moves. A small model steps in at real decisions. A large model is only asked when the small one is unsure. A router decides each step, so the expensive model sees as few calls as possible.
The guiding question
How many believable virtual users and how many checked forecasts can one workstation produce per hour – and how do we multiply that number by ten without measurably losing quality?
Quality means how close the virtual players' behaviour comes to real comparison data. A technique stays only if it moves this number without making the virtual players less realistic – the same baseline discipline as in TrendBrain. First measurements on our own hardware are next.
| Line | Idea | What we measure | Status |
|---|---|---|---|
| Router and specialists | Easy tasks go to small models, only hard ones to large models. | Cost per task at equal quality | Partly built routing table |
| Distillation | A large teacher model writes examples; a small student model learns exactly one role. | Student vs. teacher quality, per role | Planned |
| Swappable role adapters | One base model in memory, many small LoRA adapters switched in per agent instead of many models. | Agents per GPU, memory per agent | Planned |
| Aggressive quantization | 4-bit down to ternary weights for simulated agents that only make simple decisions. | Quality loss vs. throughput gain | Research |
| Speculative decoding | A small model drafts, a large model only checks. | Tokens per second at identical output | Research |
| Hybrid agents | A scripted or RL bot makes most moves for a fraction of a cent; the language model only acts at decision points. | Language-model calls per simulated player | Planned |
| Caching and reuse | Identical contexts, personas and intermediate results are not recomputed. | Share of compute saved | Planned |
| More thinking, smaller model | Small models with a checker and several attempts instead of one large model with one attempt. | Hit rate per GPU-second | Research |
Credits fund the experiments; the results make every later run cheaper.
Research basis: FrugalGPT and RouteLLM (routing); Hinton et al. 2015 (knowledge distillation); Leviathan et al. 2023 (speculative decoding); Ma et al. 2024 (1.58-bit models, BitNet b1.58); Snell et al. 2024 (test-time compute for small models).
Hybrid: what runs where
Local first, cloud where local hardware runs out. Each kind of work goes where it is cheapest and safest.
On our own machines
Inference for every agent, the database, the forecast log, unreleased content and training data. Which model runs, in which version, is our decision, and costs are hardware and power instead of per-request bills.
In the cloud
Fine-tuning runs, data snapshots, simulation bursts with thousands of virtual players, and traffic peaks. This is where cloud credits make the biggest difference.
Every open model is tested for its task before it is used. Where we are: most test runs so far covered single parts of a flow, with stand-ins for real models and platforms.
Tech stack
Boring where it can be, so the experiments are where the risk is.
- Models
- Open-weight models for language, image, video, speech and time series, served locally.
- Compute
- GPUs with CUDA; vLLM and SGLang for serving.
- Code
- Python for TrendBrain and the pipelines; Luau with Rojo for Roblox prototypes.
- Data
- PostgreSQL as the single source of truth, Parquet snapshots for reproducible data states.
- Training
- Written skills first, then small LoRA role adapters, then learning from people's approvals (DPO), then agents that read their own failure notes before the next run (Reflexion).
- Web
- Cloudflare.