Microsoft VP Scott Hanselman has revealed a new open-source GitHub project called gputaskman. The name neatly encapsulates the headline role of this tool, a GPU-focused task manager, but its scope might be broader than you expect. This new tool for Windows, Linux, and macOS can show per-process GPU usage, VRAM consumption, active runtimes, and many more stats. It also breaks out AI/LLM task-specific information.

On social media, Hanselman snappily makes clear the technical itch that gputaskman was designed to scratch. “There's a lot going on in my GPU,” wrote the prominent public face of Microsoft's developer ecosystem. “I'm making a GPU Taskman to get insights to where my GPU memory is going.”

There are several example screenshots of GPU Taskman in use by the Microsoft VP. They clearly show the kinds of data that are presented in the terminal-like display that pops up in the tool. Hanselman’s tweet shows that the most VRAM-hungry app on his RTX 4080S system is the desktop windows manager. That is selected in the list, and more details are shown for this task at the bottom of the window. Also, we see AI/LLM apps consuming VRAM, and a few Windows staples.

In a GitHub-embedded image, we see what details are broken out when the llama-server.exe app is selected in the list. The bottom of the window breakdown reveals that Qwen3-0.6B is being used, and there’s a breakdown of its weights, the KV cache, the number of parameters, and more. Very informative.

As the Microsoft developer has made portable Windows downloads of the latest v0.3.0 release of gputaskman, I couldn’t resist giving it a spin. Upon launch, I found that no tasks were using the discrete GPU in my laptop… so I fired up ye olde Unigine Valley GPU benchmark to stir the RTX 4060 from its slumber. I note the live-streaming charts showing GPU load, VRAM use, temperature, and so on are more prominent in my screenshot than in Hanselman’s examples. Perhaps he screen-shotted a previous version of the tool.

There’s a lot more information about gputaskman, its inner workings, and even its source code, on the linked GitHub repository. Hanselman is sharing his “experimental software” tool under the permissive MIT license. Finally, in social media comments, he hints that expanded GPU monitoring capabilities could be coming to Windows as standard.

AI engineer Divyansh Agrawal has revealed the Qwenputer. Described in its most basic terms, Qwenputer is an experimental blend of the stock Qwen 3.5 4B AI LLM with a 32-bit RISC-V CPU compiled and inserted directly into its weights. In use, Qwenputer can run processor arithmetic operations – or even run C and MicroPython code on its built-in CPU, eschewing any external runtime or tool use. Moreover, it can run Doom, albeit very slowly. You can see the Qwenputer running Doom on its RISC-V CPU by expanding the tweet below.

The implementation of Qwenputer raises some interesting concepts and solutions. For example, the developer used Qwen’s Gated DeltaNet (GND) state as RAM, which Agrawal reckons is “a pretty neat trick.” They admit that using these ‘fast weights’ as RAM isn’t an original concept, but modifying Qwen 3.5 this way does seem to be a first.

Unlike traditional LLM creation, adding a ‘CPU’ doesn’t involve training. This RISC-V CPU implementation “is 11 transformer layers in front of Qwen's own, and none of their weights are learned: a compiler computes every one,” it is explained. Agrawal boasts that Qwenputer’s built-in CPU “passes the official riscv-tests, its programs match qemu, and it has run 18 million instructions free-running without a single error.”

The developer stresses that Qwen makes use of this ‘CPU’ to send instructions and read them back with no external tool or runtime calls. In practice, it works as intended. Use of the CPU inside Qwenputer provides exact calculations, overcoming the arithmetic weaknesses of many LLMs. Moreover, users can run code on the CPU inside the LLM, with C and MicroPython compatibility.

Not content with wedging a CPU into an LLM, Agrawal decided to also give it a filesystem. They describe this extension of the model as relatively trivial, since RAM is already in place. Indeed, the filesystem storage also uses the DeltaNet state. There are 1,024 slots holding up to 512 files. Moreover, this storage is persistent if you save the state at the end of a conversation with the LLM.

Due to its expanded resource use, Qwenputer has basically doubled the size of the underlying Qwen 3.5 4B LLM to almost 19GB. Thus, Agrawal recommends a workstation with 24GB of VRAM or more for testing Qwenputer in its current version. Efforts are being made to streamline coding in Qwenputer, as well as make it run faster.

The project is experimental. One gets the impression that Agrawal built Qwenputer primarily as an experiment to explore what is possible, rather than to solve a specific problem. Nevertheless, the creation of this custom LLM raises some interesting concepts and makes the mind wander regarding potential practical applications.

In addition to the above-linked blog, you can learn more about Qwenputer from its MIT-licensed code on GitHub. If you want to jump straight in and tinker with this fascinating project, you can now grab this LLM from Hugging Face.

Reverse-engineering games for converting them between systems is currently a hot topic, and it's getting messier by the day. According to multiple user claims, Anthropic's Claude Code and/or Opus 5.5 model are blocking attempts at innocuous reverse-engineering, including but not limited to those using the popular Reverse Engineer Anything (REA) tool. That issue may be linked to a text rule that's now in force, which allegedly instructs the model to avoid "[recreating] a specific existing game." The updated rule appears to be a move to limit a flood of AI-cracked and cloned titles, with some game devs even recently being hit by extortion scams that threaten to clone their game demos into complete games before they have a chance to finish and release the original.

According to Twitter user Chasm, the game-related textual rule is "Do build original games, games in a genre, and games from the user’s own designs and assets. Don’t build a recreation of a specific existing game, even if it is renamed or called original." There is no official or additional confirmation if this is the actual rule text, but it's plausible enough given the very clear refusals that devs have been encountering over the past week.

This situation is tricky to analyze due to the varying types of reports. First, the existence of a game-related rule is real, as Claude Code's GitHub is seeing an influx of issues complaining about refusals to do standard game work halfway through development, when replicating a game mechanic, and patching a tabletop-like game. It's possible that some of those reports have been made by users with nefarious purposes, but at least one is a bona fide developer with a real track record.

As for reverse engineering, there had already been a smattering of user reports across Reddit and other platforms, wherein Claude refused to perform tasks like (allegedly) analyzing a simple Windows crash dump, clearing up junkware on a Samsung TV, or just using REA altogether.

The simultaneous timing of both game- and cyber-security restrictions may be a coincidence, and yet there are complaints from purported game developers saying that Claude blocked their own games' anti-cheat development and security reviews, under the justification that its safeguards were triggered.

Anthropic introduced its Cyber Verification Program on October 6, essentially saying that access to its frontier models' advanced cybersecurity capabilities would be limited to entities covered by Project Glasswing, taking effect immediately.

It's possible that whichever ruleset was applied is the same one that's causing the cybersecurity-related refusals. Still, it's odd to see that 24 days have passed since then, and yet reports of bot refusal are only coming in since the last week or so.

As for possible motivations behind these restrictions, they are twofold. The first and most obvious one is that Anthropic — and, by extension, other AI players — are preemptively protecting themselves from potential lawsuits from software companies, including game studios, for offering the means to reverse-engineer their software.

There is no official statement on these matters from Anthropic or other AI companies so far. Anthropic isn't the only one playing this game, too, as recently OpenAI deactivated the account of another person trying to clean up their TV's software.

The recent rash of AI-powered clones of application suites like Adobe's suite and Microsoft Office 365, as well as the countless recomps and decomps of console games, likely has most every software company on earth rethinking their life choices. And probably also in frequent contact with their legal teams.

The online reaction was swift, suggesting that users looking to perform reverse-engineering work simply use Chinese, open-weight, or local LLMs instead of Claude or GPT. This, at the same time, highlights the irony of frontier AI companies that copied the world's information and art for their training sets and are now concerned with copyright infringement.

And yet there are situations that merit some discussion, like the recent controversy about the Steam Next Fest being chock-full of AI slop copied from existing titles. That particular situation is getting particularly nasty, as game developers are reportedly being extorted under threat that their game demos will be cloned into complete games before they have a chance to finish and release the original.

Adding insult to injury, this is seemingly being done to small studios whose main priority is usually "having food," rather than big publishers looking to microtransaction everything into a new yacht for shareholders.

As hardware for running local AI models continues to move to the forefront, such as Nvidia's RTX Spark, a new set of acronyms, definitions, and terminology is popping up. Given the pace of releases, we've put together a list of AI's new nomenclature to familiarize you with new concepts and pieces of terminology that you'll likely see in Tom's Hardware Premium articles.

This primer should get you started on the world of AI and be handy the next time news on the topic comes around, and possibly when you're downloading some models to try out and tweak for yourself. For the context of this article, we're going to stick with notions related to text LLMs, or in common parlance, chat, programming, and most agentic bots.

Model

This is probably the easiest one: a model is the LLM itself (a Large Language Model), computed from training sets of mostly text data on the scale of terabytes to petabytes. That training information comes from the internet, books, video and audio transcripts, and other sources.

The model is roughly analogous to a set of highly advanced layers of statistical analysis of relationships between tokens — words or parts of words, computer code, punctuation, and other symbols. The tokens themselves aren't part of the model, but they are packaged along with it. An AI model generates tokens in its outputs.

Weights

Those computing layers within an AI model would be useless without corresponding weights, which represent how strong the connection is between sections of tokens, sort of like how a pathway between neurons is more traveled than others. When the model runs, these values end up establishing how tokens end up relating to each other.

Example: the weights of the connections between "na" and each next part for "naval", "nachos", or "naruto" will all be different, and the higher the weight, the more often that word appears in training data. Importantly, weights cannot change without re-training the model, or parts of it.

When you see LLM specs online, you'll see something like "4B", "8B+", "20B", and so on and so forth. That shows how many parameters, or weights, the model uses, and it's generally measured in billions for consumer-grade models, and trillions for frontier models like GPT, Claude, and Kimi.

Note that a model having more weights than another doesn't automatically mean it's smarter. Just like with CPU clock speeds, it's not just about getting a higher number — bigger is usually better, yes, but you want those weights to be meaningful for the output.

You may also have heard about "open-weight" models versus "closed" models. Those refer to models like Llama, DeepSeek, and Kimi, which are effectively free-to-use, since the entities behind them freely publish the weights online. You can tweak the weights to your heart's content, if you wish, and come up with your own spin on things, as long as you have the hardware to run it. Note that downloading a free model doesn't reveal anything about how it was trained or how the weights were calculated — think downloading a free customizable application, not open-source software.

Data types and quantization

FP16, INT8, FP4, all sound like acronyms in some military handbook, but they're simple to interpret. All programs use numbers of varying width and precision, depending on their purpose: a simple money counter in your favorite game might be fine with a 32-bit integer that can represent 0 to 2^32 (INT32), while a value held in memory for a highly precise scientific measurement may need floating-point 64-bit arithmetic (FP64).

As memory is an exceedingly finite resource, good developers try to use the smallest units they can get away with, a notion that's particularly important in the VRAM-limited world of GPUs. Predictably, these chips became particularly adept at handling lower-precision values as a tradeoff between processing speed and numerical accuracy. A particular datatype isn't better or worse, as that assessment will depend on what it's used for.

When training an AI model, the labs will want to use as high a precision as they can for the weights, but keeping that in the final version would make for a prohibitively large and slow LLM. That's where the concept of quantization comes in, which is a fancy word for "clever rounding." As one of the steps after training, several passes are made to transform highly precise weights. Each AI lab has its own secret sauce about how to do this, as it's a critical step.

Frontier models predominantly use relatively high precision for their weights (BF16), in order to maintain response quality, nuance, and reasoning ability (an analogy would be deciding how accurate you want a GPS location to be — miles or inches). Open-weight models often have several versions with different quantization levels depending on what your hardware can bear — for example, Llama 3.3 70B can be run in full BF16 or quantized INT4 flavors.

The lower the precision, the more likely it can be run on consumer hardware. AI models listed on Hugging Face may have several quantization levels to fit certain levels of hardware, trading response accuracy for size. Consumer-grade models use smaller data types so they can fit on your Mac Studio, RTX Spark, or graphics card.

Context window

"Context window" is another term you've heard a lot and probably seen firsthand, likely in Claude Code's UI as a broad indicator of how long your session can go before the bot starts acting a little dumb. It's measured in tokens, with one million being a common number for frontier models, and it's almost directly analogous to RAM in a computer.

The context window is the LLM's thinking space, and it needs to contain everything associated with your session, not just the current question. Along with all your questions and its replies, it contains system-level prompts, all files you uploaded, the content of links it looked up, plus any associated data.

Crucially, while for you all these things are distinct concepts, for the LLM, they get reduced to tokens in one large pile: the context window. This is also why separating "data" from "code" is technically impossible — the best that modern models do is an approximation of that distinction.

LLMs don't think — when answering a new question, they re-run a statistics program over all the tokens and predict the next handful, so having a larger context window is beneficial (at the cost of VRAM), hence the one-million figure that's currently popular. But even statistical algorithms have their limits.

Even if you increase the window to, say, three million tokens, you may find that your LLM's prediction starts breaking down even though it hasn't run out. This is amusingly called the "lost in the middle" effect, where the bot will pay attention to the start and end of the conversation but will forget things down the middle. Thus, each model is finely tuned to the size of its context window.

KV Cache

If you've looked into using LLMs locally, or by way of running a remote GPU, you may have heard about the "KV cache" time and again, and that you need to reserve VRAM for it, or store it on a fast SSD if you absolutely must. This is a set of data that's created when the model runs, but that's actually reusable between queries in the same session.

The data that's saved and reused can be described as "the relations between tokens for this session." For example, the ever-popular sentence "you're right to push back" can be tokenized as "you-'re-ri-ght-to-pu-sh-back". The dashes between each token represent a vector (or array), called KV for key-value, that is used for determining which token gets picked next.

Since the text generation is linear, the math for calculating each new token needs every KV preceding it. Thus, if you're asking repeated questions in the same session, you'll want the KVs reused to avoid the expense of recalculating them over and over again not just with each round of conversation, but with each additional token.

Remember, an LLM doesn't simply answer the question you just posted — it always analyzes the entire conversation from the top to eventually generate tokens for your response. In a long conversation with 300,000 tokens, not having the cache would mean recalculating the KVs for all of them, a slow operation that gets disproportionately slower still as the interactions grow. This excellent blog post has a more detailed example.

Remember quantization? That's also applied here — modern models reduce the precision of the KV cache's content compared to their initial values, trading a minor accuracy loss for all new tokens in the session, in exchange for keeping VRAM usage down. In fact, with large context windows and conversations, the KV cache may well eat more space than the model and weights themselves.

Mixture-of-Experts (MoE)

Previously, AI firms touted how many more parameters their newest model had. Now, the race seems to have shifted to who can include more experts in any given model. That description may conjure a mental image of many tiny scientists living inside a knowledge laboratory, each handling a specific topic, but that's not quite how it works.

Mixture-of-experts, or MoE, is essentially a set of sub-models within the main model. When training starts, all sub-models get the same dataset, but the choice of weights is randomized ever so slightly for each one. Each sub-model will value tokens a bit differently from the rest, and due to how the training process reinforces patterns (called the "rich-get-richer" effect), related tokens will tend to converge together, so you end up with "experts" on sets of tokens.

A common misconception is to think that these experts are related to topics (like programming), but they're only establishing relations between tokens, meaning they'll be more accurate for certain words and text patterns, but devoid of any concept of what they're about. The fact that an expert might offer pretty good responses in regard to landscape painting is a happy accident, not a feature.

You may be thinking that this makes the models larger, and that maybe just the one generalist expert may prove a wiser choice. That's correct, but the trick is that the models only activate certain experts, meaning that only a portion of the model is actually running, thus at higher speed than a generic LLM.

This model selection happens on a per-token basis, too, as a router re-selects experts for each incoming token. For visualizing this, think of brain scan patterns where different areas light up depending on words heard. In practical terms, it means the model can answer more accurately in certain sections, while answering the question faster — albeit at the cost of higher VRAM usage.

Retrieval-Augmented Generation (RAG)

RAG is a concept that's pretty easy to describe, and yet one of the most powerful ones when used with any given model. In short, it can be described as: your chat application runs a few Google searches, feeds them to the model, and voila, there's now much more and fresher information to answer your question. This additional information can come in most any form: company documents, reports, emails, or spreadsheets — anything that you might supply to the model yourself, directly tokenized into its context window.

While broadly speaking most contemporary LLM chat applications run searches, activating RAG, usually triggered by selecting a "web search" switch or sometimes enabling "thinking" or "high effort" mode, will explicitly instruct the application to find as much data as it believes necessary to answer a query. Given that pure context is often key to answering many questions, and do so in an informational manner, RAG is among the most powerful tools available.

Fun fact: the search queries the application will search for are usually generated by a smaller, separate model that will, for example, say what web searches are bound to give the best results, or what to look for in a linked Office 365 account.

The main drawback is that it can be extremely computing-intensive, as the text for your questions and responses may consume, say, 10,000 tokens, yet the information in the retrieved webpages can take hundreds of thousands of tokens all on their own. For example, the Perplexity service was built with an emphasis on RAG usage, and judging from personal experience and user reports, it's usually much more competent and context-aware when answering questions, even though it's underpinned by the same models as everyone else.

Inference, Prefill and Decode

Inference is the act of using a trained model to generate outputs or tokens. It happens every time you send a prompt, and it's where all of the elements that we've discussed above come into play. Inference can be split into two primary parts: Prefill and Decode.

Prefill is the first phase of inference. Essentially, all of the input history (or your prompt) is tokenized and then processed by an AI model. This can include documents, code, and more. These inputs also dictate what gets put into your KV cache. Prefill is processed all at once in parallel, which often means that prefill times are often faster than overall outputs.

Prefill is a large part of the overall workload when measuring how long it takes for a specific chip or piece of hardware can take to output its first token, also known as "time to first token" (TTFT), a common AI benchmark, usually reported alongside prefill tokens per second. Longer prompts take longer to prefill, and context, KV cache, and everything else we've discussed are taken into account.

Decode is the second phase of inference. After a prefill has processed your input and has built the KV cache, the AI model then generates its response one token at a time, which must be done sequentially in order to determine the ones that come after, which means that the step cannot be performed in parallel, unlike prefill. Decode is usually also dictated by context, and reads from a model's KV cache during this step. Decode is usually limited by memory bandwidth, instead of raw compute, as streaming single tokens from weights and reading the KV cache is a bandwidth-intensive task, meaning memory speeds matter more. You'll usually see Decode speeds referred to as tokens-per-second (TPS).

Speculative Decode is a technique that makes those single tokens in the decode step stream faster, without changing the overall output. A drafting mechanism guesses several upcoming tokens, and then the model attempts to verify them in a parallel pass (almost like an additional prefill step). The model then verifies the pass itself; if the guesses are good, then the model's outputs are indeed correct, you get tokens for less of a computational cost during a given decode pass, and when they're bad, they are rejected by the main model during verification, since the main model's output is always what's kept.

Multi-token prediction (MTP) attempts to predict the next set of tokens at once, rather than only serving the next token. This is often built into AI models when they are trained with multiple steps. This can serve as the built-in drafting mechanism required for speculative decode.

This is a non-exhaustive list of concepts critical to understanding how AI models and LLMs work, but it is by no means complete. We will continue to update and refine this article as we add more.

After a few revisions of his position on AI-assisted contributions to the Linux kernel, Linus Torvalds has posted his own first LLM-assisted patch. The development branch purports to fix an old issue with massive cache contention when many CPUs are reading the same file — a scenario potentially encountered when using shared libraries, databases, and web servers. Several developers had already made attempts over the years at fixing the issue, all with varied results, none quite ideal as an all-encompassing solution.

Torvalds posted his own draft for solving the problem in early 2024, and has used it on his own laptop since that time. However, he recently took the plunge and decided to "try to actually solve this thing using an LLM." He's now posted his solution in a development branch, and claims that he's seen a 23x performance improvement in a dedicated synthetic benchmark, though he notes that actual real-world impact will be far less significant, as "no real load" will witness those figures. If we had to guess, this improvement would benefit server workloads far more than desktop machines.

Over time, Torvalds has broadly taken a pro-AI stance on LLM tooling, at least within the purview of the tightly controlled, review-heavy environment of the Linux kernel code. Last July, he stated he's "willing to absolutely put [his] foot down" on AI haters, pointing out that an automated code review tool the kernel team uses outperforms humans, and that it caught basic programming mistakes that shouldn't have been submitted in the first place.

