The fastest way to build a competitive AI product today is to take an existing open-weight or licensed base model and fine-tune it for your use case. It works, and most AI products are built exactly that way. We chose a slower, more expensive path instead: every version of tAI, from the earliest release through tAI 4.2, has been trained end to end on data we collected and compiled ourselves, with no third-party corpus used as a base at any point.
Why not fine-tune something else
Fine-tuning someone else's base model means inheriting its defaults, its blind spots, and its training decisions, most of which you can't fully see or change. For a product that's meant to work heavily in Turkish, operate tools on your behalf, and be trusted with your email and code, we didn't want to build on a foundation we couldn't fully account for. Training from scratch means the model's behavior, from how it handles an ambiguous instruction to how carefully it treats a destructive action, is something we actually built and can explain, not something inherited and then patched around the edges.
This is also, honestly, the harder and slower path. A from-scratch training run costs more compute and more time than a fine-tuning pass, and it means every capability the model has, reasoning, coding, tool use, has to be built up directly rather than borrowed from a much larger base model's existing competence. We think that cost is worth paying for a product people are trusting with real work, and it's a large part of why new tAI versions ship on the cadence they do rather than more frequently.
The two corpora behind every version
Two datasets anchor the current generation of tAI models, both built and maintained in-house:
- ArtficalAI: a multilingual, Turkish-weighted general text corpus covering reasoning, conversation, and general knowledge. This is the backbone for how the model reasons, writes, and holds a conversation, in either language.
- Artfical Code Index: a compiled corpus of code and repository data, built specifically for agentic coding and tool-use, versioned separately from the general corpus and updated as the kinds of coding tasks people actually run tAI on shift.
Neither corpus is a single static snapshot. Both are actively curated: filtered for quality, checked for the kinds of duplication that make a model overconfident about narrow patterns, and weighted toward tasks our own usage data shows people actually need, rather than optimized once against a fixed public benchmark and left alone.
Versioned, not frozen
Each new tAI release is a genuine retraining against an updated version of these datasets, not a patch or an adapter layered on top of the previous model. tAI 4.2's training data reflects a further iteration of the Artfical Code Index beyond what tAI 4.1 was trained on, for example, which is a large part of why coding performance moves meaningfully between versions rather than incrementally.
This versioning discipline extends to how we handle a model already in production. When tAI 4.2 launched and started carrying most of the highest-risk traffic, we revisited tAI 4.1's safeguard thresholds and eased some of them, specifically because the overall system's safety posture had changed, not because we'd stopped paying attention to an older model still in active use.
Turkish first, not translated afterward
Most large language models are trained primarily against English data, with other languages handled through a secondary fine-tuning pass or translation layer. tAI is used heavily in Turkish, so we built the training pipeline the other way around from the start: the Turkish-weighted portion of the ArtficalAI corpus sits alongside English in the base training data itself, not bolted on afterward as a localization step.
The practical difference shows up in places a translation layer typically misses: idioms that don't map cleanly across languages, natural code-switching between Turkish and English inside a single message, and informal register that a purely translated model tends to render stiffly. We test for this directly rather than assuming general multilingual benchmarks capture it, and it's a metric we track on every new version alongside reasoning and coding scores.
"tAI 4.1 was the first version where I stopped re-explaining myself halfway through a long session, in Turkish or English." (internal testing note, Artfical DT)
How we evaluate a new version
Before any model ships, it's measured against our own internal evaluation suite covering coding benchmarks like SWE-Bench and Terminal-Bench, general reasoning and knowledge benchmarks like GPQA and MMLU, and long-context retrieval tests we built specifically to check whether the model still honors a constraint given dozens of turns earlier in a session. Published third-party benchmark numbers we reference for comparison are the official results those providers published themselves; every tAI score is one we measured ourselves, against our own harness, so it reflects how the model actually behaves in the kind of long, tool-using sessions people run it in, not just isolated single-turn prompts.
The detailed numbers for each release, along with what specifically changed in that version's training data and evaluation results, are published on that model's own announcement page, tAI 4.2 and tAI 4.1 among them, rather than summarized only here.