OB Studio

Project · snapshot October 10, 2026, 18:04 KST

Tot-360M

A language model with 345,359,296 parameters, trained from scratch for one purpose: to be the independent model inside Tot, an AI companion that can eventually run on my own laptop and a Raspberry Pi.

What this project is

Tot is an AI companion being developed for OB Studio. The wider project is a desktop app plus web tools, meant for everyday conversation, help with work, and simple actions through the app's tools.

It began on other companies' models through OpenRouter. The current direction is an independent model that can run offline on hardware I own. Parameters are the numbers a model learns during training, and 345 million is small enough to fit on a laptop or a Raspberry Pi once it is compressed for inference.

Tot is the product name. Iris is its intended personality: soft, understanding, quietly determined and willing to disagree honestly. The style I want is concise and helpful, with one manageable step at a time when someone feels overwhelmed.

The numbers that exist

Parameters
345,359,296
Counted from the actual architecture, with shared word embeddings. Named 360M for short.
Tokenizer
32,000 tokens
Built for this model. It turns text into the numbers the model reads.
Training data so far
~7.2M tokens
A calibration snapshot in 16 verified files with held-out examples. It is not the full pretraining set.
Architecture
Qwen3-compatible layout
Trained from scratch. Not a renamed pretrained Qwen. The layout matches what llama.cpp already runs.

A tokenizer splits text into pieces and maps each piece to a number, and the model only ever sees those numbers. The 32,000-piece vocabulary was built for this project. The 7.2 million tokens of training data are a calibration set: enough to check that loading, batching and checkpointing work end to end, and far too small to teach a model language. The planned pretraining dataset is much larger and is not built yet.

The architecture and its PyTorch implementation are done. I verified the full parameter count without allocating the full weights, and ran numerical checks on a two-layer version covering attention, gradients and loss behaviour.

Status, step by step

Progress snapshot · October 10, 2026, 18:04 KST

  1. 01

    Architecture and PyTorch implementation

    Parameter count and tied embeddings checked without allocating the full weights. Attention, gradients and loss behaviour pass numerical checks on a two-layer version.

    Done
  2. 02

    Tokenizer and calibration data

    32,000-token tokenizer and about 7.2 million packed tokens, with separate held-out examples.

    Done
  3. 03

    Export and inference compatibility

    A miniature model exports and runs on a pinned llama.cpp build. A miniature model also saves its training state and resumes in a fresh process from real data files.

    Done
  4. 04

    Kaggle TPU training run

    Version 4 got a TPU and verified the inputs, then failed starting the eight parallel workers because Kaggle set a conflicting single-worker address. No training step was verified. Version 5 has the fix and is submitted. At the snapshot time it was still queued for a TPU.

    In progress
  5. 05

    Full pretraining

    Not started. Needs a working distributed run first, then the full dataset.

    Not started
  6. 06

    Personality training and evaluation

    Iris personality training, quality evaluation, and measured speed and memory on a laptop and a Raspberry Pi. The earlier RAM and speed figures were targets, not measurements.

    Not started

What went wrong so far

Kaggle version 4 obtained TPU hardware, installed the runtime and verified the input files. It then failed while starting the eight parallel workers, because Kaggle had supplied a single-worker address setting that conflicted with the distributed launch. Not one training step was verified in that run.

Version 5 contains the corrected launcher, which passed local tests before being submitted. At the snapshot time it was queued. A successful distributed run, recovery on the TPU and a usable trained checkpoint have not been established.

Independent reviews along the way found and fixed several other problems in the notebook, runtime setup, data checks, timeout handling and checkpoint logic. I would rather publish the failed run than a tidy story.

The first target

The first capability goal is Qwen3-0.6B, including the roughly five-point range shown on the Artificial Analysis Intelligence Index, together with useful conversation and simple tool use. This is an ambition for the first version. Tot-360M has no measured benchmark score, and until it does, treat every claim about its ability as a goal.

Questions

Is Tot-360M a fine-tuned Qwen?
No. It is designed to be trained from scratch. It uses a layout compatible with Qwen3 so that llama.cpp can already run it, but the weights start random and are learned from our own data.
Can I download it or chat with it?
Not yet. No successful training run exists, so there is no trained checkpoint. The Tot desktop app currently uses other providers' models through OpenRouter or Gemini with your own key.
Why 345 million parameters and not 360 million?
The name is a rounded label. The counted number from the actual architecture, with shared word embeddings, is 345,359,296.
Will it really run on a Raspberry Pi?
That is the intended finished product. Memory and speed on a laptop and a Raspberry Pi have not been measured, and any earlier figures were targets.
Is training done locally?
No. Training uses cloud hardware, currently a Kaggle TPU. Only the finished model is meant to run locally and offline.

Want to try what exists now? The Tot desktop app is in public alpha and runs today on other providers' models.