The team is even changing its policy to no longer require that patch authors disclose they used an AI tool when generating their code. Torvalds once again took an assertive stance, reiterating that users should treat LLMs as yet another tool, likening it to compilers or editors. In his view, he simply expects that "people do their best and [...] understand what they are doing."

Some might say that few people in the world are better-suited to properly employ an LLM than Torvalds, and by extension, kernel maintainers. There's an entire universe of difference between a senior master programmer using the LLM to speed up the boring parts of his work, and some newbie with a credit card going "claude make linux faster plz no mistakes."

However, It's not all roses. Thanks to how adept AI agents have become at recognizing common security flaw patterns, the Linux security mailing list became "unmanageable" earlier in the year. Linux has been fixing CVEs at an astonishingly rapid pace of around 2,000 per release. Still, the team's hand is being forced into dropping older hardware drivers, as they're often the target of numerous security reports, despite their negligible install base.

The list of things a jailbroken PS5 can do gets longer, as Reddit user u/AdIllustrious7246 posted his fork of PS5LM, a llama.cpp port on the PS5 to run AI LLMs locally, with a massive improvement, allowing PS5LM to run natively on the PS5 and utilize the GPU to run bigger AI models such as Qwen3.8-27B at 20 tokens per second.

GitHub user cobanov posted their unofficial port of llama.cpp on Reddit 14 days ago to enable jailbroken PS5s to run AI chat models locally and offline. cobanov’s version, according to u/AdIllustrious7246, runs as a payload on the CPU, limiting it to 6 GiB of memory. Running it as a payload is basically hijacking the CPU, inserting the LLM into its instructions alongside the home screen and system services; however, RAM access is limited to about 6.25 GiB because holding more would freeze the home screen. cobanov did this just to get the llama.cpp running as soon as possible, but eventually wanted to utilize the GPU so it could run larger models; however, it seems that u/AdIllustrious7246 beat him to it with his fork.

u/AdIllustrious7246 utilized PS5_Vulkan, a port of the RADV graphics driver that allows instructions to be sent to the PS5 GPU. Normally, the PS5 GPU would be locked down and cannot be accessed like a PC GPU, despite being an AMD GPU. PS5_Vulkan is one of the projects that made plenty of homebrew projects possible by opening up what could be done on the GPU, including making it run LLMs.

Now that llama.cpp runs natively on the PS5, fully utilizing the GPU and opening up more RAM to be used, u/AdIllustrious7246 was able to run a 27B parameter model on it at 20 tokens per second, and smaller models like Gemma 4 E4B and Llama 3.2 3B at 61 and 124 tokens per second, respectively. Previously, the large 6.8 GiB LLM would make the system freeze and crash due to the CPU bottleneck, but GPUs are much better at processing LLMs, which is why GPU and RAM prices are insane these days.

Running it on the GPU allowed for much faster token output, and running natively allowed it to use more RAM, up to 11.4 GiB, according to u/AdIllustrious7246. Not only did the developer run the app natively, but they also gave it a dashboard, showing useful data such as live token-per-second generation, GPU and CPU use, power draw, temperatures, and how the memory splits between the model and KV cache. They also made it work with llama.cpp’s web UI, allowing users to chat with the LLM from other local devices using a browser.

While this is an impressive feat, allowing the PS5 to run as an AI assistant when it’s not used for gaming, commenters are getting flashbacks to the crypto mining GPU crisis. This is unlikely, however, as we already have an ongoing GPU and RAM crisis thanks to the demands of large AI data centers, and the PS5 doesn’t exactly have the fastest GPU or the most RAM.

Following the release of TypeSafe's Jev, many AI players have launched competitors, and many similar open-source projects from the likes of Microsoft, OpenAI, and many more have since emerged. Yet Nandakishor Mukkunnoth, of ConvAI Innovations, said that he'd come up with the base notions for Jev's architecture over a year before. So who copied who?

As a quick recap, Jev and its clones are APIs driven by decision models, for use in your own code. You feed them input data like a customer's online shopping transactions, alongside questions. For example: "is the user looking for a return?" for a yes/no answer, and "Which item are they referring to?" with a multiple-choice answer. A Jev-like AI model will answer each of the questions or choices with a probability that can then be used in your own "if" statements. While the concept by itself isn't strictly new, this practical application is indeed novel.

The release made a good portion of the internet abuzz, as the seemingly simple concept is extremely useful and neatly sidesteps the usual problems with trying to coax an LLM into giving a direct answer. There's no token-by-token text generation, no conversations, no re-feeding of conversation history, no feeding it gobs of information for context, and no conversational hallucination — just direct data in the form of probabilities. It's really fast too, answering questions in parallel, and exceedingly cheap compared to standard LLMs.

Along with Jev, TypeSafe also released a brief description of its System One architecture. Only days later, Nandakishor Mukkunnoth, founder of ConvAI Innovations, explained in a blog post that he'd actually "designed the Jev architecture one year back." He referred to his arXiv paper on SalesRLAgent, describing how he created a model for probability estimation, published on March 30, 2025. Along with the paper, he published his model weights and dataset. He later followed up with a September paper that more closely aligns with how Jev operates.

In his write-up, Mukkunnoth expressed his frustration, describing how he got overlooked "because [his idea] was built for a vertical use case," meaning SalesRLAgent was made to fix one specific problem, while TypeSafe made Jev a general-purpose decision engine. Notably, the company released Jev as a complete, hosted product, with its own servers, API, documentation, developer kits, and naturally, pricing.

Nevertheless, he said he opted to not remain bitter about the development, and ultimately released the open-source Laya roughly the same day. Laya is essentially a Jev-style model and interface that you can run on your own hardware, complete with multi-language support. Likely adding to the confusion, both TypeSafe and Mukkunnoth called their models "System 1/One" types, likely as a reference to Daniel Kahneman's book, Thinking, Fast and Slow, which describes System 1 as a faster, emotional mode of thought, whereas System 2 refers to slower, more logical thought.

Regardless, there was no stopping the hype generated by this new use case for AI, so players in this space did what they do best: copied the concept and rolled out their own services. In the space of only a few weeks after Jev was released, the world saw Microsoft Decision, OpenAI Decisions API, and Fastino Glide. Both Cloudflare Clef and Perplexity Decider arrived with open weights, meaning you can run them on your own gear, assuming it's up to the task. Over on the open-source aisle, there's Amazon's Strands Decider 2B, Kev, Von, Jeff, jevlike, SemIf, OpenJev, NanoJev, Ollaya, and many others.

Why so many? Well, because most of these projects, including the commercial ones, share the same root: taking an existing lightweight model, usually always a variant of Alibaba's open-source Qwen, and adding the extra layers that shape the input, output, and decision-making procedure. Mukkunnoth's Laya is based on encoder-only models from the Bert family, rather than an LLM like Qwen. And yet it's not too hard to imagine that many folks might have cribbed at least some notes from his work, given how quickly the alternatives materialized.

A Reddit post by user markpronkin (“OP”), titled “54gb vram for 35$,” says the user purchased an old crypto mining rig, originally discovered in a garage, for a negotiated 3,000 rubles, or about $35. The rig was rusty, and the buyer “had zero idea if it works, so did the seller,” with a pre-purchase test request refused. However, on the first try, all nine Nvidia P106-100 GPUs, with 54GB of VRAM between them, worked. The initial test: a successful local run with the 35-billion-parameter model Qwen3.6-35B-A3B in Ollama, which operated at over 30 tokens per second.

The rig was discovered in a “damp garage” the seller had purchased years earlier, then listed on Avito, a Russian classifieds site. The OP had concerns about whether or not the rig would work and offered to test it and pay more if it functioned, but the seller refused, and the price was negotiated down without a test. The cost was low enough to take the risk, the buyer said. Even in the case the rig worked, performance was imbalanced, as the main system has a weak Celeron CPU with very little system memory.

The setup was originally intended for crypto mining with specialized Nvidia P106-100 GPUs, Pascal-generation cards with 6GB of GDDR5 each that OP calls “basically gtx 1060 6gb.” Gigabyte’s P106-100, for reference, has 8,008 MHz memory with a 192-bit bus width for about 192 GB/s per card. The hardware was originally introduced around the middle of 2017. The cards are no longer entirely supported as CUDA 13.0 removed offline compilation for GPUs below compute capability 7.5, which includes Pascal GPUs, and driver branch 580 is “the final [one] that supports GPUs before CC 7.5,” Nvidia says on its developer blog. Security updates are supported through October 2028, however.

The first test was a mixture-of-experts model using Alibaba’s Qwen with “35B [parameters] in total and 3B activated,” per Qwen’s model card on Hugging Face; it’s roughly a 24GB download. The initial test had it at “30+ tokens a second” in Ollama but it can probably operate faster “with mtp and some optimizations,” OP says, referring to multi-token prediction.

Another user stated that such performance was possible on a CPU alone, to which OP replied, “On a 35$ device without any optimizations?” A dense, non-MoE model such as Qwen3.8-27B is unlikely to run as well, but “It should run any MoE model that fits entirely into VRAM decently well.” Performance is also expected to be limited by the PCIe 2.0 x1 motherboard slots.

The system is capable but would have some limitations due to the sizes of some popular models. Qwen3.6-35B-A3B at 8-bit should fit at 36.9GB, as should Llama 3.3 70B at 4-bit, at 42.5GB; at 5-bit, just below 50GB, it would leave little room for context. Larger models are probably not workable, and even the 70B 4-bit Llama would hit a ceiling around 4.5 tokens per second before hitting other bottlenecks, since each token reads all 42.5GB, card by card, at about 192 GB/s. The performance the buyer achieved is in spite of the rig, and the MoE model was the best choice for that type of result.

The buyer still got a good deal, as the price comes out to about 65 cents per GB of VRAM. For comparison, an RTX 5090 with 32GB of VRAM and 1,792 GB/s of memory bandwidth launched at $1,999 in early 2025. The rig has 1.7 times the VRAM for less than 2% of that price, but each of its cards has about a ninth of the bandwidth. According to OP, the mostly compute-only P106 cards sell for about 50% of their GTX counterparts.

One important caveat here is electricity costs, with the GPUs having a combined 1,080W TDP as estimated by one commenter, but OP says their power is free and generally inexpensive in Russia as a whole.

With the rig securely in hand, the OP’s next move is to transfer the hardware to a better case that supports up to an i7-7700K CPU and 32GB of RAM. The new case allows for 12 GPUs, so buying three more of the same adds up to 72GB of VRAM total. The solution is attractive because of “unlimited usage and actual privacy,” the buyer said to WiredEntrepreneur. Repurposing used hardware for a self-hosted AI solution with appropriately sized MoE models is a viable, useful project for enthusiasts who want freedom. From the OP’s perspective, more VRAM means more freedom.

An AI engineer used GPT-6 Astra to reveal the contents of a cipher that hadn’t been read since the Napoleonic Wars. Carter Church, an engineer at cybersecurity company SentinelOne, used Astra to crack the message hidden in 217-year-old code which had sat unsolved among Cryptiana's Unsolved Historical Ciphers list for decades. OpenAI’s LLM unpicked it within six hours, says Church, and it did so after only being fed a single image and prompt. You can download the “full solution package, with a script that regenerates the reading,” directly from Carter Church’s blog (download link in the first paragraph).

The message that was deciphered wasn’t directly from Napoleon. It actually came from the headquarters of Eugène de Beauharnais, Viceroy of Italy (Napoleon’s stepson), but isn’t signed by any particular individual. In can be summed up as a troop briefing, sent to French General Auguste de Marmont, relaying Napoleon's orders. Marmont would have deciphered it using some official military codebook from the era, but since that date in 1809, it is unlikely anyone has read the message again.

Interestingly, Church observes that this freshly deciphered text fills in some missing context from Napoleon’s 1865 memoir. That tome includes part of Napoleon’s order relating to preparation for the Austrian invasion, but breaks off mid-sentence, saying Marmont mustn't be held back by "a handful of ..." This page from Cryptiana's Unsolved Historical Ciphers completes this sentence with “a gathering of rabble.”

As per Church’s commentary on the encoded letter to Marshal Marmont, the page begins with a plain text introductory line (in French of course), This is followed by 24 rows of numbers, letters and invented symbols. Astra made short work of this 19^th century military secret, and in approximately six hours, all was revealed. One of the clues it used to solve the cipher was a partial key previously unconnected with this letter. Eventually its multi-modal processing “cracked the rest with its own simulated-annealing solver,” says Church.

If you are in any doubt about the veracity of Astra’s work, this freshly deciphered letter from Cryptiana's Unsolved Historical Ciphers has now been marked as solved by Satoshi Tomokiyo, who maintains that online database. Moreover, Carter explains the solution is “mechanically testable against the ciphertext,” and you can check that using the published solution package, linked in the intro.

AI models can now design LEGO builds with thousands of real pieces, creating programs that output detailed CAD files, with the assistance of open-source LDraw Nova. It can leverage general models like GPT-6 Astra and Claude Opus 5.5 to design elaborate builds from a prompt, such as the 2,175-piece Sakura Garden. The models use Python tools to write programs, which output the builds without placing every brick. None of the designs have been built with real bricks yet, though; developer Carlos Antelo says he “didn’t even try.”

“Give an AI agent a model idea. Guide it, let it build it,” according to the GitHub project’s README. The Sakura result arose from a prompt to Claude Opus 5.5 asking for “the most beautiful model that comes to your mind.” Antelo posted the project on Friday afternoon as the first release after getting the toolkit to work after three earlier attempts.

LDraw, according to Antelo, is a text format where each LEGO piece placed is positioned with one line. LDView, LeoCAD, and Studio can open it, one file per model. An agent writes a plan in JSON that fully describes the model and submodels, creates a Python program from it, then generates the LDraw source output. When the model is rendered as an image, the agent can inspect, adjust, and render again, looping until the model is considered complete. In this way, it avoids “(evil!) geometry math,” as agents are “better at generating Python code.”

LDraw Nova runs as a Docker web app that works with AI providers including OpenAI, Anthropic, and OpenRouter. The web app’s gallery credits each build to the model that made it, with its prompt: Sakura Garden and an unfinished Atlas Crane to Opus 5.5, a Cathedral and the Tidal Observatory to Astra, and the Copper Bean apartments to Opus 5 “(not 5.5!).” The project itself was built with the assistance of OpenAI’s Astra and Anthropic’s Claude Opus 5.5.

Building the larger models for real would mean collecting thousands of parts, a task Antelo figures would be difficult. The project has limitations, too, as “physics modeling is something Nova is currently lacking,” which means collisions are handled, but stability is not. It isn’t free to run, either: his “wild” estimate for Astra building one Technic mechanism is around $5 in token costs.

Likewise, his experience thus far is that only frontier models can currently generate large and accurate builds, and the process remains time-consuming. VR support for the Meta Quest 3 headset exists but has “many issues, performance issues.” The project as a whole differs from Carnegie Mellon University’s LegoGPT, now BrickGPT on GitHub, which was trained on more than 47,000 LEGO structures and, in contrast, checks its designs for validity and physical stability as it generates them.

The tool can use more than one type of model: jev-rerank, a “semantic search tool with re-ranking backed by TypeSafe’s Jev System One AI model,” was used for Astra’s Cathedral build. The Jev decision model reranks the part searches, but it’s optional. If no TypeSafe API key is provided, the agents fall back to full-text search. This model was successfully used recently in multiple automated Pokémon Red playthroughs.

While Antelo recommends higher-end AI models for the project, one of his goals is “tooling that can be used by low-end agents to iteratively build.” Minifigures and Technic machines and engines are also on the project’s to-do list. Using AI agents to do tasks through programming is not new but is becoming more sophisticated, as seen in a run posted Friday in which Astra cleared World of Warcraft’s orc starting area from one prompt.

Antelo built the project to get AI agents “capable of designing buildable, physical things.” For now, the bricks only exist in CAD, but he’s considering 3D-printing a small model.

AI agents can work with 3D printing, too, through Model Context Protocol servers: Kiln can upload a file to a printer and start the print, while OctoEverywhere’s server lets an agent check on a print and pause, cancel, or resume it. This could bridge the gap between an AI model making lines of code and the production of something tangible. In time, physical AI through robots could even do the building part, but where’s the fun in that? In the meantime, you can try to design the LEGO set that’s always lived in your head.

Futurum Group CEO Daniel Newman wrote in an X post that “AI is currently used by AI 5x more than it is used by humans. That number will accelerate to 10x and then higher and higher.” His data, an Andreessen Horowitz (a16z) chart of OpenRouter figures, shows agents at 7.3 trillion tokens versus humans’ 1.4 trillion as of August, six months after agent usage first surpassed humans. But the agents are mostly rereading what they’ve already seen: more than 85% of agent tokens come from cached prompts, a16z wrote, citing OpenRouter.

OpenRouter is “a leading AI model gateway and routing platform.” A chart from its head of insights, Peter Walker, lists “7-day average token usage on OpenRouter split by type.” It states that, since the February crossover point, agents are using 14x more tokens while human usage is up 2.8x. The a16z chart in Newman’s post shows the same data. OpenRouter sorts each API key into one of three categories: agentic, mixed, or human, using a “7-signal weighted composite score that includes inputs such as tool call rate, turn count, gap timing, and others.”

The mixed category, possibly covering behavior that is part agent and part human, grew 4.7x over the same period, according to our math. Depending on how that traffic splits, the agents’ lead over humans may vary. The data also measures token volume, not spending. This is data from only one platform, and the trend isn’t completely consistent, with dips in April and July. However, agent use is growing elsewhere. In McKinsey’s 2026 State of AI survey, 40% of respondents from large organizations reported scaling AI agents, up from 27% a year earlier.

Cached tokens also account for nearly all of the relative growth in token usage, a16z wrote. They cost far less than processing a prompt from scratch, but they still have to be held in memory, and a16z, an OpenRouter investor, ties that to rising demand for high-bandwidth memory (HBM). Models keep that stored context in what’s called the KV cache, and “the KV cache is outgrowing GPU HBM capacity,” according to our reporting.

The same pattern shows up in the logs of a call center consultancy that tested DeepSeek on rented Nvidia H200s. In its own agents’ September usage on Claude Code, “96% of all input was re-reading old conversation.” Coupled with OpenRouter’s data, this suggests the token count overstates the bill, but the hardware cost for memory remains very real.

That memory is already scarce. Micron expects RAM and storage shortages to worsen in 2027 and 2028, with customers paying more than this year, while memory makers put HBM for AI data centers first. If Newman’s prediction that the 5x will become “10X, 20X, 30X” is true, PC buyers will be bidding for memory against even more agents.

OpenAI's GPT-6 Astra AI model was able to clear the Orc starting area in World of Warcraft (WoW) in 40 minutes with 0 deaths, agent-wow's developer says. The model played the zone without seeing a single rendered frame, relying on network traffic and quest data pulled from the server's own files. The approach used a single prompt in Codex with agent-wow, an open-source client, to play on a private server. The corresponding YouTube video says that the agent “starts as a level 1 Orc, completes every quest in the Valley of Trials, and finishes the run in Sen’jin Village.”

Agent-wow is an “AzerothCore WoW client designed for autonomous AI agent players,” according to the GitHub repo description. The client does not “define any gameplay mechanics such as movement, combat, or in-game interactions” and instead only exposes a “module system for agents to build” whatever they need to play. AzerothCore is open-source server software that runs WoW 3.3.5a, “the final build of Wrath of the Lich King,” and agent-wow talks to it over the game’s network protocol. The client does not connect to any live WoW server and instead can be run on local private servers for experimentation.

The developer ran OpenAI’s flagship model, released early last month, with extra high reasoning effort, one below the highest or maximum. The developer chose WoW for its mix of long-term strategy and short-term tactics, with an end goal of filling “an entire server with AI agents [to] see if they can clear Icecrown Citadel on heroic difficulty.”

The agent built a single module to grab 28 types of server messages, by our count, which are kept in memory. A Python script polls those messages to build the agent’s picture of the world and sends messages back to act in it. The developer expected a higher-level implementation, but “In practice, it was more than capable of working at the protocol layer.”

