Introducing tAI 4.2

Today we're introducing tAI 4.2, the largest and most capable model in the tAI family. It is built for professional, knowledge-heavy work and for agents that need to stay coherent across long, multi-step tasks: writing and debugging real codebases, working across spreadsheets and documents, reasoning through ambiguous instructions, and carrying a plan from start to finish without losing the thread.

Announcements

Availability and pricing

tAI 4.2 is available now at tai.artfical.com, through api.artfical.com for developers, and through the developer console for key management and usage tracking. Existing chats and any custom instructions or memory attached to them carry over automatically, there's nothing to migrate. If you'd rather keep using tAI 4.1 for a specific chat or project, it stays selectable in the model picker, we're not retiring it alongside this release.

Pricing is usage-based and billed per token. Input costs $1.00 per million tokens, output costs $2.50 per million tokens, and cached reads, repeated context like a long system prompt or a pinned document, cost $0.05 per million tokens. Inside tAI itself, tAI 4.2 sits on the Pro tier; tAI 4.0.6P and 4.0.6B remain free for everyday use.

Architecture

tAI 4.2 runs on ArtficalAI ROD 2, the second generation of Artfical's own model architecture, succeeding the architecture behind tAI 4.1. ROD 2 is a from-scratch redesign, not a scaled-up version of what came before it, focused specifically on getting more useful computation out of every token instead of just adding parameters. A more efficient attention mechanism and better load-balancing across the underlying hardware mean tAI 4.2 does more per token than tAI 4.1's architecture could, which shows up directly in the pricing above: roughly 30% lower cost to serve per output token than tAI 4.1's architecture, alongside a noticeably faster time-to-first-token on typical requests.

The capability gains covered in the sections below come from training and data, not from the architecture change on its own. What ROD 2 buys is headroom: the same or better quality at a lower serving cost, which is what let us hold tAI 4.2's price close to tAI 4.1's despite it being the larger, more capable model.

Use cases

We built tAI 4.2 around a simple observation: most of the value people get from a language model doesn't come from a clever one-line answer, it comes from a model that can sit with a real task for a long time and not fall apart. That means holding onto context across dozens of tool calls, recovering gracefully from its own mistakes, and knowing when to ask a clarifying question instead of guessing.

Economically valuable tasks

We evaluated tAI 4.2 against a broad set of well-specified, knowledge-based tasks spanning dozens of professional fields, including spreadsheet modeling, presentation drafting, structured writing, research synthesis, and technical documentation. Across these tasks, tAI 4.2 shows a clear, consistent improvement over tAI 4.1, our previous flagship, particularly on tasks that require carrying constraints across several steps rather than answering in a single pass.

What stands out in our internal review isn't any single benchmark score, it's how often the model gets a task right on the first attempt without a follow-up correction. On a sample of real support tickets, contract redlines, and financial summaries pulled from our own usage logs (with identifying details stripped), reviewers accepted tAI 4.2's first draft outright markedly more often than tAI 4.1's, which is the metric we actually care about, since a second round-trip is where most of the time cost of using a model shows up in practice.

Coding

tAI 4.2 was trained heavily on the Artfical Code Index V12.2, our internally compiled corpus of code, commit history, and tool-use trajectories. In practice this shows up as fewer broken edits, better handling of large existing codebases, and steadier behavior across long agentic coding sessions where the model has to plan, write, run, read the output, and revise, repeatedly, without supervision.

It's also noticeably better at reading a codebase before changing it, tracing how a function is actually called across a repository instead of assuming from its name, catching an existing test that already covers the change it's about to make, and stopping to ask when a requested fix would touch code outside what was described. None of that shows up cleanly in a single benchmark number, but it's the difference between a diff we can merge with a quick skim and one that needs a careful re-read.

Agentic tool use

A growing share of real usage is no longer a single question and answer. Increasingly it's a model operating tools on someone's behalf over an extended session: querying a database, editing files, calling an API, checking the result, and deciding what to do next. tAI 4.2 was trained specifically to be more reliable in this loop, with meaningfully fewer dropped steps and less drift from the original goal as sessions get longer.

We also spent time on failure recovery specifically: when a tool call errors out, comes back empty, or returns something the model didn't expect, tAI 4.2 is more likely to notice, explain what went wrong, and try a different approach instead of quietly continuing as though the call had succeeded. That matters most in exactly the sessions where it's hardest to catch, the long ones a person isn't watching turn by turn.

Long context

Long, messy, real-world context, a full repository, a stack of documents, a sprawling conversation history, is where models most often lose track of what actually matters. tAI 4.2 is noticeably steadier here: it holds onto earlier constraints and instructions further into a session, and is less likely to quietly contradict something it was told at the start.

This is deliberately not the same thing as a bigger context window on its own. A model can technically accept a huge amount of text and still lose track of what's important inside it. What we tuned for is retrieval under pressure: when a session is packed with tool results, file contents, and back-and-forth, can the model still find the one constraint from forty turns ago that actually governs the current step. That's the failure mode long sessions run into most, and it's the one tAI 4.2 is measurably better at avoiding.

Multilingual performance

tAI is used heavily in Turkish, not just English, so multilingual quality isn't a secondary concern for us the way it can be for models tuned mostly against English benchmarks. tAI 4.2's training leaned further into the Turkish-weighted portion of the ArtficalAI corpus than 4.1 did, and it shows in fewer awkward, translated-sounding responses and better handling of Turkish idioms, code-switching, and informal register, on top of the reasoning and coding gains that carry over regardless of language.

"tAI 4.2 is the first version of the model where I stopped re-explaining myself halfway through a long session." (internal testing note, Artfical DT)

Built with tAI 4.2

One prompt, one file, no follow-up questions. Here's what tAI 4.2 built on the first try:

Safeguards

tAI 4.2 includes safeguards around misuse-prone areas like cybersecurity and hazardous-material topics. Queries that trip these safeguards are handled with extra caution rather than answered outright, and we keep tuning the thresholds down as false-positive rates improve, so normal, legitimate questions in adjacent areas aren't caught by mistake.

Every tAI model goes through internal red-teaming before release: prompt-injection resistance, tool-use safety (a model that can actually operate tools on your behalf needs tighter guardrails than one that only talks), and misuse patterns specific to Turkish-language use that English-only safety testing tends to miss entirely.

Training data

tAI 4.2 was trained end to end on data we collected and compiled ourselves. No third-party corpus was used as a base. Two datasets anchor the model:

• ArtficalAI: a multilingual, Turkish-weighted general text corpus covering reasoning, conversation, and general knowledge.
• Artfical Code Index V12.2: a compiled corpus of code and repository data built specifically for agentic coding and tool-use.

Both datasets are versioned and re-mixed between training runs rather than frozen after being built once, weighted toward the kinds of tasks our own usage data shows people actually run tAI on, and refreshed as that mix shifts.

Benchmarks

Scores from other providers are the official results those providers have published; tAI 4.2 and tAI 4.1 scores were measured by Artfical.

We'll keep sharing what we learn as more people put tAI 4.2 to work on real, long-running tasks. That feedback is what shapes the next version.