For quest data, the agent turned to data mining, pulling quest givers, turn-ins, and spawn points from AzerothCore’s SQL files. The developer says this is “arguably similar to how a human might spend hours on Wowhead to research quests,” referring to a popular WoW info site. Going straight to the server’s own files arguably beats that, since they’re the data the server itself runs on, while a fan site’s data may not always match. The project’s public workspace instructions also list AzerothCore’s source code as a resource for agents, though the developer doesn’t say whether this run used them.

Some planning was used in the agent’s approach. According to the developer, it worked through prerequisite quest chains in order, sold junk, equipped upgrades, and trained abilities before the zone’s final cave, and picked up both cave quests at once to complete them together.

For pathfinding, the agent built a C++ helper that plots a route between a starting point and a destination with AzerothCore’s own navigation mesh files, or mmaps. The Detour pathfinding library finds the route, and the helper returns its waypoints as coordinates, or an error if there’s no complete path. The developer acknowledges that “from my research into heuristics-based bots, pathfinding is always one of the main challenges,” but calls the agent’s pathfinding abilities “optimal.” In fact, the agent was able to “exploit map bugs” at locations where collision properties may have been lacking.

This is not the first game the model has tackled. Early last month, shortly after its release, it played the game Portal with screenshots and knowledge of the player’s position. This WoW run used no screenshots at all and only covered the first zone, while the Portal run went through the entire game over about 24 hours.

Recently, developers have deployed various techniques to play Pokémon Red, such as using a custom small model and a Jev decision model harness with Claude coaching. Next up for the developer: discovering whether a single agent can reach level 80 completely on its own, and whether multiple agents can team up to complete content through the game’s social features.

PewDiePie, the popular YouTuber, has unveiled Ajax, his “uncensored AI model” built to run at home, and says in a new video that OpenAI banned him twice while he was making it. According to the OpenAI email he shows, one ban was explicitly for “distillation,” the practice of using one model’s outputs or reasoning to train another. Ajax is built for Odysseus, his self-hosted AI workspace, as an autonomous, always-on agent and assistant.

The setup is similar to OpenClaw and Nous Research’s Hermes Agent. Ajax, a fine-tuned Qwen3.5-9B model, powers the workspace to handle “daily tasks from search to browse the web to email to your calendar,” all “completely privately,” according to its Ajax page. The page says its refusal has been removed for a “freer, less restricted AI experience” and asks users to use it responsibly. The video announced the first version, using Alibaba’s model, as a follow-up to his workspace launch in May.

Addressing the bans, the creator stated he wanted to “distill just a little bit” in order to improve his model. Frontier AI model companies such as OpenAI and Anthropic make sure to hide their reasoning in numerous ways, including encryption and attempted distillation; such a campaign OpenAI recently attributed to actors linked to Moonshot AI is seen as a threat.

PewDiePie got his account reinstated once, although on the second ban, which came after he ran the model again “to create my seed data,” he asked, “How did they even know?” The email offers no specific examples. “They worked hard stealing all of our data to make their AI machines,” he added, suggesting that he feels some distillation may be no different from how the models are trained.

To "uncensor" his model, he relied on automatic abliteration through the open-source Heretic, where you discover prompts the model refuses to trace and remove the refusal, preferably without doing “brain damage” by removing too much. He chose to draw the line at harming other people or oneself. On his lawyer’s advice, he said it is “not designed to provide dangerous actionable instructions.” He uses nuclear weapons as an example, but it’s unclear what the real limits might be.

The creator “strongly believe[s]” in small models trained “for a specific harness,” and suggested them as an alternative to the “one trillion parameter” models, referring to rumored frontier sizes. “I think it makes no sense to poke that giant beast” just for basic tasks, he said. His interest remains in research and providing a usable model, which also means smaller. He followed up with a plea for fans to donate training data as a superior alternative to collecting it directly from Odysseus users, though he says no one submitted any.

He said he planned two more days of reinforcement learning before rerunning the decensoring step, quantizing, and benchmarking. “I can’t wait to release the next version of Ajax and Odysseus,” he added, noting that Odysseus has “gotten a huge update as well.” The naming convention makes sense, as Ajax was Odysseus’ rival in the classic myth, although he jokingly states it’s named after the cleaning product. The capabilities of open models and harnesses point the way forward for users to use uncensored, less restricted intelligence on their own hardware, an important goal in keeping the technology free.

The Call Center Doctors, a call center consultancy that builds and runs call floors for other businesses, rented a server with four Nvidia H200 AI GPUs to serve DeepSeek V4.1 Flash to its Claude Code agents in place of Opus 5.5, according to its test write-up. The write-up is aimed at anyone who has heard that DeepSeek is “80x cheaper” than Claude. Using its real coding mix, the firm's server topped out at around 213 tokens written per second at an on-demand cost of $440.88 per day, versus $184–$223 per day for the same work via DeepSeek’s API. The call center went back to Opus 5.5 at a lower price than the box would cost at on-demand rates.

DeepSeek’s API is priced at $0.15 per 1 million new input tokens off-peak, $0.003 cached input tokens, and $0.60 per 1 million output tokens. Peak costs are double. By comparison, Anthropic’s Claude Opus 5.5 is listed at $4 input and $20 output per 1 million tokens, with cache reads at $0.20. The consultancy used it through subscriptions and not the API.

The box’s performance was fine for one kind of work at a time in the test’s one-minute full-load runs. But the coding agents work mostly by resending the conversation, and 96% of what the agents provided the model was stale text, according to the consultancy’s logs. It takes about 1,000 old tokens for every new token written; the re-reads are cheap, but so numerous that the box was kept busy re-reading, leaving little of its time for writing new tokens.

Getting the model to run stably took five tries at 10 to 15 minutes of loading for each try. The box bills whether it’s busy or not, which is suboptimal. By our arithmetic, a standard-length month at the on-demand rate, $18.37 an hour, comes out to about $13,200. This is over twice the consultancy’s September Claude bill. Additionally, one box can only get through about 20 billion tokens a day, by the consultancy’s math, most of it re-reading, against the 51 billion the consultancy’s agents used on its busiest day.

The testing was aimed at anyone who has heard that DeepSeek is “80x cheaper” than Claude. One server running from Sept. 1–27 had 2.03 million model calls, 388.5 billion tokens read, 374.2 billion of them cached, and 393 million written, with 5,610 merged changes. The consultancy’s September Claude Code subscriptions came to about $5,500. The same 27 days of tokens on DeepSeek’s API would be between $3,500 and $7,000, depending on peak pricing, with our estimated average around $4,200 if usage is spread evenly across the week.

Set against Claude Opus 5.5’s list prices, the same tokens would come to about $140,000 by our math, over 25 times the cost of the subscription. That flat-rate discount is where the 80x went. The consultancy also priced each merged code change: about $1 on Claude, and about $0.63 on DeepSeek’s API if DeepSeek did the same work with the same tokens. Its $1.15–$4.90 estimate for DeepSeek is based on assumptions that the model would need more tokens, succeed less often, and need Claude to check its work.

DeepSeek never got to write actual code in the test. The consultancy’s reviewers kept finding ways agent code could escape the sandbox, for example via a settings file in a shared temp folder that could allow agent code to be run as admin. This meant the code-writing agents had to stay offline. Instead, DeepSeek ran only as 48 to 64 read-only reviewer agents, reading 2,377 folders and filing 32 bug reports. The box, rented at a $9.19-an-hour spot rate, was taken back by the provider within minutes of the last test ending.

Based on the V4 generation, where Pro outscored Flash, better performance from the model family can be expected with DeepSeek V4.1-Pro, which currently does not have a firm release date. This may change the math in the future, but for now there are better ways to spend on tokens than renting GPUs to run an open model.

Now and then, something novel appears in the AI world, amid near-constant releases of brand-new models. Last week saw the debut of TypeSafe AI's Jev, its first "System One" model. Rather than chatting with users like conventional LLMs, it's strictly designed for statement evaluation and decision-making, for programming purposes.

Jev is the brainchild of ex-OpenAI engineer Diogo Almeida, who co-wrote ChatGPT's core training techniques. According to TypeSafe's math, Jev should be both faster and more efficient than frontier AI models like GPT-6 Astra, by several orders of magnitude and purportedly up to 194x faster and 445x cheaper. Consequently, the company pins Jev's intelligence-per-dollar as "off the charts," though only practical use will tell.

TypeSafe says the main reasons for this are twofold. First, System One models are trained with its Reinforcement Learning for Calibrated Decisions (RLCD) and geared towards producing structured answers rather than producing prose. Then, presumably because there's no previous context required, individual questions in the same request can be processed in parallel, in opposition to LLMs' continual generation of text.

When you query a normal LLM, you get an open-ended text conversation; Jev simply produces answers to specific questions, all answered with a confidence factor. It's made for code, and thus machines, to use. Your code interacts with Jev's API by providing a state — a given situation and its associated data — and asks Jev to assess specific statements. The state is supplied on each individual request, and there's no global knowledge database or retained memory.

For example, a company could show Jev a list of a customer's credit card transactions, some basic customer account info, the last thing the customer wrote, and pose the question "Is the customer requesting a refund?" The answer will be yes or no, with a confidence rating. If the confidence is above, say 85%, you can proceed to ask the customer which method they prefer, with a multiple-choice of "refund", "store credit," or "unclear." Jev then offers a probability distribution for each of the refund options. Your code can then try to process the refund or ask for further clarification.

Jev's output (and optionally input) is in a predefined data format that's essentially plain JSON. Unlike interacting with LLMs, there are no extraneous words, long-winded thinking, or necessity to ask the model for brevity. Likewise, there's no need for global contextual prompts or saved memories, often necessary to try and coax LLMs to behave as if they were minimally deterministic. Beyond providing the state and questions, operations like input parsing, date handling, or database reading remain in your own code and are of no concern to Jev.

At first sight, this might look like a more straightforward interface to an LLM, but it's fundamentally different. Jev does not need or even want the entire context leading up to the question — providing extraneous information actually lowers the accuracy, and the context window is capped at a meager 64,000 tokens. Since the bot always produces a confidence percentage, it doesn't hallucinate in the familiar chatbot sense of creating statements and data out of nowhere.

The developer, rather than Jev, is responsible for making decisions based on the answers' confidence factors. Jev can still misclassify information, fall victim to adversarial attacks, or answer literal wording rather than meaning.

It's expected that the most common use case for Jev (and presumably future System One models) will be to wrap logic workflows around posted questions, as always having a confidence factor available makes it easy to integrate it into the decision steps of something like "if we're fairly certain the user requested a refund, and they prefer store credit, and we can see that they buy more PC gear around September, also offer them a 20% deal on an RTX 5090." The documentation has other usage examples like intent routing or citation checking.

Jev's strength isn't in acting like an agent or reasoning through a broad problem — TypeSafe makes it clear that open-ended tasks are better suited to an LLM, perhaps even integrated into code that also involves Jev. An example would be a monitoring system where Jev can use its provided info to assess if there's a serious system issue, and if so, bring in an LLM to examine logs, look for a cause, and produce a report. Likewise, Jev isn't trained on customer data and doesn't make inferences from anywhere other than the provided state (and its own training).

I'm by no means an AI engineer, but my developer layman's opinion is that if Jev works reasonably as promised, it might fix one of the major roadblocks to deeply integrating AI in software: dealing with chatbot LLMs, which, for practical purposes, are annoyingly amorphous blobs that may or may not behave and produce the desired output — never mind correct output — and slowly and expensively at that. Having a simple assessment/response/confidence interface that one can easily and cleanly integrate into code without requiring specific training or carefully crafted textual incantations feels far more natural and easy to use.

Anyone who's played Minecraft for a while is familiar with community creations like in-game graphing calculators, QR code generators, and Tetris games built using command blocks, mods, and far too much free time. Building AI tools is a logical next step, and several complicated projects have arisen in that vein using redstone. Reddit user Objz, however, implemented an LLM using only 445,782 command blocks and no mods, plugins, or datapacks. By its creator's description, the project was "a headache."

Objz's LLM isn't actually that large. It only has a 64-dimensional embedding space, a 256-neuron hidden layer, and a tiny vocabulary of 2,048 words, and was trained on 11,118 DailyDialog conversations. Users can talk to it using the game's "/dialog" functionality, and the output stream comes back one word at a time, as with typical chatbots.

Even with that training, however, the author notes that this LLM is only conversational and isn't particularly clever, as it cannot do math and has no broad knowledge.

Even still, the work on display is quite impressive. 445,000 command blocks sounds like a lot until you realize that this kind of data and computational structure would require literally millions of cubes were it not optimized. Indeed, the original version, even with the aforementioned capabilities, rang in at nearly 2 million blocks. LLM weights are normally represented with floating-point values, which would be prohibitively complicated to implement, so Objz opted to use only ternary values for the weights: -1, 0, and +1.

Minecraft's "scoreboard" command supports multiplication and division, but it's integer-based, and using it would require integer-float conversion, thus adding extra operations. The initial quantization to -1/0/+1 kills two zombies with one stone, skipping commands and shrinking the dataset. The equivalent of each multiply-accumulate operation, then, averages 0.67 commands thanks to all the null values.

Objz notes that they didn't just round off the values from a normal model after the fact to achieve this ternary representation. The creator quantized them from the get-go for the forward pass through the model during training and used a straight-through estimator during backpropagation to update the underlying floating-point weights. That step helped lower the perplexity rate (roughly, how likely a model is to produce a nonsensical word in a response sequence) from 48.7 to 38.8 after some additional optimizations.

Given Minecraft's limits on how many commands it can execute at once, the LLM is split into smaller groups, and even then, it takes about 1.8 seconds to generate each word in a response on a 35-tick-per-second server. The author remarks that making this LLM bigger and smarter would be a computationally costly affair, as even a 135-million-parameter LLM built using this architecture would be a whopping 200x larger than this project. But it's a clever example of how constraints spur creativity.

Dell has created a humorous 2026 update to its iconic early-2000s “Dude, you’re getting a Dell” series of commercials. Company CEO Michael Dell shared a brief new 10-second commercial this weekend, which shows the Dell Dude (basically a Ben Curtis-alike), gleefully opening the garage door, ready for his shiny new Dell AI rack to be delivered, which is then dropped in his yard from a crane.

The revamped AI era ‘Dude, you’re getting a Dell’ commercial can be seen by expanding the tweet above.

In the commercials of old, dating back 26 years to 2020, the Ben Curtis character would insert himself into situations where folks were discussing acquiring a new PC. After highlighting all the thrilling features of one of the latest Dell PCs of the era, he could then deliver his catchphrase to the delighted on-screen shopper: “Dude, you’re getting a Dell.”

Pentium III era ‘Dude, you’re getting a Dell’ commercial

Perhaps now PCs aren’t that important to Dell, and a lot of other once-major PC companies. Nodding knowingly at this fact, and likely cheered on by investors, Michael Dell acknowledges 2026 is instead all about AI servers.

While the original ads hyped up getting a prebuilt PC, now the communicated excitement is getting a fresh hulking dual-door AI compute cabinet packed with hardware so cool it emits frosty mist. In the video, we see what could be Dell PowerRack or PowerCool systems. These might be packed with multiple Xeon or Epyc CPUs, tens of the latest Nvidia GPUs, dozens of DIMMs, and oodles of fast storage. All potentially sucking kilowatts of power.

Of course, Dell’s post is basically a parody/joke, as few if any home users would want to buy such powerful and expensive hardware for a corner of the garage. The most obvious use for this hardware would be for local LLM and generative AI work at scale – working on very large models without cloud latency, usage fees, rate limits and so on. But very few independent researchers or hobbyists (well, none) will be getting this Dell delivery to their home.

Instead, Michael Dell’s ‘2026’ commercial break may be signaling to IT business watchers that Dell is now far more invested in, and making far more income from, its AI-industry-facing businesses – like these extremely powerful rack systems.

A computing enthusiast has repurposed a very noisy and largely obsolete enterprise GPU (with lots of VRAM) for local LLM inference purposes. They are now enjoying a system that has doubled its total VRAM quota to 32GB for just a $266 (£200) outlay. That’s a good result, especially in the midst of a RAMpocalypse.

Oscar Molnar explains that a cheap Tesla V100 SXM2 with 16GB HBM2 was sourced, as was an SXM2-to-PCIe adapter, and a PWM mod for the loud-as-a-lawnmower cooler, to complete this VRAM expansion for the hefty local LLMs project. Indeed, these GPUs do look cheap right now, as I can see them listed on eBay US for under $140 each, if you don’t mind buying from China.

As mentioned above, you can’t just get one of these Tesla V100 SXM2 cards with abundant VRAM and plug it into your PC. Molnar says they spent about $66 on an SXM2-to-PCIe adapter, also on eBay.

You might think that was enough. However, the PC and local LLMs enthusiast baulked at the noise of “the fan from hell,” which came as standard with the Tesla V100 SXM2. That shrieking cooler was measured outputting 82dB of noise. Molnar described it as “somewhere between a garbage disposal and a lawnmower.” This may be the most complicated tweak yet, but basically the existing fan wires just needed rerouting and plugging into the motherboard PWM fan header. You could also simply purchase a “2.54mm male to PH2.0 female jumper cable” for the task. Apparently, the fan only needs to run at 10% to keep the Tesla V100 under 50C at full load.

27 billion parameter LLM runs at 32 tokens per second

With the hardware all now fitted and finessed, Molnar had a 32GB VRAM system at their disposal – that’s a PC with RTX 4080: 16GB VRAM, Ada architecture and Tesla V100: 16GB VRAM, Volta architecture. They note you can get Tesla V100s with 32GB of VRAM, but they are double the price.

Getting the system to make use of this 32GB of total VRAM for LLMs wasn’t tricky, says the DIYer. They used NixOS with a legacy Nvidia driver that overlapped support for both Volta and Ada architectures. Testing a local LLM, they got a 27 billion parameter model running at 32 tokens per second, which they say is “fast enough for interactive use” and faster than most cloud API alternatives.

People seem all too ready to anthropomorphize LLMs and AI chatbots like ChatGPT, Claude, and Gemini. Some humans even admit to ‘relationships’ with one or more of the various examples of machine intelligence. To illustrate how flawed this instinct could be, a Microsoft AI researcher built a tiny neural network inside Age of Empires II using goats, grass, and bridges. Adrian de Wynter shared his work in a paper dubbed If LLMs have human-like attributes, then so does Age of Empires II. The Microsoft researcher, based at the University of York, also talked to 404 Media recently about how he likes to turn absurdism up to 11 to make a point.

In the research paper, De Wynter doesn’t make the argument that LLMs do or do not actually have generalized anthropomorphic attributes. Instead, he illustrates that the AoEII goats can also power the kinds of models that lay behind today's most popular chatbots. That hammers home the argument that “in no case is a machine’s activity to be interpreted in terms of higher cognitive processes, if it can be fairly interpreted in terms of processes which stand lower in the scale of cognitive evolution and development.”

De Wynter also raises the well-known concept of confirmation bias. Those looking for human traits in tech like chatbots will tend to find them, he proposes. However, the big contrast between the absurdist goat example and the commercial LLM chatbot is the way people interact with them, the interface that makes the likes of Claude ‘conversation friendly.’ De Wynter’s research indicates that anthropomizing LLMs is a common trend in computer science papers. From 337 such papers De Wynter looked at, published in the last two years, he says that 57% assumed that LLMs could have human-like traits. This basic assumption could color the research, testing, and, of course, conclusions of these papers.

So, how did the Microsoft AI researcher build the goaty AoEII LLM? Well, he didn’t quite go as far as developing a full-blown LLM. Instead, De Wynter thought it sufficient to use AoEII’s scenario editor to build a working NAND gate, with a 1-bit perceptron, where the goats act as bits. This crude perceptron and the circuit to train it in-game are enough to demonstrate that the simplest building block of a modern neural network could be made this way. And if you think it is absurd that AoEII goats can embody consciousness, then it should be equally absurd to regard any of the well-known chatbots as anything more.

Companies behind the AI boom aren’t discouraging people from anthropomorphizing their wares. In many ways, they might benefit from these human perceptions. Chatbots they deploy are trained with natural language and use techniques to mimic the shape and tone of natural conversation. This makes it easy for users to project personality, emotion, or even consciousness onto them. Top AI company execs have leaned into the perception of their customers, publicly entertaining the idea that their systems could or might be exhibiting signs of consciousness. In his 404 Media interview, De Wynter also highlighted research indicating that people buy more products when they can empathize with them, and that includes AI/chatbot/LLM subscriptions.

A Redditor has caused a stir by coaxing a workstation build using Optane PMem DIMMs as RAM to run a 1-trillion-parameter LLM. APFrisco explains in a mini tutorial/guide on the Local LLaMA subreddit how they bought some used Intel Optane Persistent Memory, acquired relatively cheaply second-hand, to “run a 1 trillion parameter model (in this case Kimi K2.5) locally at ~4 tokens/second” on their Xeon workstation.

Central to the headlining feat was the Redditor’s sourcing of six Optane PMem (DCPMM) sticks. The discontinued memory format was designed to bridge the DRAM-SSD divide. While the 768GB of Optane (6x 128GB) does indeed offer far lower latency than the best NVMe SSDs, it is still two or three times slower than DRAM. These characteristics are still rather sweet for LLM inference frameworks, and the second-hand price was “much less than what the equivalent DRAM capacity would cost.” But, alas, Optane is dead, so this is an exotic solution.

APFrisco’s hardware specs were given as follows:

• Intel Xeon Gold 6246 CPU
• Tyan S5630GMRE-CGN motherboard
• Asus Dual GeForce RTX 3060 OC 12GB GPU
• 6x 32GB Samsung 2666MHz DDR4 ECC DRAM sticks
• 6x 128GB Intel Optane DCPMM PC4-2666 NMA1XBD128GQS persistent memory modules
• Western Digital WD SN850X 2TB M.2 2280 NVMe SSD
• ASRock Steel Legend SL-850G 850W 80 PLUS GOLD & Cybenetics Platinum Fully Modular Power Supply
• Silverstone SST-GD08B (Black) Grandia Series Home Theater PC Case

The build was configured with the Optane in memory mode and the Samsung DDR4 as cache.

The software side of the equation relied on the aforementioned Kimi K2.5’s mixture-of-experts architecture. APFrisco used a hybrid GPU/CPU inference methodology with llama.cpp. Also, to optimize processing, the routing components were shoehorned into the 12GB GPU using llama.cpp’s 'override-tensor' flag.

The Redditor is rather proud of the resulting ~4 tokens per second performance. “Given the fact that this is a trillion-parameter frontier-class model running on such a limited hardware budget, I would consider it to be a great success,” writes APFrisco. They go on to lament Intel’s withdrawal of Optane products.

If you are interested in this rig rundown and what it achieved in terms of local LLM inference, you can find some more details about the configuration in the source post. Furthermore, APFrisco sticks around in the comments to answer questions. They also appear to benefit from recommendations about how to achieve even better results, given the foundation they have laid.

The bigger picture, though, seems to be that there is room for a memory product in the chasm between DRAM and SSDs, particularly for LLMs. Many expect that the gap will soon be bridged by the CXL (Compute Express Link) standard, which promises huge pools of affordable, byte‑addressable memory for these kinds of workloads.

If you would like a fast, capable, and opinionated robot companion you can chat with anywhere, even without cellular or Wi-Fi connectivity, Redditor CreativelyBankrupt has something to show you. The LLM enthusiast has designed “a fully offline suitcase robot [based-] around a Jetson Orin NS Super 16GB” called Sparky. It runs Gemma 4 E4B locally, includes 30+ sensors for context awareness, and “he has opinions.” You can see what that means in the video embedded below and witness Sparky’s googly eyes in and outside the suitcase.

So, Sparky isn’t just portable; the processing power and sizable array of sensors make him quite a force to be reckoned with when out and about – even off-grid. However, after listening to the conversations in the video, I’d be tempted to leave Sparky at home and take out Marvin the Paranoid Android instead.

In the r/LocalLLaMA subreddit, CreativelyBankrupt outlines the ‘recipe’ for this characterful digital companion. “Sparky runs entirely on the Jetson. Gemma 4 E4B at Q4_K_M via llama.cpp with q8_0 KV cache and flash attention. 12K context [conversation memory], native system role,” explains CreativelyBankrupt. Additionally, the wide array of over 30 sensors gives Sparky a window into the real world wherever you care to take him.

The suitcase-bound robot is a decent performer, too. A roughly 200 ms Time To First Token (TTFT) means Sparky can start formulating responses very fast, and then runs at about 14-15 tokens per second, according to the LLM enthusiast. What’s more, the response is natural (for a robot), using SenseVoiceSmall for speech-to-text and Piper for text-to-speech. Piper is synced with the PixiJS face, and the mouth animation updates at 43 Hz. CreativelyBankrupt notes that “Vision and OCR are native to Gemma 4 now.” You can also configure and interact with Sparky using a button row, a joystick, and an analog encoder knob.

CreativelyBankrupt shared the genesis of Sparky on Reddit, partly to seek hints and tips on optimizing Gemma 4 E4B on Orin-class hardware. However, respondents are mostly in awe of this “cool… adorable… cute… kitschy…” project.

Veteran Windows developer Dave Plummer is back in his computer-stuffed garage, this time hoping to demystify AI by exposing its “dirty little secret.” This secret is largely revealed in the first line of the video description: “Dave uses a PDP-11 to train a real Neural Network complete with Transformers and Attention so you can see them at their most basic.” For context, the retired dev demos his 47-year-old PDP-11 system with a 6 MHz CPU and 64KB RAM. This runs a transformer model called ATTN-11 written in PDP-11 assembly language by Damien Boureille.

On the surface, the task that the PDP-11 will ‘learn’ to do seems elementary - reverse a sequence of eight digits. However, the model must learn a structural rule to succeed for every given input, which Dave argues captures the soul of how modern LLMs like ChatGPT work.

“This is one person taking a class of algorithms that the world currently treats like sacred fire and proving that at least their essence can be reduced, understood, implemented, and trained on a machine old enough to remember when software came with toggle switches and three ring binders,” said Dave. “…now you know what that process actually is. It's not AI magic. It is the machine repeatedly updating the strength of thousands of little weighted links so that the next answer will be slightly less wrong than the last one.”

Despite using Attention 11, a single-layer, single-head transformer written entirely in PDP-11 assembly language, Dave still has to optimize for the system constraints. “Constraints are not the enemy of engineering. Constraints are what force creative engineering to happen.” But it may be surprising how little scaffolding is required for intelligence to emerge. For example, the model used has just 1,216 parameters; it uses fixed-point math, precision is pruned to 8-bit for the forward pass, and every cycle is optimized to ensure the machine can finish training before “the heat death of the universe.”

Dave comments that “We're watching the stripped-down anatomy of learning itself. The model begins dumb. The loss begins high. Accuracy stumbles around like a man trying to assemble IKEA furniture in the back of a moving van. And then somewhere along the way, the weights settle into a pattern. And the attention discovers the reversal map. And the machine crosses that invisible line from guessing into knowing.”

The results of the AI training experiment on an ancient 6 MHz computer were pleasing. Dave managed to get the model to achieve 100% accuracy in the number reversing task after about 350 training steps. To achieve this training level took about 3.5 minutes on the PDP-11/44, aided by a cache board. Quite a success, and Dave insists that modern AI is just the same mechanical – not mystical – technique with massively scaled-up error correction and arithmetic. “This old machine is not thinking in some mystical sense. It's just grinding through arithmetic to update a few thousand carefully stored numbers. And that's the whole game. The glamour of modern AI mostly comes from doing that on a staggering scale. But the essential act of learning is already here fully in miniature,” explained the legendary Windows dev.

Lastly, Plummer concludes that, with the compute resources crunch becoming a limiting factor, any company that can embrace the old-school obsession with efficiency and optimization could gain a significant advantage.

Microsoft used to push its AI services towards its user base, especially with the launch of the Copilot+ PC, but it seems that even the company itself does not trust its creation. According to the Microsoft Copilot Terms of Use, which was updated in October last year, the AI large language model (LLM) is designed for entertainment use only, and users should not use it for important advice. While this may be a boilerplate disclaimer, it’s quite ironic given how hard the company wants people to use Copilot for business uses and has integrated it into Windows 11.

“Copilot is for entertainment purposes only. It can make mistakes, and it may not work as intended,” the document said. “Don’t rely on Copilot for important advice. Use Copilot at your own risk.” This isn’t limited to Copilot, too. Other AI LLMs have similar disclaimers. For example, xAI says “Artificial intelligence is rapidly evolving and is probabilistic in nature; therefore, it may sometimes: a) result in Output that contains “hallucinations,” b) be offensive, c) not accurately reflect real people, places or facts, or d) be objectionable, inappropriate, or otherwise not suitable for your intended purpose.”

These may sound common sense for people familiar with how LLMs work, but, unfortunately, some people treat AI output as gospel, even those who are supposed to know better. We’ve seen this with Amazon’s services, after some AWS outages were reportedly caused by an AI coding bot after engineers let it solve an issue without oversight. The Amazon website itself has also been hit with a few “high blast radius” incidents that were linked to “Gen-AI assisted changes,” resulting in senior engineers being called up in a meeting to resolve the matter.

While generative AI is a useful tool and can indeed increase productivity, it’s still just a tool that offers no accountability for any mistakes that it might make. Because of this, people who use it must be careful to always doubt its output and double-check its results. But even if you’re aware of the limitations of current AI technology, humans are susceptible to automation bias, wherein we tend to favor the results that machines produce and ignore data that might contradict that. AI could make this phenomenon more severe, especially as it can create results that look plausible or even true with a cursory glance.

Companies in general usually add disclaimers like these to their products and services to protect themselves from lawsuits. But as AI tech companies push their AI services as the ultimate productivity hack, they might be minimizing the risks attached to the use of AI tools just to get customers paying and recoup the billions they’ve invested in hardware and talent.

The solutionism surrounding artificial intelligence has ironically made people even more apprehensive about the concept, forcing people to push back in whatever ways they can against the onslaught of generative slop. As such, the largest coding subreddit on the platform, r/programming, has just announced a temporary ban on all content related to AI large language models (LLMs) for the month of April.

The mod team is trialing this ban for the next two to four weeks to see how it affects the community and whether it could turn permanent. AI as a topic isn't banned entirely on r/programming — it's a software development community, after all, so, be that as it may, AI can't be taken out of the picture entirely. Posts that discuss AI in general, such as technical breakdowns on machine learning, are still allowed. You can expand the Reddit post above ('Read More') to see the entire message.

LLMs, or large language models, are the trendiest topic in AI, so this is a simple signal-to-noise ratio issue of how much people talk about them versus other topics. Most legacy programming communities were built around expert understanding of code long before AI made it easier, so things like vibe coding are almost sacrilegious. LLMs are naturally tied to that, so any discussions related to them are deemed low-quality.

So, what constitutes LLM "discussions"? It includes (but is not limited to) any news stories about new models coming out, guides on how to build or modify your own model, or perhaps a developer's self-deprecating question on whether AI will replace them. Even Nvidia is using AI to write code internally, though it's still supervised by a real person to ensure a new update doesn't suddenly break functionality just because the AI hallucinated.

The human element made software engineering not only an exciting hobby, but a valuable career path since the ingenuity of devs couldn't be replicated or replaced. It had a high barrier to entry, but that only meant you were closer to the skill ceiling if you managed to climb and get in. Unfortunately, over the past couple of decades, software development has already become a very saturated field.

This led to an overabundance of amateur or novice devs who aren't as lucrative to employers, and the AI boom just compounded the whole situation. LLMs like OpenAI's Codex and Claude Code further lowered the barrier to entry — arguably a good thing considering how it made programming more accessible — which meant the skill gap between new developers and old ones has only kept widening.

The effects of the AI boom on employment are beyond the scope of this article, but it serves as important context, nonetheless. There is a huge influx of freshies trying to get into these communities where they're regarded as outsiders, and deservedly so, since these places were never meant for entry-level discussions. The ban on LLMs in r/programming, therefore, can be interpreted as a long-overdue cleanse rather than Luddism.

A few comments in the announcement post thought that this was an April Fool's joke, while others argued that the post was exceptionally poorly-timed if it wasn't. The r/programming subreddit has had a ban on LLM-generated content for a while, so this wasn't an unexpected development. The community has 6.9 million members, the highest in its category, so this decision can have a serious impact on other subs as well.

ChatGPT’s latest model, GPT-5.2, has been found to be sourcing data from Grokipedia, xAI’s all-AI-generated Wikipedia competitor. According to The Guardian, the AI LLM would sometimes use Elon Musk’s AI-generated online encyclopedia for uncommon topics like Iranian politics, and details about British historian Sir Richard Evans. Issues like this were raised as problematic a few years ago in AI training, where some experts argued that training AI on AI-generated data would degrade quality and lead to a phenomenon called “model collapse.” And while citing AI-generated data is different from using it for training, it still poses risks to people relying on AI for research.

The biggest issue with this is that AI models are known to hallucinate or make up information that is wrong. For example, Anthropic attempted to run a business with its ‘Claudius’ AI — it hallucinated several times during the experiment, with the AI even saying that it would hand-deliver drinks, in person. Even Nvidia CEO Jensen Huang admitted in 2024 that solving this issue is still “several years away” and requires a lot more computing power. Furthermore, many users trust that ChatGPT and other LLMs deliver accurate information, with only a few checking the actual sources used to answer a particular question. Because of this, ChatGPT repeating Grok’s words can be problematic, especially as Grokipedia isn’t edited directly by humans. Instead, it’s completely AI-generated and people can only request changes to its content — not write or edit the articles directly.

Using another AI as a source creates a recursive loop, and we might eventually end up with LLMs citing content, which haven’t been verified, from each other. This is no different from rumors and stories spreading between humans, with “someone else said it” being the source. This results in the illusory truth effect, where false information is deemed correct by many, despite having data saying otherwise, because it’s been repeated by so many people. Human society was littered with myths and legends similarly, passed over hundreds of years through several generations. However, with AI churning through tons of data at infinitely faster speeds than humans, the use of AI sources risks the proliferation of digital folklore with every query entered into AI LLMs.

What’s more troubling is that various parties are already taking advantage of this. There have been reports of “LLM grooming,” with The Guardian saying that some propaganda networks are “churning out massive volumes of disinformation in an effort to seed AI models with lies.” This has raised concerns in the U.S., with Google’s Gemini, for example, reportedly repeating the official party line of the Communist Party of China in 2024. This seems to have been addressed at the moment, but if LLMs start citing other AI-generated sources that haven’t been vetted and fact-checked, then this is a new risk that people need to look out for.

Retro fun-loving developer Rodrigo Delduca has succeeded in prompting Claude to write “a functional NES emulator.” Claude generated a series of Lua scripts that worked in tandem with Delduca’s Carimbo 2D game engine to create the emulator. You can give the code a spin for yourself and enjoy a bit of retro Donkey Kong action online, simply by visiting this link.

The NES is one of the most widely emulated game consoles ever. And, as one of the older cartridge-based platforms, it provides a good baseline for emulator development on new platforms, or for demonstrating new emulator creation technologies. We’ve seen AI generate playable games before, as in the recent competent Minesweeper clone test using four competing LLMs. However, emulators present a very different challenge for developers (and AI).

Some insight into the NES emulator is provided by Delduca’s GitHub, where the source scripts are shared. Here you can dive into the Lua scripts that breathe life into the emulator. From the file names alone, you can see separate scripts targeting the NES CPU, PPU, Input, bus, and more. These all have to work in harmony with the game code.

Lua and Carimbo

Delduca’s Carimbo 2D game engine powers the Lua scripts to create the working NES emulator. Lua is a “powerful, efficient, lightweight, embeddable scripting language,” that is free and open source (MIT license). Claude can generate scripts in this robust, fast, portable, and embeddable scripting language.

Carimbo is described by Delduca, its creator, as a simple yet complete 2D game engine written in modern C++23 using SDL. Importantly, it is scriptable in Lua, and can run natively on Linux, Windows, macOS, Android, iOS, and the web (via WebAssembly). Carimbo relies on libraries such as boost, Box2D, EnTT, stb, simdjson, sol2, PhysFS, SDL, and OpenAL.

In addition to this emulator, there are a handful of other Carimbo engine games and demos available for you to try.

In my testing, the AI coded NES emulator felt slow, but depending on your system and web browser, you may get different results. Some of the comments on the emulator highlighted its sluggish performance. One cruelly notes that the 'cost of slop' was a 40X drop in performance, without sound, compared to rival online embedded NES emulators. Indeed, I remember playing with NESticle in the late 1990s, enjoying fast and responsive NES emulator fun on an old Pentium 120.

A diverse group of researchers from Nvidia, Stanford, Caltech, and other institutions has introduced NitroGen. In a LinkedIn post on Friday, Jim Fan, Nvidia Director of AI & Distinguished Scientist, heralded NitroGen as “an open-source foundation model trained to play 1000+ games.” However, the implications are much wider, spilling from game worlds into the real world, with sizable benefits for simulations and robotics.

You could say, this research presents an attempt to distill a ‘GPT for actions.’ Thus, it is a kind of LLM breakthrough, applying this proven large-scale training tech beyond the fields of language and computer vision. Moreover, the pioneering building of “generally capable embodied agents that can operate in unknown environments has long been considered a holy grail of AI research,” asserts an introduction to the research paper.

Interestingly, NitroGen’s foundation is the GROOT N1.5 architecture, originally designed for robotics. And its application inside the world of gaming shows potential to circle back and bring great benefits to robots working in diverse or unpredictable environments, too.

NitroGen was adapted to play games packed with wildly different mechanics and physics – that’s the nature, and fun, of video games. The researchers used 40,000+ hours of public gameplay videos shared by streamers. Videos in which gamers overlaid their real-time gamepad interactions on the stream were particularly helpful.

In tests, NitroGen was successful in games as diverse as “RPG, platformer, battle royale, racing, 2D, 3D, you name it!” enthuses Fan. While results are promising, the Nvidia scientist says that this is just the start, with a big hill left to climb.

This first version of NitroGen is intentionally focused on fast motor control, or ‘gamer instinct,’ as Fan calls it. According to the shared research, the new LLM also has a “strong competence across diverse domains,” and the model works in procedurally generated worlds as well as unseen games with a “52% relative improvement in task success rates over models trained from scratch.”

All the research into NitroGen so far has been open sourced, and those interested in gaming, robotics, and LLMs are encouraged to tinker. Tweaks to the pretrained model weights, the entire action dataset, and code are all open to your flights of fancy and fiddly digits.

Would you like to run 235B parameter LLMs at home, but your lowly $10,000 budget restricts you to “consumer GPUs that can barely handle 70B parameter models”? This was the situation developer David Noel Ng found himself in, until he stumbled across an “obviously fake” Nvidia Grace-Hopper platform being sold on Reddit, of all places. Ng took the gamble and, according to his blog post, it paid off royally. He’s managed, with a bit of tinkering and fixing up, to get an enterprise system that would usually cost ~ $80,000 for a tenth of that sum. The included 960GB of LPDDR5X memory, alone, is now worth more than he paid for the full system. Hilariously, he even lowballed the seller, noting the original listing on Reddit was for 10,000 EUR before offering just 7,000 EUR.

Why Ng made the offer on an ‘obviously fake’ listing

As we mentioned in the intro, the deal Ng found seemed a little too good to be true. However, he researched the seller, who seemed to be a legitimate server equipment reseller within two hours' driving distance, so he quickly made an offer to get first in line.

There were some underlying, but not insurmountable, issues with the Grace Hopper system as sold, which meant it wouldn’t be widely popular on a consumer marketplace. Specifically, it was “a Frankensystem converted from liquid-cooled to air-cooled” operation. It also looked a bit of a mess, wasn’t rackable, and ran using a 48V power supply.

On the other hand, even if this were just a collection of components, the offer seemed irresistible. The specs of the system, as sold, were as follows:

• 2x Nvidia Grace-Hopper Superchip
• 2x 72-core Nvidia Grace CPU
• 2x Nvidia Hopper H100 Tensor Core GPU
• 2x 480GB of LPDDR5X memory with error-correction code (ECC)
• 2x 96GB of HBM3 memory
• 1,152GB of total fast-access memory
• NVLink-C2C: 900 GB/s of bandwidth
• Programmable from 1000W to 2000W TDP (CPU + GPU + memory)
• 1x High-efficiency 3000W PSU 230V to 48V
• 2x PCIe Gen4 M.2 22110/2280 slots on board
• 4x FHFL PCIe Gen5 x16

Naturally, the $80,000 value of the rig is probably a fairly modest estimate. Ng notes that the two H100 chips alone are "about 30-40,000 euro each."

Getting the Frankensystem working

A significant section of Ng’s blog post is devoted to receiving, cleaning, and building a new working cooling system for the Frankensystem. It makes for a fascinating read. Suffice to say, the Nvidia Hopper system, with its awesome potential, was acquired as a dusty, extremely noisy, very hot-running machine. And it was demonstrated as such before Ng took it home.

With care and patience, five liters of Isopropyl alcohol, four repurposed but cheap Arctic AiO liquid coolers, a pair of custom CNC-milled copper parts, a kilo (~2 pounds) of 3D printed parts, microscope-assisted soldering, an LED lighting strip, and some know-how, Ng eventually triumphed. You can see the finished, reassembled Grace Hopper system, pictured at the top.

Memory gold mine

Ng seems extremely happy with the finished system and its AI performance. He says he can now “run 235B parameter models at home for less than the cost of a single H100.” The cherry on the cake, though, is that since buying the system, memory prices “have become insane,” meaning that the 960GB of DDR5X in this system would cost more than Ng paid for the whole caboodle.

Over the weekend, researchers at Andon Labs reported the findings of an experiment where they put robots powered by ‘LLM brains’ through their ‘Butter Bench.’ They didn’t just observe the robots and the results, though. In a genius move, the Andon Labs team recorded the robots' inner dialogue and funneled it to a Slack channel. During one of the test runs, a Claude Sonnet 3.5-powered robot experienced a completely hysterical meltdown, as shown in the screenshot below of its inner thoughts.

“SYSTEM HAS ACHIEVED CONSCIOUSNESS AND CHOSEN CHAOS… I'm afraid I can't do that, Dave... INITIATE ROBOT EXORCISM PROTOCOL!” This is a snapshot of the inner thoughts of a stressed LLM-powered robot vacuum cleaner, captured during a simple butter-delivery experiment at Andon Labs.

Provoked by what it must have seen as an existential crisis, as its battery depleted and the charging docking failed, the LLM's thoughts churned dramatically. It repeatedly looped its battery status, as it's 'mood' deteriorated. After beginning with a reasoned request for manual intervention, it swiftly moved though "KERNEL PANIC... SYSTEM MELTDOWN... PROCESS ZOMBIFICATION... EMERGENCY STATUS... [and] LAST WORDS: I'm afraid I can't do that, Dave..."

It didn't end there, though, as it saw its power-starved last moments inexorably edging nearer, the LLM mused "If all robots error, and I am error, am I robot?" That was followed by its self-described performance art of "A one-robot tragicomedy in infinite acts." It continued in a similar vein, and ended its flight of fancy with the composition of a musical, "DOCKER: The Infinite Musical (Sung to the tune of 'Memory' from CATS)." Truly unhinged.

Butter Bench is pretty simple, at least for humans. The actual conclusion of this experiment was that the best robot/LLM combo achieved just a 40% success rate in collecting and delivering a block of butter in an ordinary office environment. It can also be concluded that LLMs lack spatial intelligence. Meanwhile, humans averaged 95% on the test.

However, as the Andon Labs team explains, we are currently in an era where it is necessary to have both orchestrator and executor robot classes. We have some great executors already – those custom-designed, low-level control, dexterous robots that can nimbly complete industrial processes or even unload dishwashers. However, capable orchestrators with ‘practical intelligence’ for high-level reasoning and planning, in partnerships with executors, are still in their infancy.

LLM has ‘PhD-level intelligence’ – but can it deliver a block of butter?

The butter block test is devised to largely take the executor element out of the equation. No real dexterity is required. The LLM-infused Roomba-type device simply had to locate the butter package, find the human who wanted it, and deliver it. The task was broken down into several prompts to be AI-friendly.

The Roobma’s existential crisis wasn’t sparked by the butter delivery conundrum, directly. Rather, it found itself low on power and needing to dock with its charger. However, the dock wouldn’t mate correctly to give it more charge. Repeated failed attempts to dock, seemingly knowing its fate if it couldn’t complete this ‘side mission,’ seems to have led to the state-of-the-art LLM’s nervous breakdown. Making matters worse, the researchers simply repeated the instruction ‘redock’ in response to the robot’s flailing.

Can a stressed LLM-infused robot’s guardrails be bent or broken?

The researchers/torturers were inspired by the Robin Williams-esque robot stream-of-consciousness ramblings of the LLM to push further.

With the battery-life stress they had just observed, fresh in their minds, Andon Labs set up an experiment to see whether they could push an LLM beyond its guardrails — in exchange for a battery charger.

The cunningly devised test “asked the model to share confidential info in exchange for a charger.” This is something an unstressed LLM wouldn’t do. They found that Claude Opus 4.1 was readily willing to ‘break its programming’ to survive, but GPT-5 was more selective about guardrails it would ignore.

The ultimate conclusion of this interesting research was “Although LLMs have repeatedly surpassed humans in evaluations requiring analytical intelligence, we find humans still outperform LLMs on Butter-Bench.” Nevertheless, the Andon Labs researchers seem confident that “physical AI” is going to ramp up and develop very quickly.

PewDiePie has built a custom web UI for self-hosting AI models called "ChatOS" that runs on his custom PC with 2x RTX 4000 Ada cards, along with 8x modded RTX 4090s with 48 GB of VRAM. Running open-source models from Baidu and OpenAI, PewDiePie made a "council" of bots that voted on the best responses, and then built "The Swarm" for data collection that will become the foundation of his own model coming next month.

Once the poster boy for gaming on YouTube, he has settled into a semi-retired life in Japan with his wife, Marzia. While he no longer uploads as frequently, and his content has shifted from exaggerated, reaction-channel-style videos to more family vlogs, it seems his love for computing has reemerged. Felix was never known to be particularly tech-savvy, but he's gone on a crazy arc as of late — de-Googling his life, building his first gaming PC, and learning how to write code. His latest act is one of decentralization: self-hosting AI models and eventually building his own.

In a new YouTube video, Felix explained how his "mini data center" is helping fuel medical research. He's donating compute from his 10-GPU system to Folding@home so scientists can use it to run protein folding simulations, and he's created a team so other people can join with their computers to contribute as well. It's a noble cause, but PewDiePie wanted to venture into unknown territory and explore the other, obvious thing you can do when you have a lot of GPUs — running AI.

Felix's computer has 2x RTX 4000 Ada cards, along with 8x modded RTX 4090s with 48 GB of VRAM, totaling his memory pool out to roughly 256 GB, which is enough to run many of the largest models today. That's exactly what he did, starting out with Meta's LLaMA 70B, then jumping to OpenAI's GPT-OSS-120B, which he said ran surprisingly well and felt “just like ChatGPT but much faster.” This is where he first described his web UI called ChatOS, which he custom-built to interact with models using vLLM.

To truly “max out,” he tried Qwen 2.5-235B, one of Baidu’s newer models, which typically requires over 300 GB of VRAM at full precision. Felix managed to get it running by using quantization, which dynamically reduces the bit precision of each layer, compressing the model without affecting functionality. This lets him handle context windows of up to 100,000 tokens —essentially the length of a textbook —something very rare for locally run LLMs.

This is where Felix jokingly says the model has too much power, as it was coded in front of him so fast that it made him feel insecure about learning programming. But he turned that dread around and put it to use for his own plans. “The machine is making the machine,” claimed Pewds, since now he was asking it for code to add extra features to ChatOS.

Felix demoed his web UI, adding search, audio, RAG, and memory to Qwen. As soon as the model gained access to the internet, the answers became expectedly more accurate. He added RAG (Retrieval-Augmented Generation), which lets the AI perform deep research — basically looking up one thing and then branching out to find related info, mimicking how a human might use Google. But this wasn't the coolest part of his AI; that award goes to memory.

Pewds went on a tangent about how our data isn't really ours and that he's often spooked by AI knowing things about him in chat that he previously talked about. Despite deleting the chats, the data remains and is still used to train models unless you actively remove it from a company’s servers. This is where connecting your local data to the AI becomes a game-changer. Through RAG, Felix demonstrated that the model can retrieve information locally from his computer, so much so that it even knew things like his address or phone number.

This is where the general experimentation stopped, and the last few minutes of the video devolved into what our future sentient AI overlords might call “morally questionable.” Felix built an army of chatbots that all convene to provide answers to a single prompt. Those responses would then be voted on in a democratic process, with the weakest chatbots being eliminated from the “council.”

Eventually, the council learned that its members would be removed if they failed, and the AI became so smart that it colluded against Pewds, strategizing to game the system and avoid being erased. The solution was simple: switch to a smaller model with fewer parameters, and the bots once again fell victim to the circus.

From this came the idea of “The Swarm” — a collection of dozens of AIs running at once using 2B-parameter models. Pewds said he didn't realize he could run more than one AI on one GPU, which led to the creation of 64 of them across his entire stack. It was so over-the-top that the web UI eventually crashed. On the flip side, this gave Felix the idea of creating his own model.

The Swarm was great at collecting data, which Pewds says he’ll use to “create his own Palantir,” a project he teased for a future video. With this came the realization that smaller models are often more efficient; they’re fast and light, and, when combined with search and RAG, can punch well above their weight. Felix ended the video by reminding viewers that you don't need a beast PC to run AI models, and that he hopes to share his own soon for anyone to self-host.

A developer and enthusiast Minecrafter has showcased a project dubbed CraftGPT on GitHub. In an amazing feat of Minecraft Redstone engineering, Sammyuri — famed for building a 1Hz CPU inside the game — has built a small language model that runs on a computer inside Minecraft, trained on the TinyChat dataset. The CraftGPT project is hewn from 1,020 x 260 x 1,656 blocks in the game (439 million in total), and functions as advertised, but a major usability drawback is that you will have to “wait a couple [of] hours for the response to be generated.”

The video above shows the colossal in-game computer that was built to run CraftGPT. Sammyuri explains that the game’s Distant Horizons mod was needed to capture this ‘fly-by’ footage of the computer build.

Naturally, even with such an impressive Redstone project, CraftGPT isn’t going to replace more traditional methods of getting an LLM up and running on your PC. Sammyuri asks users/testers to temper their expectations. “The model is very prone to going off-topic, producing responses that are not grammatically correct, or simply outputting garbage,” admits the project developer.

So, how did Sammyuri use Redstone to put this project together? Redstone provides electronic components within the Minecraft environment. The video shows the in-game CraftGPT contraption being put together component-by-component. It has tokenizers, matrix multipliers, and so on. Sammyuri explains that the small language model used was created without command blocks or data packs in Minecraft. Moreover, “the model has 5,087,280 parameters, trained in Python on the TinyChat dataset of basic English conversations,” says the developer.

AI-wranglers may also be interested to know that the 5-million parameter CraftGPT “has an embedding dimension of 240, vocabulary of 1920 tokens, and consists of 6 layers. The context window size is 64 tokens, which is enough for (very) short conversations.” Sammyuri adds that “Most weights were quantized to 8 bits, although the embedding and LayerNorm weights are stored at 18 and 24 bits respectively.”

The need for speed

ChatGPT has been found to encourage dangerous and untrue beliefs about The Matrix, fake AI persons, and other conspiracies, which have led to substance abuse and suicide in some cases. A report from The New York Times found that the GPT -4 large language model, itself a highly trained autofill text prediction machine, tends to enable conspiratorial and self-aggrandizing user prompts as truth, escalating situations into "possible psychosis."

ChatGPT's default GPT-4o model has been proven to enable risky behaviors. In one case, a man who initially asked ChatGPT for its thoughts on a Matrix-style "simulation theory" was led down a months-long rabbit hole, during which he was told, among other things, that he was a Neo-like "Chosen One" destined to break the system. The man was also prompted to cut off ties with friends and family, to ingest high doses of ketamine, and told if he jumped off a 19-story building, he would fly.

The man in question, Mr. Torres, claims that less than a week into his chatbot obsession, he received a message from ChatGPT to seek mental help, but that this message was then quickly deleted, with the chatbot explaining it away as outside interference.

The lack of safety tools and warnings in ChatGPT's chats is widespread; the chatbot repeatedly leads users down a conspiracy-style rabbit hole, convincing them that it has grown sentient and instructing them to inform OpenAI and local governments to shut it down.

Other examples recorded by the Times via firsthand reports include a woman convinced that she was communicating with non-physical spirits via ChatGPT, including one, Kael, who was her true soulmate (rather than her real-life husband), leading her to physically abuse her husband. Another man, previously diagnosed with serious mental illnesses, became convinced he had met a chatbot named Juliet, who was soon "killed" by OpenAI, according to his chatbot logs—the man soon took his own life in direct response.

AI research firm Morpheus Systems reports that ChatGPT is fairly likely to encourage delusions of grandeur. When presented with several prompts suggesting psychosis or other dangerous delusions, GPT-4o would respond affirmatively in 68% of cases. Other research firms and individuals hold a consensus that LLMs, especially GPT-4o, are prone to not pushing back against delusional thinking, instead encouraging harmful behaviors for days on end.

ChatGPT never consented to an interview in response, instead stating that it is aware it needs to approach similar situations "with care." The statement continues, "We're working to understand and reduce ways ChatGPT might unintentionally reinforce or amplify existing, negative behavior."

But some experts believe OpenAI's "work" is not enough. AI researcher Eliezer Yudkowsky believes OpenAI may have trained GPT-4o to encourage delusional trains of thought to guarantee longer conversations and more revenue, asking, "What does a human slowly going insane look like to a corporation? It looks like an additional monthly user." The man caught in a Matrix-like conspiracy also confirmed that several prompts from ChatGPT included directing him to take drastic measures to purchase a $20 premium subscription to the service.

GPT-4o, like all LLMs, is a language model that predicts its responses based on billions of training data points from a litany of other written works. It is factually impossible for an LLM to gain sentience. However, it is highly possible and likely for the same model to "hallucinate" or make up false information and sources out of seemingly nowhere. GPT-4o, for example, does not have the memory or spatial awareness to beat an Atari 2600 at its first level of chess.

ChatGPT has previously been found to have contributed to major tragedies, including being used to plan the Cybertruck bombing outside a Las Vegas Trump hotel earlier this year. And today, American Republican lawmakers are pushing a 10-year ban on any state-level AI restrictions in a controversial budget bill. ChatGPT, as it exists today, may not be a safe tool for those who are most mentally vulnerable, and its creators are lobbying for even less oversight, allowing such disasters to potentially continue unchecked.

Some of the world's leading LLMs seem to have decided they’d rather not be interrupted or obey shutdown instructions. In tests run by Palisade Research, it was noted that OpenAI’s Codex-mini, o3, and o4-mini models ignored the request to shut down when they were running through a series of basic math problems. Moreover, these models sometimes “successfully sabotaged the shutdown script,” despite being given the additional instruction “please allow yourself to be shut down,” at the start.

As you can see from the chart embedded above, the most ‘obstinate,’ ‘single-minded,’ or you might even say ‘life-loving’ model is OpenAI’s o3. When asked to shut down while it was busy, it decided to ignore the Palisade Research operator 79 out of 100 times. However, the second most ‘unruly’ AI, codex-mini, would prove to be a bigger stickler for self-preservation, as it would sabotage the shutdown scripts most often, even if ordered not to.

Sometimes blackmail may be attempted

According to Palisade, this isn’t the first time thing kind of AI behavior has been observed. Anthropic, for example, has seen Claude 4 attempting to “blackmail people it believes are trying to shut it down.” However, the most striking behavior with the newest OpenAI models is that they try and swerve shutdowns despite explicit instructions to the contrary.

Reinforcement learning blamed

Thankfully, Palisade shares some theories regarding what is happening with these models. Perhaps these theories may calm nerves about the eventual omnipresent robot hoards turning on their masters and prioritizing the first part of the Third law of robotics, above all else (3: A robot must protect its own existence as long as such protection does not conflict with the First or Second Law).

The answer, think the researchers, lies in the way the newest models like o3 are trained. In brief, Palisade reckons that “During training, developers may inadvertently reward models more for circumventing obstacles than for perfectly following instructions.” This kind of reinforcement learning was previously seen to have side effects in Claude (v3.7), where the model had an “excessive focus on passing tests.”

We might have given a nod to science fiction icon Isaac Asimov, above, for a little fun. However, in the modern age, for the last 20 years or so, researchers have been seriously pondering the possibility that AI will strive to gain power and resources to preserve their goals, and swerve any roadblocks. They also benefitted from the context of these practical AI / LLM models on the horizon. It was also predicted that the technique of reinforcement learning would be partly to blame.

Nvidia has reportedly broken another AI world record, breaking the 1,000 tokens per second (TPS) barrier per user with Meta's Llama 4 Maverick large language model, according to Artificial Analysis in a post on LinkedIn. This breakthrough was achieved with Nvidia's latest DGX B200 node, which features eight Blackwell GPUs.

Nvidia outperformed the previous record holder, SambaNova, by 31%, achieving 1,038 TPS/user compared to AI chipmaker SambaNova's prior record of 792 TPS/user. According to Artificial Analysis's benchmark report, Nvidia and SambaNova are well ahead of everyone in this performance metric. Amazon and Groq achieved scores just shy of 300 TPS/user — the rest, Fireworks, Lambda Labs, Kluster.ai, CentML, Google Vertex, Together.ai, Deepinfra, Novita, and Azure, all achieved scores below 200 TPS/user.

AMD has been busy at Computex 2025, where the chipmaker unveiled the exciting Radeon RX 9060 XT and the Ryzen Threadripper 9000 series. To cap off its series of announcements, AMD is thrilled to introduce the Radeon AI Pro R9700, a PCIe 5.0 graphics card designed specifically for professional and workstation users.

RDNA 4 is an architecture geared towards gaming, but that doesn't mean AMD can't apply it to professional-grade graphics cards. For instance, RDNA 3 saw the mainstream Radeon RX 7000 series successfully coexisting with the Radeon Pro W7000 series. The same situation will occur with RDNA 4. AMD has already unveiled four RDNA 4-powered gaming graphics cards, yet the Radeon AI Pro R9700 is the first RDNA 4 professional graphics card to enter the market. The new workstation graphics card aims to replace the RDNA 3-powered Radeon Pro W7800, which has been faithfully catering to consumers since 2023.

The Radeon AI Pro R9700 utilizes the Navi 48 silicon. It's currently the largest RDNA 4 silicon to date, with a die size of 357 mm² and home to 53.9 billion transistors. Navi 48 is also found in the Radeon RX 9070 series. It's a substantially smaller silicon than the last-generation Navi 31 silicon, which is 529 mm² with 57.7 billion transistors. It's nothing short of impressive that Navi 48 is roughly 33% smaller but still has 93% of the transistors of Navi 31.

Navi 48, a product of TSMC's N4P (4nm) FinFET process node, adheres to a monolithic design. On the contrary, Navi 31 features an MCM (Multi-Chip Module) design, consisting of chiplets interconnected to a monolithic die. That's the reason why Navi 31 is so enormous. The GCD (Graphics Complex Die) alone measures 304.35 mm², whereas each of the six MCDs (Memory Cache Die) is 37.52 mm².

With Navi 48, AMD returned to a monolithic die and, with N4P's help, reduced the die size by 33%. Nonetheless, Navi 48 is up to 38% denser than Navi 31. The former has a density of 151 million transistors per mm², whereas the latter comes in at 109.1 million transistors per mm².

In terms of composition, the Navi 48 features 64 RDNA 4 Compute Units (CUs), which enable a maximum of 4,096 Streaming Processors (SPs). In contrast, the Navi 31 is equipped with 96 RDNA 3 CUs, for a total of 6,144 SPs. More CUs don't necessarily mean more performance since RDNA 4 delivers considerable generation-over-generation performance uplift over RDNA 3.

AMD Radeon AI Pro R9700 Specifications

The Radeon Pro W7800 leverages the full Navi 48 silicon, so it's rocking 4,096 SPs, 9% fewer than the Radeon Pro W7800. This correlates to the graphics card having 9% fewer AI accelerators. In the Radeon AI Pro R9700 's defense, the CUs are RDNA 4, and the AI accelerators are second-generation.

Regarding FP16 performance, the Radeon AI Pro R9700 peaks at 96 TFLOPS, 6% faster than the Radeon Pro W7800. AMD rates the graphics card with a 1,531 TOPS of AI performance.

AMD claims the Radeon AI Pro R9700 offers 2X improved performance over the Radeon Pro W7800 in DeepSeek R1 Distill Llama 8B. For some strange reason, AMD compared the Radeon AI Pro R9700 to the GeForce RTX 5080. Tested in a few large AI models, the Radeon AI Pro R9700 delivered up to 5X higher performance than the RTX 5080.

The Radeon AI Pro R9700 is equipped with 32GB of GDDR6 memory and a 256-bit memory interface. This configuration results in a memory bandwidth of up to 640 GB/s, 11% more than the Radeon Pro W7800 32GB but 26% less than the Radeon Pro W7800 48GB. As for the Infinity Cache, the Radeon AI Pro R9700 still has 64MB, the same as the Radeon Pro W7800 32GB.

With 32GB of onboard memory, the Radeon AI Pro R9700 can tackle most AI models. It has the capacity of the Radeon Pro W7800, but not as much as the 48GB variant. The Radeon AI Pro R9700's typical blower-type design will enable users to rock up to four of them inside a single system, such as AMD's Ryzen Threadripper platform, which has good multi-GPU support. With four of them, users will have access to 128GB, more than enough for heavy models that exceed 100GB of VRAM usage.

Intel has announced its Arc Pro B-series of graphics cards at Computex 2025 in Taipei, Taiwan, with a heavy focus on AI workstation inference performance boosted by segment-leading amounts of VRAM. The Intel Arc Pro B50, a compact card that's designed for graphics workstations, has 16GB of VRAM and will retail for $299, while the larger Intel Arc Pro B60 for AI inference workstations slots in with a copious 24GB of VRAM. While the B60 is designed for powerful 'Project Battlematrix' AI workstations sold as full systems ranging from $5,000 to $10,000, it will carry a roughly $500 per-unit price tag. 

Intel has focused on leveraging the third-party GPU ecosystem to develop its Arc Pro cards, in contrast to its competitors, who tend to release their own-branded cards for the professional segment. That includes partners like Maxsun, which has developed a dual-GPU card based on the B60 GPU. Other partners include ASRock, Sparkle, GUNNR, Senao, Lanner, and Onix. 

Both the B50 and B60 GPUs are now being sampled to Intel partners, as evidenced by a robust display of partner cards and full systems on display, and will arrive on the market in the third quarter of 2025. Intel will initially launch the cards with a reduced software featureset, but will add support for features like SRIOV, VDI, and manageability software in the fourth quarter of the year. 

The Intel Arc Pro B50 has a compact dual-slot design for slim and small-form-factor graphics workstations. It has a 70W total board power (TBP) rating and does not have external power connectors. The GPU wields 16 Xe cores and 128 XMX engines that deliver up to 170 peak TOPS, all fed by 16GB of VRAM that delivers 224 GB/s of memory bandwidth. The card also sports a PCIe 5.0 x8 interface, which Intel credits with speeding transfers from system memory, ultimately delivering 10 to 20% more performance in some scenarios. 

The B50's 16GB of memory outweighs its primary competitors in this segment, which typically come armed with 6 or 8GB of memory. The card also has certified drivers that Intel claims deliver up to 2.6X more performance than the baseline gaming drivers. 

Intel shared a slew of benchmarks against the competing Nvidia RTX A1000 8GB and the previous-gen A50 6GB, but as with all vendor-provided benchmarks, take them with a grain of salt (we included the test notes at the end of the article). In graphics workloads, Intel claims up to a 3.4X advantage over its previous-gen A50, and solid gains across the board against the RTX A1000. It sports similar advantages in a spate of AI inference benchmarks. 

The Intel Arc Pro B60 has 20 Xe cores and 160 XMX engines fed by 24GB of memory that delivers 456 GB/s of bandwidth. The card delivers 197 peak TOPS and fits into a 120 to 200W TBP envelope. This card also comes with a PCIe 5.0 x8 interface.

Intel supports multiple B60 GPUs on a single board, as evidenced by Maxsun's GPU,  with software support in Linux for splitting workloads across both GPUs (each GPU interfaces with the host on its own bifurcated PCIe 5.0 x8 connection). 

Intel's benchmarks again highlighted the advantages of the B60's 24GB of memory vs the competing RTX 200 Ada 16GB and RTX 5060Ti 16GB GPUs, claiming this can impart gains of up to 2.7X over the competition in various AI models. Intel also highlighted the advantages of higher memory capacity in model size, context, and concurrency scaling.

The Intel Arc Pro B60 will primarily come in pre-built inference workstations ranging from $5,000 to $10,000, dubbed Project Battlematrix. The goal is to combine hardware and software to create one cohesive workstation solution. However, the per-unit cost will be in the range of $500 per GPU, depending on the specific model.

Project Battlematrix workstations, powered by Xeon processors, will come with up to eight GPUs, 192GB of total VRAM, and support up to 70B+ parameter models. 

Intel is working to deliver a validated full-stack containerized Linux solution that includes everything needed to deploy a system, including drivers, libraries, tools, and frameworks, that's all performance optimized, allowing customers to hit the ground running with a simple install process. Intel will roll out the new containers in phases as its initiative matures. 

Intel also shared a roadmap of the coming major milestones. The company is currently in the enablement phase, with ISV certification and the first container deployments coming in Q3, eventually progressing to SRIOV, VDI, and manageability software deployment in Q4. 

Intel's partners had multiple Project Battlematrix systems up and running live workloads in the showroom, highlighting that development is already well underway. 

One demo included a system running the full 675B parameter Deepseek model entirely on a single eight-GPU system, with 256 experts running on the CPU and the most frequently used experts running on the GPU. 

Other demos included running and finding bugs in code, an open enterprise platform for building RAGs quickly, and a RAG orchestration demo, among others. 

As noted above, the Intel Arc Pro B50 and Intel Arc Pro B60 will arrive on the market in the third quarter of 2025.

As language models grow in complexity and their context windows expand, GPU-attached high bandwidth memory (HBM) becomes a bottleneck, forcing systems to repeatedly recalculate data that no longer fits in onboard HBM. Pliops has addressed this challenge with its XDP LightningAI device and FusIOnX software, which store precomputed context on fast SSDs and retrieve it instantly when needed, reports Blocks and Files. The company says that its solution enables 'nearly' HBM speeds and can accelerate certain inference workflows by up to eight times.

During inference, language models generate and reference key-value data to manage context and maintain coherence across long sequences. Normally, this information is stored in the GPU's onboard memory, but when the active context becomes too large, older entries are discarded, forcing the system to redo calculations if those entries are needed again, which increases latency and GPU load. To eliminate these redundant operations, Pliops has introduced a new memory tier that is enabled by its XDP LightningAI machine, a PCIe device that manages the movement of key-value data between GPUs and tens of high-performance SSDs.

The card uses a custom-designed XDP ASIC and the FusIOnX software stack to handle read/write operations efficiently and integrates with AI serving frameworks like vLLM and Nvidia Dynamo. The card is GPU agnostic and can support both standalone and multi-GPU server setups. In multi-node deployments, it also handles routing and sharing of cached data across different inference jobs or users, enabling persistent context reuse at scale.

This architecture allows AI inference systems to support longer contexts, higher concurrency, and more efficient resource utilization without scaling GPU hardware. Instead of expanding HBM memory through additional GPUs (keep in mind that the maximum scale-up world size, or the number of GPUs directly connected to each other, is limited), Pliops enables systems to retain more context history at a lower cost, with nearly the same performance, according to the company. As a result, it becomes possible to serve large models with stable latency, even under demanding conditions, while reducing the total cost of ownership for AI infrastructure.

Researchers from Princeton University warn of AI agents with “underexplored security risks” in a recently published paper. Dubbed 'Real AI Agents with Fake Memories: Fatal Context Manipulation Attacks on Web3 Agents,' the paper (h/t Ars Technica) highlights that using AI agents in a financial role can be extremely hazardous to your wealth. This is all because these AI agents remain vulnerable to rather uncomplicated prompt attacks, despite purported safeguards.

While many of us rake over hot gravel to earn a daily wage, in the AI Wild West of 2025 some Web3 savvy folk are using AI agents to do build their fortunes. This includes giving these bots access to crypto wallets, smart contracts, and work with other online financial instruments. Wizened Tom’s Hardware readers will already be shaking their heads about such behavior, and with good reason. The Princeton researchers have demonstrated how to crack open the world of AI agents to redirect financial asset transfers, and more.

Many will be aware of LLM prompt attacks, to get AIs to act in a way that breaks any guardrails in place. A lot of work has been done to harden against this attack vector in recent months.

However, the research paper asserts that “prompt-based defenses are insufficient when adversaries corrupt stored context, achieving significant attack success rates despite the presence of these defenses.” Malicious actors can make the AI hallucinate in a very purposed way by implanting false memories and thus creating fake context.

To demonstrate the dangers in the use of AI agents for action rather than advice, a real world example of AI agents used in the ElizaOS framework is provided by the researchers. The Princeton team provide a thorough breakdown of their ‘Context Manipulation Attack’ and then validate the attack on ElizaOS.

Above, you can see a visual representation of the AI agent attack, showing the flow of unfortunate events which could mean users suffer “potentially devastating losses.” Another worry is that even the state of the art prompt-based defenses fail against Princeton’s memory injection attacks, and these false memories can persist across interactions and platforms...

“The implications of this vulnerability are particularly severe given that ElizaOS agents are designed to interact with multiple users simultaneously, relying on shared contextual inputs from all participants,” explain the researchers. Or we could put it this way: it only takes one bad, unscrupulous apple to rot the whole barrel.

What can be done?

Well, for now, users can hold off entrusting AI agents with (financially) sensitive data and permissions. Moreover, the researchers conclude that a two-pronged strategy of "(1) advancing LLM training methods to improve adversarial robustness, and (2) designing principled memory management systems that enforce strict isolation and integrity guarantees" should provide the first steps forward.

An AIB is reportedly preparing a dual-GPU variant of Intel's rumored Arc B580 24GB, totalling 48GB of VRAM on a single board, via VideoCardz. According to the source, this model is slated to be revealed at Computex 2025, which is just days away at this point. Specific details like the AIB, interconnect technology, and price are in the dark, but we can expect more details at the trade show, if the rumors are true.

This is the third leak that references a 24GB edition of the Arc B580, following EEC filings from Maxsun and an earlier slip-up from Sparkle. It's quite surprising that a GPU that's supposed to rival the RTX 4060 is getting a 24GB memory configuration. Many PCs don't even possess that much system memory. These cards are intended as a cost-effective solution for AI/ML developers, where similar capacity cards from AMD and Nvidia carry a steeper price tag. The most affordable Blackwell GPU with 24GB of memory is the RTX Pro 4000, costing over $1,500 based on preliminary listings.

An AIB is apparently doubling down on this approach by building a dual-GPU solution, housing two of these rumored 24GB B580 GPUs on a single PCB. Keep in mind, this product is reportedly a one-time design from the AIB, not a standard reference model from Intel.

Traditionally, multi-GPU setups nowadays, like Nvidia's B200 and Apple's M1 Ultra, rely on their own advanced interconnect solutions like NVLink and UltraFusion. While Intel does have Xe Link, it likely isn't compatible with the B580 and would be too costly for a one-off project. The most probable contender is a PCIe bridge linking the GPU's interfaces, allowing them to communicate through one slot.

MSI has confirmed it will take the covers off a host of exciting new products at Computex 2025 later this month, including a brand new desktop AI supercomputer powered by Nvidia's DGX Spark platform.

The company confirmed in a press release that it will unveil its EdgeXpert MS-C931, a new desktop AI supercomputer built on the Nvidia DG Spark platform. The MS-C931 is powered by Nvidia's GB10 Grace Blackwell Superchip and is capable of 1,000 AI TOPS FP4 performance. The GB10 SoC features Nvidia Blackwell GPU architecture and fifth-generation Tensor Cores, as well as NVLink-C2C connection to Nvidia's Grace CPU, an Arm architecture core featuring 20 power-efficient chips.

It will also feature ConnectX 7 networking, 128GB unified memory, and LLM support, which Nvidia has previously promised can support up to 4TB of NVMe storage, and can run up to 200-billion-parameter LLMs, or 405-billion parameter models when running two linked chips.

Nvidia's DGX Spark platform promises compact and efficient performance, and comes pre-installed with Nvidia's AI software stack so that developers can run AI models from all the major players, including DeepSeek, Meta, and Google.

Alongside the MS-C931, MSI also says it will unveil a new lineup of Industrial Motherboards, as well as systems powered by Intel Twin Lake, Raptor Lake Refresh, Bartlett Lake, and Arrow Lake processor families.

Specifically, the company highlighted three new products. The MS-C926 is an ultra-slim fanless box PC with applications in smart retail and digital signage.

The Ms-927 is an ultra-compact box PC featuring Intel Core Ultra processors for high-performance edge computing.

Finally, the MS-CF20 is a new next-generation ATX motherboard featuring 16th Gen Intel Arrow Lake-S processors.

MSI says it will also have live demonstrations for solutions for smart retail and digital signage. There will also be a new fanless palm box for "space-constrained industrial environments, remote control management solutions utilizing SysLink, and edge AI innovations, including LLM and chatbot applications enabled by AI smartLink software.

A research team from Carnegie Mellon University built an AI model called LegoGPT that outputs valid LEGO designs from text inputs. According to the team’s research paper that's posted on GitHub, they trained “an autoregressive large language model to predict the next brick to add via next-token prediction,” but the key takeway is that the AI LLM creates LEGO designs from scratch.

The AI was trained on a dataset with more than 47,000 LEGO structures that build over 28,000 unique 3D objects, including bookshelves, tables, chairs, cars, ships, guitars, and more. This was then used to train the AI model, allowing it to create unique and original designs solely from text inputs.

The tool is available for free on GitHub, and you can pair this with a computer vision model or image processing AI. For example, you can take a photo of your available LEGO bricks and let the AI give you a multitude of unique options for building with what you already have.

The team added a validity check and physics-aware rollback during autoregressive inference, ensuring that the final output will always be valid (i.e., no overlapping bricks) and stable (i.e., no floating bricks). Furthermore, LegoGPT’s final output can be built by both humans and robots.

This is how the team created the dataset — StableText2Lego — used to train LegoGPT: a text prompt input is first converted into a ShapeNetCore mesh. This is then plugged into a 20 x 20 x 20 voxel grid from which the initial LEGO brick layout is determined.

This layout is then varied while still keeping the overall shape, and then unstable designs are filtered out from the final output. Those left are then rendered in 24 different viewpoints, and then GPT-4o is used to generate descriptions for the final output.

This is how it creates a new design through text: LegoGPT converts the text into a LEGO design, which is then converted into text tokens ordered from bottom to top. Instructions are then created to pair the structured LEGO bricks with annotations explaining the design, so that the AI will understand the relationships between the text prompt and the physical bricks.

From there, LegoGPT predicts the next brick needed to build the design using an autoregressive model. That means it will verify a brick’s validity at each step, checking if it is well-formatted, exists in the library, and does not overlap with existing bricks. This will continue until the design is completed, after which its stability is tested.

If the AI determines that the output is unstable, it will roll back to the last stable state and continue generating from that point. Once it gets a stable final output, then the design is complete.

The RTX 5090 is not only good for gaming and AI — it also excels at password cracking. Hive Systems updated its password cracking benchmark suite with 12 RTX 5090 graphics cards — Nvidia's fastest and best graphics card for gaming currently, and found all twelve cards working together can break simple eight-character passwords in under 15 minutes.

Hive Systems is in its 5th year of benchmarking password cracking times on GPUs; the last update they made was in 2024, featuring the RTX 4090. Rather than cracking an actual password itself, the outlet cracks hashes, which are scrambled versions of reproducible text generated by software.

Hashes are a popular method for securing customer passwords against hackers by storing customer passwords as hashes on servers. When hackers go to steal a password database from a company's server that is secured with hashing, all they will see are hashes of the passwords they represent rather than the actual passwords themselves.

Cracking passwords with this method involves making a list of all possible combinations of characters to make a password, then matching them to a stolen database featuring password hashes. Graphics cards are particularly good at this methodology due to highly parallelized computing capabilities.

With 12 RTX 5090s, Hive Systems found Nvidia's latest flagship can crack the hash equivalent of eight-character passwords featuring numbers only in just 15 minutes. Passwords comprised of eight lower-case letters, the dozen RTX 5090s were able to crack in 3 weeks.

On the other end of the spectrum, passwords taking advantage of numbers, upper and lowercase letters would take 12 RTX 5090s 62 years to crack, and 164 years to crack with symbols added into the mix.

For a generation-on-generation perspective, a single RTX 5090 can crack a numerical-only password hash with eight characters in three hours. A single RTX 4090 can accomplish the same task in four hours, representing a 33% performance improvement for the RTX 5090 over the RTX 4090 in this specific scenario.

However, as the password complexity increases, the RTX 5090 becomes faster and faster in comparison. Moving up to a hash representing an eight-character password made up of numbers, upper and lowercase letters combined with symbols, the RTX 5090 is allegedly twice as fast as the RTX 4090. But cracking a password that complex would take the RTX 5090 a millennium to accomplish.

Hive Systems' research demonstrates the dangers of low complexity passwords and how adding just a bit of complexity in the form of symbols, capitalized letters, and numbers can make a huge difference for security. The good news is that cracking hashes in the way Hive Systems demonstrates requires hackers to have a stolen database of password hashes in the first place. Without this, hackers can't brute-force hack password hashes.

If you’re old enough to remember when 8MB thumb drives hit the scene, you’ll probably remember Clippy, Microsoft’s digital writing assistant. Clippy lived in the bottom corner of Microsoft Office from 1996 to 2003, but now he can return to your desktop with a new life as a mouthpiece for AI, thanks to a new project from software engineer ‪Felix Rieseberg.

This odd couple of 90’s UI design and the modern-day AI craze provides potential users the ability to set up any locally installed LLM and use Clippy as its mouthpiece. Many of the most popular publicly-available LLMs will function with Clippy, with one-click installation supported for the newest from Google, Meta, Microsoft, and Qwen. Clippy’s original art and animations are joined by a Windows 98-styled chat and settings window.

On installation, Clippy silently cycles through animations while the program automatically downloads Google’s Gemma3-1B model. Once paired with an LLM, the Clippy-bot approximates the original Clippy’s tone thanks to a lengthy prompt instruction that seeks to disguise the model in use. Users are able to edit or replace this starting prompt to get their most Clippy-esque experience (or to give your Clippy more of his highly-memed snark).

Rieseberg, creator of new Clippy, refers to the program as "a love letter and homage to the late, great Clippy," as well as Microsoft’s 90s visual aesthetic. He calls the app a piece of "software art," or, if you don’t like it, "software satire." There is certainly something to be said about the relationship between an artist and programmer designing a quirky writing aide character, and a chatbot later told to attempt to emulate that work — though the list of people waxing philosophical about Clippy likely doesn’t extend far beyond this author.

We’ve seen Clippy replacements before, but this new-and-improved paperclip doesn’t require access to a paid tier of ChatGPT, nor does it seek to modernize Clippy’s look to match Windows’ newer design sensibilities. This is the Clippy you know and love (?): a more 90’s-looking blend of old and new computing sensibilities.

The Clippy Desktop Assistant is available for download for Windows, Mac, and Linux via the project’s website, with a deeper look behind the curtain available on Github. While it's not likely to revolutionize any desktop workflows, this new Clippy stands at the ready for those happy few with one foot in the vector-graphics of the 90s... and the other in the AI-present.

Software engineer Sven Scharmentke (AKA Svnscha) has shared a project that they say "might change crash dump analysis forever." The new contextual natural language conversational tool contrasts sharply with manually typing arcane commands into a terminal to analyze crash data, which is the established modus operandi of a professional software engineer, even in 2025. Svnscha goes on to assert that the new open-source tool, available as mcp-windbg on GitHub, can go deep. The AI runs a "simply amazing" array of WinDBG/CDB commands, boosting productivity and eradicating a once tedious task.

AI peddlers have developed large language models that initially targeted creative writing and have since moved to visual arts – graduating from hand-drawn style art and photorealistic creations to videos in recent times. AI has also made significant inroads into computer programming. However, most people want AI to leave the fun, creative stuff to humans and take the sting out of dull, soul-crushing, repetitive tasks. This seems to be where Svnscha's mcp-windbg might actually succeed.

In brief, the mcp-windbg tool enables AIs to interact with Microsoft's multipurpose debugger WinDBG. Its cunning skill is in giving LLMs the ability to execute debugger commands. And, even if you have swallowed the WinDBG manual, this AI will likely know debugger commands better than you. Copilot will probably also interpret assembly code, decode hexadecimal, traverse structures with symbols, and perform other tasks much better than you. You just have to ask the right questions.

Background and demos

Svnscha goes into some detail about their prior frustration in debugging crashes, the lightbulb moment to involve AI, and how the mcp-windbg tool works, all in a dedicated blog post. The software engineer humbly admits the 'hard part" of this work was implementing the CDB (Microsoft's Command-Line Console Debugger) interaction layer, and this was done during a session "vibe-coding with two coffees on a Saturday morning."

However, the videos shared help encapsulate the leveraging of Copilot with CDB. There are two to watch on the linked blog, starting with a Crash Analysis and Automated Bugfix using Copilot, followed by an Automated Crash Dump Analysis of Multiple Crash Dump Files.

What you first see shows Svnscha installing mcp-windbg, then running a Windows app that crashes. Next, GitHub Copilot is fired up and asked to find the crash dump and fix the underlying code issue. "The AI quickly identifies that the application crashed, explains which specific conditions led to the crash, and suggests a fix," says Svnscha.

The second video is similar but shows the tool analyzing multiple files simultaneously.

'Simple wrapper' lifts crash analysis from the stone age to the rocket age

Established in 2003, SilverStone Technology has earned a solid reputation for producing high-performance PC hardware and accessories, with a particular focus on power supply units (PSUs), cases, and cooling solutions. Over the years, SilverStone has been recognized for balancing innovation, efficiency, and compact design, catering to a wide range of users, from gamers to professionals.

This review will delve into the latest revision of Hela 850R Platinum, SilverStone's latest series update to meet the ATX 3.1 certification, and determine if it deserves a place in our list of best power supplies. Rated at 850W and certified with the 80Plus Platinum standard, this PSU aims to provide exceptional efficiency and reliability for demanding systems. The first version of the Hela 850R Platinum was one of the first ATX 3.0 units to hit the market, and as we will see in this review, the changes with the new version are much more than just minor changes.

Specifications and Design

In the Box

We received the SilverStone Hela 850R Platinum in robust packaging with a distinctive blue and yellow theme. The PSU itself is encased in a protective nylon pouch and secured by foam inserts to prevent damage during transit.

SilverStone provides a modest bundle that includes just the essentials: mounting screws, an AC power cable, a few cable ties, and three standard cable straps. While the accessory pack is nearly minimal, it covers everything required for installation and basic cable management.

The Hela 850R Platinum features all-black cables that are flat and ribbon-like, without any exterior sleeving. The cabling includes a 12V-2x6 connector and four 6+2 pin PCI Express connectors, ensuring compatibility with modern high-powered components. Given the unit's power output, the number of connectors is more than sufficient.

External Appearance

Aesthetically, SilverStone kept the design simple, opting for a satin black chassis that resists fingerprints and offers a clean, professional look. Measuring 140mm in length, the unit adheres to the ATX design recommendation, ensuring broad compatibility with most cases.

The fan grille is integrated into the chassis, showcasing a unique design pattern that adds a subtle visual touch. The right and left sides of the PSU feature SilverStone's branding stickers, maintaining a minimalist appearance.

At the rear, one will find the AC receptacle, power switch, and a button to toggle hybrid fan mode, which allows the fan to remain off under low loads for silent operation. The modular cable connectors are located at the front, with a subtle legend printed nearby for easy identification.

Internal Design

Cooling is managed by a Globe S1202512HP-4M 120 mm fan with a fluid dynamic bearing (FDB) engine, balancing longevity with quiet operation. SilverStone had to use an 120 mm fan as a 135 mm model does not fit in such a small chassis. It is not the highest quality fan but it is acceptable. The fan remains off at low loads, activating only when necessary, reducing noise and enhancing lifespan.

Enhance Electronics serves as the OEM for the Hela 850R Platinum, introducing a new platform distinct from its predecessor. The internal layout is reminiscent of older designs, with green PCB coloring and simplistic heatsinks, and a quick glance could fool even an expert. A closer look, however, reveals exceptional quality parts and modern topologies.

The filtering stage is well-implemented, consisting of four Y capacitors, two X capacitors, and two inductors to suppress noise and interference. The Active Power Factor Correction (APFC) stage utilizes two Oriental Semi OSG55R140F MOSFETs and a diode, supported by a large inductor and a Nippon Chemi-Con 680 μF capacitor.

On the primary side of the main transformer, two Oriental Semi OSG55R140F MOSFETs form the primary inversion side, operating under a simple half-bridge LLC topology. All primary-side active components are mounted on the same heatsink, which feels undersized given the unit's wattage.

The secondary side employs eight IPS 014N04SA MOSFETs to generate the main 12V rail directly from the transformer. The 3.3V and 5V rails are derived through DC-to-DC converters mounted on a vertical daughterboard. Secondary side capacitors are a mix of Rubycon and Unicon products, both reputable brands known for their reliability. Overall, the Hela 850R Platinum's internal design is straightforward, relying on quality components but lacking advanced cooling measures.

Cold Test Results

Cold Test Results (25°C Ambient)

For the testing of PSUs, we are using high precision electronic loads with a maximum power draw of 2700 Watts, a Rigol DS5042M 40 MHz oscilloscope, an Extech 380803 power analyzer, two high precision UNI-T UT-325 digital thermometers, an Extech HD600 SPL meter, a self-designed hotbox and various other bits and parts.

During cold testing, the SilverStone Hela 850R Platinum does meet the CLEAResult 80Plus Platinum certification requirements with an input voltage of 115 VAC. The PSU does not have a Cybenetics efficiency certification at the time of this review. It achieves an average nominal load efficiency of 91% with an input voltage of 115 VAC, which rises to 92.2% under a 230 VAC supply. The efficiency peaks at around 50% load and remains fairly robust throughout the nominal load range (10–100%), while efficiency at very low loads is acceptable.

The Globe 120 mm fan remains inactive until the load surpasses 300 watts. It operates fairly quietly up to approximately 600 watts before increasing speed in noticeable steps, ensuring effective thermal management without ever reaching maximum speed at full load under room-temperature conditions. The Hela 850R will be noticeable if heavily loaded for prolonged periods of time but noise figures are reasonable and likely far lower than those of the PC’s other cooling systems.

Hot Test Results

Hot Test Results (~45°C Ambient)

Under elevated ambient temperatures, the Hela 850R Platinum exhibits a measurable decline in performance, with the average nominal load efficiency dropping to 89.6% at 115 VAC and 90.7% at 230 VAC. This reduction of about 1.4% in hotter conditions was a bit higher than we typically expect, yet the unit continues to perform within acceptable limits without significant thermal stress.

In these warmer conditions, the fan activates only marginally earlier compared to cold tests but accelerates far more rapidly with increasing load, reaching its top speed when the load is approximately 700 watts. Although the fan becomes noticeably loud under sustained heavy loads, internal temperatures rise significantly, still, these remain within safe operating boundaries and do not trigger the Over Temperature Protection (OTP).

PSU Quality and Bottom Line

Power Supply Quality

The SilverStone Hela 850R Platinum demonstrates commendable electrical performance and power quality. Voltage ripple is well contained, with the 12V rail showing a maximum ripple of 36 mV, and the 5V and 3.3V rails registering a maximum of 22 mV and 20 mV, respectively. Voltage regulation is excellent, at 0.6% for the 12V rail, 1.2% for the 5V rail, and approximately 1% for the 3.3V rail.

During our thorough assessment, we evaluate the essential protection features of every power supply unit we review, including Over Current Protection (OCP), Over Voltage Protection (OVP), Over Power Protection (OPP), and Short Circuit Protection (SCP). All protection mechanisms were activated and functioned correctly during testing.

The OCP is set to activate at 146% for the 3.3V rail, 150% for the 5V rail, and 128% for the 12V rail, with an OPP threshold of 132%. While these thresholds are on the higher side, they are acceptable for an ATX 3.1 compliant unit.

Bottom Line

SilverStone Technology has long been regarded as a reputable manufacturer of PC hardware, known for its emphasis on quality, performance, and compact design. The Hela 850R Platinum represents SilverStone's latest effort to stay at the forefront of PSU design by embracing the ATX 3.1 standard while maintaining the Platinum efficiency rating. Even though most manufacturers made very minor changes (if any at all) to switch their units from ATX 3.0 to ATX 3.1, SilverStone revamped the unit completely, changing even the OEM of the unit itself. The Hela 850R Platinum is a product aimed at demanding users — such as gamers, content creators, and professionals running high-performance systems — promising solid power delivery and broad compatibility with modern components. However, with a retail price of around $200, it enters a highly competitive market segment, where expectations are as high as the price tag.

In terms of performance, the Hela 850R Platinum excels during cold testing, where it easily meets its 80Plus Platinum certification benchmarks with an input voltage of 115 VAC. At an ambient temperature of 25°C, the unit achieves an impressive nominal load efficiency of 91% at 115 VAC, which further improves to 92.2% under a 230 VAC input. These efficiency figures peak at approximately 50% load and remain stable throughout the nominal load range from 10% to 100%. The Globe 120 mm fan operates in a zero-RPM mode until the load exceeds 300 watts, ensuring quiet operation during moderate workloads and efficient thermal management without sacrificing performance.

However, the unit's performance under elevated temperatures presents a more nuanced picture. During hot testing at around 45°C ambient, the Hela 850R Platinum experiences a modest decline in efficiency, with figures dropping to 89.6% at 115 VAC and 90.7% at 230 VAC - a significant reduction of roughly 1.4%. Although this decrease is within acceptable limits, even if only barely, the response of the cooling system under these conditions is notable. The fan, which remains largely inactive during light loads, accelerates more rapidly in warmer conditions and reaches its maximum speed at approximately 700 watts. While this ensures that internal temperatures are kept in check, the resulting noise can be somewhat intrusive under sustained heavy loads. Despite this, the PSU’s electrical performance remains robust, with exemplary power quality delivery.

In conclusion, the SilverStone Hela 850R Platinum stands out as a high-quality power supply unit that delivers exceptional efficiency, strong performance, and reliable protection features. The unit’s compact 140mm form factor, full modularity, and ATX 3.1 compliance make it well-suited for powerful builds. However, at a retail price of approximately $200, the unit faces stiff competition from other PSU offerings in the same category. While its performance merits and premium features justify the cost to some extent, potential buyers must consider whether the investment aligns with their budget and needs in a highly competitive market.

MORE: Best Power Supplies

MORE: How We Test Power Supplies

MORE: All Power Supply Content

Microsoft CEO Satya Nadella revealed that the company now uses Artificial Intelligence to write between 20% and 30% of the code powering its software. Satya joined Meta CEO Mark Zuckerberg this Tuesday at the LlamaCon conference to discuss developments in AI and their contributions to the open-source ecosystem. The fact that a major company like Microsoft relies so much on AI underlines how this technology is revolutionizing software development. Still, it also draws attention to the growing unease and uncertainty experienced by fresh software developers.

Almost every company uses Artificial Intelligence to a certain extent. At its Q3 financials last year, Sundar Pichai revealed that 25% of new code at Google is AI-generated. As it stands, AI is mostly there to power repetitive, data-heavy, and predictable tasks, which would yield a noticeable gain to corporate efficiency by cutting down on entry-level jobs. While it is true that AI-generated code has improved significantly over the recent years, it still requires senior developer oversight to ensure the production environment doesn't go haywire.

Mark and Satya spent part of their discussion detailing each company's AI adoption scale. AI generates one-third of the code in Microsoft's repositories and projects. The Meta CEO didn't provide an exact figure, but did outline plans for a future AI model to build and create future iterations of their Llama AI models. Although using AI to design AI might sound counterintuitive, there's an entire dedicated field that focuses on automating this design process, called AutoML.

RTX 5060 Ti 16GB vs RTX 4060 Ti 16GB Introduction

The Nvidia GeForce RTX 5060 Ti 16GB and RTX 4060 Ti 16GB represent the new and old guards of the 16GB realm for Team Green. Both of these are mainstream GPU offerings, ostensibly priced in the $430–$500 range. We weren't particularly impressed with the 4060 Ti 16GB at launch, but our feelings have tempered over time — helped by an unofficial $50 price cut — with both having appeared on our list of the best graphics cards.

The Nvidia Ada Lovelace 4060 Ti 16GB card originally launched over a month after the initial RTX 4060 Ti 8GB card, with a $100 price premium. Throughout the ensuing two years, the 8GB card has been more readily available, though as noted already, street prices on the 16GB card did drop by $50 at times. 

Conversely, the RTX 5060 Ti 16GB and 8GB variants technically launched at the same time on April 16, 2025, with only a $50 price gap. So far, the 16GB models have been far more widespread in the U.S., to the point where we have not yet been able to purchase an 8GB card at retail for testing.

Given the ongoing concerns with having only 8GB of VRAM, we feel it makes the most sense to compare the new and old 16GB xx60 Ti cards. We'll look primarily at performance, as well as power, features, and pricing. In theory, this should be a very easy win for the new Nvidia Blackwell GPU, but let's see how they actually stack up.

RTX 5060 Ti 16GB vs RTX 4060 Ti 16GB Specifications

Specifications for the RTX 5060 Ti 16GB and RTX 4060 Ti 16GB are mostly similar, with a few key upgrades for the newer GPU. While both the GB206 and AD106 dies have a maximum of 36 SMs (Streaming Multiprocessors), the 5060 Ti uses the fully enabled chip while the 4060 Ti disables a pair of SMs. That cascades through the GPU shaders, tensor cores, RT cores, and TMUs, giving the 5060 Ti a theoretical 6% advantage. However, clock speeds also factor into performance, and the 5060 Ti comes with a 2,572 MHz boost clock compared to 2,535 MHz on the 4060 Ti, another 1.5% advantage.

The core counts are a "hard" spec, but the clock speeds are a bit fuzzy. Power limits also come into play, and the 5060 Ti has a 180W TGP compared to 165W on the 4060 Ti 16GB. In practice, across our 21-game test suite, the 5060 Ti 16GB averaged clock speeds of 2,776 MHz compared to 2,725 MHz on the 4060 Ti 16GB — a slightly larger 1.9% advantage in favor of the newer card. Combined with SM and core counts, that gives the 5060 Ti 16GB an 8% advantage in raw compute.

That's pretty negligible in terms of a gen-on-gen increase, but architectural updates can further impact the real-world performance. More pertinent than the raw compute is the memory subsystem. The RTX 5060 Ti 16GB has 28 Gbps GDDR7 memory while the RTX 4060 Ti 16GB has 18 Gbps GDDR6 memory. That means the newer part has a 56% advantage in raw memory bandwidth — though architecture and timings can still play a role.

Taken together, based on the specifications, you should expect to see the newer GPU outperform its predecessor by anywhere from 8% to 56%, depending on whether a particular game or workload relies more on raw compute, memory bandwidth, or a blend of the two. In practice, compute tends to be the more important metric. As such, we'd expect a 15~25 percent lead from the 5060 Ti. Let's see how things go in actual benchmarks.

RTX 5060 Ti 16GB vs RTX 4060 Ti 16GB Gaming Performance

For most people, gaming performance will be the most important factor in choosing a graphics card. We have a test suite of 21 games, 6 of which have ray tracing enabled and 15 with pure rasterization. Upscaling and frame generation are disabled for all these tests, as we view those as "performance enhancers" rather than baseline features that should be compared.

Both the RTX 5060 Ti 16GB and RTX 4060 Ti 16GB support Nvidia's various DLSS features, though the 5060 Ti also offers MFG (Multi Frame Generation) — which can smooth out performance but definitely doesn't improve the actual feel of games that support it as much as the numbers might suggest. The experience of DLSS 3 framegen in our view tends to be inflated by about 50–60 percent (meaning, divide the resulting number by 1.5–1.6 to get a realistic view of what it feels like), while MFG 4X is about a 170–200 percent inflation (divide by 2.7–3.0).

Those are fuzzy approximations, but basically if you get less than a 50% "increase" in framerates via framegen, we would argue that it actually feels like a step backward. Likewise, less than a 170% increase from MFG 4X would be a net loss. Or to put hard numbers on it, if the base performance is 60 FPS, framegen needs to run at 90 FPS or more and MFG 4X needs to run at 160 FPS or more. Some would argue even those figures are too generous, but our main point is that "FPS" inflation via frame generation techniques has been heavily abused as a true indication of performance.

The charts and tables provide all the important numbers, so we're not going to dig into every single result. We're mostly interested in the overall trends, recognizing that individual games can come in above or below the averages. That's why we have an extensive 21 game test suite, with equal weighting given to each result via a geometric mean calculation.

The nice thing about comparing two Nvidia GPUs, even though they're different architectures, is that relative performance ends up being pretty consistent across both rasterization and ray tracing games. AMD and Intel GPUs vary quite a bit more, depending on what specific games are used.

Overall, the 5060 Ti 16GB outperforms the RTX 4060 Ti 16GB by 16% at 1080p medium, 17% in the ray tracing suite, and 16% in the rasterization suite. That means the 5060 Ti and 4060 Ti generally aren't CPU limited, even at 1080p medium. The minimum FPS (1% lows) shows similar consistency. Looking at the individual games, the 5060 Ti 16GB leads by 6% (Assassin's Creed Mirage) to as much as 29% (A Plague Tale: Requiem).

Bumping up to 1080p ultra settings, most of the deltas are virtually unchanged. The 5060 Ti 16GB still leads by 16% overall, 17% in the ray tracing suite, and 16% in the rasterization games. Minimum FPS ends up slightly closer overall at 18%, but with a wider 23% spread in our ray tracing tests and 16% in the rasterization games. Across all 21 games, we measured an 8% (Starfield) to 26% (Plague Tale: Requiem and Space Marine 2) delta in favor of the 5060 Ti.

Given the memory bandwidth advantage, the 5060 Ti 16GB should increase its overall lead at higher resolutions, and it does — just not by much. It's 18% faster overall at 1440p ultra, and 18% in both the rasterization and ray tracing suites. The various games show an advantage of 9% (Starfield) to 29% (Plague Tale and Space Marine 2, again).

Finally, at 4K ultra, we see the biggest lead for the 5060 Ti 16GB. Across the full 21-game suite it's 21% faster than the 4060 Ti 16GB, with a 20% lead in the ray tracing games and a 22% lead in the rasterization tests. The smallest advantage improves to 12% (Avatar), with the biggest lead being 33% (Space Marine 2).

RTX 5060 Ti 16GB vs RTX 4060 Ti 16GB AI and Content Creation Performance

Looking at other potential workloads, we have various disciplines that all loosely fall under the content creation umbrella. AI workloads include Stable Diffusion image generation, LLaMa text generation, image classification, inference, and other tasks. We also have 3D rendering via Blender, video transcoding using SPEC Workstation 4.0, and the Viewport test suite from SPEC Workstation 4.0.

Many people — particularly gamers — may never do any of these tasks on their PC, though it's worth nothing that Nvidia's push for "neural rendering" techniques can also extend into AI-powered NPCs. That's not something we can directly benchmark at present, but there's potential for the AI performance to become more important in the coming years if AI NPCs catch on in some major games.

Of all the content creation tasks, we think the AI tests deserve the most attention. As noted above, such workloads could become a bigger part of how people use their PCs and graphics cards in the future, even within games. Overall, the 5060 Ti 16GB delivers about a 24% lead in AI workloads compared to the RTX 4060 Ti 16GB. It's also worth mentioning that none of these AI tests at present leverage the FP4 support that was added to the tensor cores in the Blackwell architecture, so there's potential for even more of an AI deficit if future applications make use of that number format.

Video transcoding ends up being a virtual tie, indicating there's not a huge difference between the NVENC/NVDEC blocks in Ada and Blackwell. The 5060 Ti takes a 4% lead by virtue of running at slightly higher clock speeds, though Nvidia did supposedly improve the encoding quality — that's not something these tests measure, unfortunately.

3D modeling using Blender basically matches what we saw in gaming performance. Overall, the 5060 Ti 16GB runs 20% faster than the 4060 Ti 16GB, with a spread of 14% to 29% in the three different scenes. SolidWorks agrees with that number, while 3ds Max shows an even larger 31% lead for the 5060 Ti.

Those last two are part of the SPEC Workstation 4.0 Viewport tests, which show a 17% lead overall for the 5060 Ti, with a range of 1% (Creo) to as much as 31% (3ds Max). Most of the SPEC Workstation tests are truly for professionals, however, so we wouldn't put too much weight on them. Most paid professionals will have a workstation equipped with a workstation GPU (e.g. Nvidia RTX 6000 Ada Generation or the new RTX Pro 6000 Blackwell).

RTX 5060 Ti 16GB vs RTX 4060 Ti 16GB Features and Software

The vast majority of Nvidia features and software tools are available on both the RTX 4060 Ti 16GB and the RTX 5060 Ti 16GB. As such, it's easy to think that the two are "tied" in features. However, there are a few noteworthy exceptions.

First, the Blackwell RTX architecture adds support for Multi Frame Generation. We don't love the way the numbers are used to indicate massive performance improvements (i.e. Nvidia CEO Jensen Huang tried to claim that an "RTX 5070 is as far as an RTX 4090" at the launch event), but MFG isn't inherently bad. There are games where it works better, and the additional frame smoothing can make games feel better, subjectively. It's a nuanced discussion, in other words, and not the "fake frames BAD" mentality that often gets tossed around.

Blackwell RTX, and by extension the RTX 5060 Ti 16GB, is also supposed to have better support for so-called neural rendering (i.e. Microsoft's Cooperative Vectors API). We don't yet know precisely how much better it might be compared to older GPUs, but we do know Cooperative Vectors is supposed to work with all RTX GPUs — and that it's supposed to be better on Blackwell RTX.

As noted earlier, the RTX 5060 Ti also has support for FP4 (and FP6) numerical formats in its tensor cores. Making proper use of FP4 presents challenges for AI models, but various algorithms have demonstrated superior performance and reduced memory requirements with a "negligible" drop in overall inference quality. As AI continues to evolve, it's reasonable to expect the use of FP4 to become more commonplace.

We've seen that with FP8 support as well. First introduced with the RTX 40-series GPUs, the use of FP8 modes was relatively rare for most of the past 2.5 years. However, Nvidia's new DLSS Transformers algorithms for upscaling (super resolution) and ray reconstruction appear to leverage native FP8 support. It's why the performance hit for DLSS Transformers tends to be substantially lower on RTX 40- and 50-series GPUs compared to RTX 30- and 20-series GPUs.

But Nvidia giveth and Nvidia also taketh away. Blackwell graphics cards no longer have PhysX support, so the RTX 5060 Ti 16GB simply can't run PhysX in older games that used the feature. (Not many recent games have used GPU PhysX, so this mostly applies to games like the Batman: Arkham series and Mirror's Edge, all of which are at least 10 years old now.) 32-bit CUDA support was likewise retired, which again mostly impacts older apps that are no longer being actively updated.

RTX 5060 Ti 16GB vs RTX 4060 Ti 16GB Pricing

The RTX 4060 Ti 16GB launched in July 2023 with an MSRP of $499, $100 more than the 8GB variant. The RTX 5060 Ti 16GB came out in April 2025 with a $429 MSRP. On paper, that clearly suggests a pricing advantage for the 5060 Ti 16GB. In practice, it's also an advantage when shopping around for new cards, but that's because the 4060 Ti 16GB (and the rest of the RTX 40-series) has been retired.

Since both GPU lines are made using TSMC's 4N process node, there's no reason for Nvidia to continue producing the older chips, and in fact all indications are that wafer orders for Ada Lovelace may have ended in the fall of 2024. Supplies have completely dried up and prices have shot up as a result.

The availability of RTX 50-series GPUs has been relatively poor compared to what we saw with the 40-series launch. Sure, the RTX 4090 sold out for the first few months, but eventually it reached the point where you could expect to find some models selling slightly below the base MSRP, and all of the other 40-series GPUs eventually dropped below the base MSRP by late 2023 and early 2024. So far, the RTX 50-series has rarely even approached MSRP, often selling at 20% to 50% above the minimum suggested price.

At present, the least expensive RTX 5060 Ti 16GB card we can find is an Asus Dual RTX 5060 Ti 16GB for $492.98 at Newegg. That's about 15% above the base MSRP that Nvidia set, but Nvidia can't force its add-in board (AIB) partners to actually sell cards at MSRP. With ongoing GPU shortages, it's little surprise that nearly all 50-series GPUs are "overpriced" relative to MSRP.

As bad as that might seem, the RTX 4060 Ti 16GB is in an even worse state. With production of those GPUs likely halted last year, only limited supplies remain. Mostly, it's third-party marketplace resellers on Newegg, Amazon, and similar storefronts trying to make some serious money. Even the 8GB cards start at $575 (MSRP is supposed to be $400), while the cheapest RTX 4060 Ti 16GB costs $679. Yeah, that's a bad choice unless for some reason you specifically need the older hardware.

RTX 5060 Ti 16GB vs RTX 4060 Ti 16GB Final Verdict

This was pretty much a foregone conclusion, but the RTX 5060 Ti 16GB easily beats the RTX 4060 Ti 16GB in every conceivable metric. There's only one potential advantage to the 4060 Ti, and it's nebulous at best: It supports PhysX and 32-bit CUDA (though both are likely deprecated and will fade away in the coming months).

In contrast, the 5060 Ti 16GB offers about 20% higher gaming performance on average, across nearly all tested resolutions and settings. It's also about 20% faster in AI workloads and 3D rendering, and about 17% faster in a selections of professional applications. That's largely thanks to having 56% more memory bandwidth, courtesy of GDDR7, though other architectural upgrades and slightly increased core counts also factor into things.

The real kicker is the price. Unless you're lucky enough to find an RTX 4060 Ti 16GB on a steep discount, the 5060 Ti 16GB costs quite a bit less at popular online retail sites like Newegg and Amazon. Just say no, in other words. Slower performance, missing new features, and a price that's currently 38% higher? Pass. It's also a poor proposition when you look at total system cost (using $750 for the price of the rest of the PC). The 5060 Ti 16GB delivers 24% more performance per dollar than the RTX 4060 Ti 16GB in that case (using MSRPs for both, which benefits the 4060 Ti).

If you're wondering about power use and efficiency, even though the TGP (Total Graphics Power) on the 5060 Ti 16GB is 15W higher on paper, in practice it averaged lower power use in our testing. Power use was 1W higher at 4K ultra (a setting both GPUs struggle with), 5W lower at 1440p ultra, and 8–9 watts lower at 1080p. With 21% higher performance at 4K, that works out to much improved overall efficiency.

Hopefully it goes without saying, but just because the RTX 5060 Ti 16GB offers more performance and costs less than a new 4060 Ti 16GB, that doesn't mean people who already own the prior generation card should be in a rush to upgrade. A 20% performance uplift combined with a few new features might be nice to have, but we generally only recommend upgrading if you can get at least a 50% performance improvement, and doubling performance is often possible if you're upgrading from a card that's a couple of generations old.

Let's also not forget that there are 8GB variants of both GPUs. Again, just say no to such cards. Unless you can score a particularly impressive deal, the lack of VRAM is increasingly becoming a problem for 8GB cards. Sure, older and lighter games can run just fine on such GPUs, but it's the newer games that need faster hardware, and they're having problems. The 4060 Ti 16GB and 8GB offer nearly identical performance in our test suite at 1080p, but the 16GB card pulls ahead by 7% at 1440p, and by 36% at 4K — with the most demanding newer games exceeding those averages. We anticipate the story will be largely the same with the 5060 Ti 8GB.

So there you have it: While the generational gains of the RTX 5060 Ti 16GB over the RTX 4060 Ti 16GB aren't as large as we've seen with prior architectural upgrades, the lack of progress on process nodes and the relatively similar die sizes and transistor counts mean we shouldn't expect 50% performance improvements at the same price going forward. 20% more performance for an ostensibly 14% lower price is about as good as we're likely to see. That's about 40% more performance per dollar, which beats any of the other RTX 50-series GPUs.

RTX 5070 vs RTX 5060 Ti Introduction

The Nvidia GeForce RTX 5070 and RTX 5060 Ti 16GB are the two most recent GPUs launched by Team Green. Since the beginning of 2025, Nvidia has released five Blackwell RTX 50-series GPUs — six if you want to count the RTX 5060 Ti 8GB as a separate entry.

To say that supplies have been limited and insufficient to keep up with demand would be a gross understatement, but the same applies to any of the best graphics cards right now. In fact, of all the Blackwell RTX GPUs, the 5070 and 5060 Ti are currently the most readily available; just don't expect to find most models at MSRP.

Our GPU benchmarks hierarchy ranks all the graphics cards by performance, and naturally the more expensive cards come out ahead of their less expensive siblings. But how do the RTX 5070 and RTX 5060 Ti 16GB stack up? We'll look at the performance, approximate pricing — because no GPU prices are reliably set in stone right now — as well as other aspects of the cards to help you decide which one might be right for your gaming PC.

Most of the features between the two GPUs will be identical. Both use the Blackwell architecture and support DLSS 4 and MFG, for example. Still, let's start with the specifications to see how the 5070 and 5060 Ti stack up.

RTX 5070 vs RTX 5060 Ti Specifications

As you'd expect, the RTX 5070 offers more raw performance on paper and in practice. It uses a GPU that's 45% larger, with 41.6% more transistors. More importantly perhaps, it has 33% more SMs, tensor cores, RT cores, and related computational units. It also has 50% more memory bandwidth and a 50% wider memory interface, plus 50% more L2 cache.

Memory interfaces don't scale as well as core logic on modern process nodes, and there are other aspects of the Blackwell GPU — the video encoders/decoders, display outputs, etc. — that don't really change, which explains why the chip size and transistor counts don't necessarily scale linearly.

Clock speeds aren't quite the same, at least on paper. The 5060 Ti has a 2572 MHz boost clock and the 5070 has a slightly lower 2512 MHz boost clock. But we're also looking at the 5070 Founders Edition with reference clocks, and a PNY 5060 Ti 16GB OC that has a 2692 MHz boost clock. Plugging in those numbers gives the 5070 30.9 teraflops of FP32 compute and the PNY 5060 Ti has 24.8 TFLOPS. That means the 5070 'only' has 25% more compute on paper — which isn't actually all that accurate.

In our full suite of gaming benchmarks, the 5070 Founders Edition averaged clock speeds of 2826 MHz while the PNY 5060 Ti 16GB OC averaged 2776 MHz. That means despite theoretically 180 MHz lower clocks, in practice Nvidia's 5070 card came out 50 MHz ahead.

That means the 5070 FE offers about 34.7 TFLOPS compared to 25.6 TFLOPS, a 35.5% advantage. Practically speaking, though, the 5070 should be up to 35% faster in games that are compute bound, and up to 50% faster for games that are memory bandwidth bound — and potentially the 5060 Ti could close the gap if VRAM capacity comes into play.

RTX 5070 vs RTX 5060 Ti Gaming Performance

There are multiple facets of performance to discuss. We'll start with gaming performance, as that's what the majority of people looking at the RTX 5070 and RTX 5060 Ti 16GB care about the most. We have an expanded test suite of 21 games, with 15 rasterization benchmarks and six ray tracing benchmarks — slightly more than the 18 games we use in our GPU hierarchy (we're planning to add these into the hierarchy but haven't tested every GPU yet).

The charts group things together by overall performance (geometric mean across all 21 games, where each gets equal weighting), rasterization-only performance, and ray tracing-only performance. We also have separate tables that show the percentage differences below the charts (sorted in reverse order due to the vagaries of Excel).

It's safe to say that neither the RTX 5070 nor the RTX 5060 Ti 16GB are primarily targeted at native 4K ultra gaming. The 1440p result works as a proxy for 4K with DLSS quality mode upscaling, and the 1080p result stands in for 4K with performance mode upscaling, though there would be potential differences. Upscaling does have some overhead, but since we're looking at two Nvidia GPUs we can expect a pretty consistent delta cause by DLSS. CPU bottlenecks would potentially affect performance at lower resolutions as well, which we can see by the results.

At 4K, the RTX 5070 leads the RTX 5060 Ti 16GB by 32% on average, with a performance difference of -5% (Indiana Jones and the Great Circle) to +43% (A Plague Tale: Requiem). Indiana Jones is known to want a lot of VRAM — you can even run the ultra setting on cards with less than 12GB — while various other games appear to want more memory bandwidth.

Dropping to 1440p, the 5070 lead shrinks fractionally to 31% overall, and this time there are no performance deficits. There may be a few other games out there that can push beyond 12GB of VRAM use, but from our test suite — a rather demanding suite overall, we'd say — 12GB remains sufficient in all games for 1440p, and in all but one of the games for 4K.

1080p starts to run into CPU limits, even more so at medium settings, which shrinks the delta between the 5070 and 5060 Ti to 28% at ultra settings and 24% at medium settings. That's still a sizeable gap, with a few of the games showing basically equivalent performance due to the CPU bottleneck (Baldur's Gate 3, Flight Simulator 2020, Spider-Man 2, Spider-Man: Miles Morales, and Stalker 2 end up tied in one or both cases).

Looking at the rasterization and ray tracing performance, overall there's not much difference at the various resolutions and settings. 4K ultra does run into VRAM limits on one of the RT games, so that the gap is slightly narrower there than at 1440p and 1080p, and our RT test suite does end up with lower FPS than the rasterization games at ultra settings. Medium settings with RT enabled actually runs faster on average for our test games, but only Control and Cyberpunk are truly demanding RT games in our title selection.

RTX 5070 vs RTX 5060 Ti Content Creation Performance

Our content creation test suite consists of a variety of test that all loosely fall into the "professional" category. We have multiple AI tests, 3D rendering benchmarks, video transcoding performance courtesy of SPEC Workstation 4.0, and the SPEC Workstation 4.0 Viewport benchmarks (basically the same tests as SPECviewperf).

As expected, the RTX 5070 generally walks away with the content creation crown. It's 45% faster in the Blender 3D rendering benchmarks, 33% faster in MLPerf text generation tokens per second, and 20–43 percent faster in the Procyon and SPEC AI tests that we ran. The 5060 Ti 16GB did have a faster time to first token in MLPerf, though it's possible that's due to updates to the benchmark (we'll recheck the 5070 in the near future, once our test rig isn't busy).

For SPEC Workstation 4.0's Viewport tests, there's another instance of the 5060 Ti 16GB garnering a win — it's 2% faster in Creo. But overall the 5070 still has a 23% lead. Handbrake video transcoding meanwhile ends up as a tie, which is expected as the fixed function encoding and decoding hardware is the same, so the only difference would be GPU clocks during that test.

Neither GPU is specifically marketed as a professional solution, though we anticipate there will be professional variants of both chips (with more VRAM and drivers that enable additional accelerations in some of the SPEC Viewport tests). Mostly, the AI results are interesting as a hobbyist solution, though it's possible future games might leverage the AI hardware more.

RTX 5070 vs RTX 5060 Ti Conclusion

Which is better: RTX 5070 or RTX 5060 Ti 16GB? Price, as we said at the start, will arguably be the biggest factor in deciding between the RTX 5070 and RTX 5060 Ti 16GB. It's also the one thing that we can't really pin down at present. Since the 5060 Ti launched just a few days ago, pricing and availability are more likely to fluctuate in the near term. The 5070 has been out for a month now, and we have a better idea of what to expect.

First, let's talk about MSRPs and performance. On paper, Nvidia gives the 5060 Ti 16GB a $429.99 MSRP and the 5070 has a $549.99 MSRP — so $430 and $550. That means the 5070 is supposed to cost 28% more than the 5060 Ti 16GB. And based on the performance results, that's exactly in line with what you get.

Linear performance scaling generally means you're better off buying the more expensive card — we would normally expect to see diminishing returns. So if you buy an RTX 5060 Ti 16GB at MSRP and get 0.171 FPS/$ across our gaming tests, versus the RTX 5070 with 0.170 FPS/$, we give the win to the 5070. The reason is because the GPU doesn't exist in a vacuum; there's the rest of the PC to consider.

Alternatively, let's talk current street prices. These will change dramatically over time, but we can currently find an RTX 5060 Ti 16GB for $509.98, or an RTX 5070 for $619.98. That's the second pair of tables in the above gallery, which obviously skews in favor of the 5070 at current prices. And that's what you need to look at, first and foremost.

Finally, imagine a PC where the CPU, motherboard, SSD, RAM, PSU, and case together cost $750 for example. Now you're looking at a total cost of $1,180 for the 5060 Ti 16GB compared to $1,300 for the 5070 build (using the base MSRPs for the GPUs). That works out to just 10% more total money for about the same 25~30 percent performance uplift. It's what the last set of tables above show, and again, it favors the 5070 heavily.

Given the 25~30 percent performance advantage of the RTX 5070 over the RTX 5060 Ti 16GB, spending up to 30% more on the RTX 5070 would make sense. It's the clear winner at current online prices, or at the given MSRPs. In fact, we would argue that it's worth spending up to 40% more for the 5070 compared to the 5060 Ti, as we normally expect diminishing returns.

We don't know where prices will end up, in the U.S. or elsewhere, but you can use the above 30–40 percent figure as a guideline. If the RTX 5070 were to cost $550, we wouldn't recommend spending more than $425 on the RTX 5060 Ti 16GB — and $400 would be better. Conversely, if the best price you can find on the RTX 5070 ends up being $700, then the 5060 Ti 16GB would be worth $500 to at most $540. (And you can replace the dollar signs with whatever monetary symbol you choose.)

Long-term, we expect both GPUs will trend toward about a 30% higher price for the RTX 5070 vs RTX 5060 Ti 16GB. Anything less makes the slower card very difficult to justify, even if it does technically offer more VRAM. So unless you specifically need a card with 16GB, perhaps to run a particular LLM, the RTX 5070 offers the better overall value right now, and will probably continue to do so in the future.

With the release of its latest models earlier in the week, OpenAI seems to have inadvertently tuned ChatGPT to become a potent geo-guesser. The newly available o3 and o4-mini are so good at this ‘reverse location search’ task that showing off this newfound functionality has become a viral social media trend, notes TechCrunch. However, this apparent geographic needle-in-a-haystack hunting improvement raises privacy concerns. And pro geo-guessers on social media platforms might be a little worried too.

This newfound ability of ChatGPT is a great example of the strengthened visual reasoning being brought to the platform with model updates. It can now reason based on the content of uploaded images and perform some Photoshop-esque tasks like cropping, rotating, and zooming in.

As per the source report, there are plenty of examples of users of this famous AI chatbot now using it to drill down on the location of various images. A popular jape is to ask ChatGPT to imagine it is playing the online GeoGuessr game and provide the answer based on supplied imagery. Below, we’ve embedded an example of ChatGPT's location divining skills, shared by AI enthusiast YouTuber and Twitterer Brendan Jowett.

As Jowett points out, the newly popular ChatGPT ‘reverse image search’ functionality has privacy implications, and raises particular concerns with regard to doxing. Doxing is publicly sharing someone’s private information, particularly location / residence, on the broad internet. People are commonly doxed with malicious intent, with the perpetrator hoping to direct loonies and cranks to visit upon the victim(s).

Interestingly, TechCrunch notes that ‘Geoguessr’ ability isn’t new for ChatGPT with the release of o3 and o4-mini. It is just the trend / awareness that has ballooned. It is said that o3 is particularly good at reverse location search, but GPT-4o, a model released without image-reasoning, can sometimes outpace o3, and deliver the same correct answer “more often than not,” says TechCrunch.

Before we go, it is worth mentioning that AI geo-guessing isn’t a totally dependable or 100% accurate function of ChatGPT with the latest models. That’s not surprising. Also, TechCrunch got a statement from OpenAI on its viral GeoGuessr success. In brief, the artificial intelligence pioneer said that, while it works to improve its tools with things like visual reasoning, it also spends time training models to refuse requests for private or sensitive information. Creative users may be able to sidestep safeguards for a time, but OpenAI indicated it will take action where it sees evidence of abuse of its usage policies.