We publish models and results so people can test what jBlaze can do. We do not currently plan to publish the technology itself.
jBlaze can permanently change trained model behavior at the weight level. The same system that can improve reasoning, precision, self-correction, factual behavior, and specialization can also remove safeguards, replace identity, reshape decision behavior, and lower the barrier to creating uncontrolled model variants. Once a reusable system like that is public, it cannot realistically be recalled.
A reusable model-editing system could make it much easier to strip safety-related behaviors from many open-weight models, not just one.
Persistent identity and behavioral modification can be valuable in controlled environments, but the same capability has obvious misuse potential.
If reasoning and other capabilities can be improved without building a larger model or repeating a full training cycle, open release could dramatically lower the barrier to powerful model modification.
Direct knowledge programming creates powerful enterprise uses, but also raises serious questions around provenance, misinformation, and integrity when placed in uncontrolled hands.
If model providers believe released weights can be broadly and permanently rewritten with little friction, they may become less willing to release future open-weight models.
Once source code is copied, mirrored, forked, and redistributed, there is no realistic way to put it back in the box.
And that is not the only risk. jBlaze could also affect large parts of the AI industry financially. Much of today's AI economy assumes that materially changing a model requires expensive retraining, fine-tuning, large GPU allocations, repeated post-training runs, or replacement with a larger model. If targeted weight-level programming can accomplish some of those goals faster and with far less compute, that assumption changes.
That could put pressure on businesses built around repeated training and post-training compute, GPU rental, large-scale fine-tuning, model-customization services, and the infrastructure needed to support those workflows. It could also change the competitive value of existing models by allowing an owner to improve or repurpose models it has already paid to train instead of replacing them as quickly.
Open-sourcing jBlaze would remove exclusivity from that capability. No single company would gain the strategic advantage of controlling it; every competitor, startup, researcher, and model modifier could potentially use it. That is not merely a software-release decision. It could change incentives across model development, cloud compute, enterprise AI customization, and parts of the GPU and datacenter ecosystem.
We believe the technology is better placed inside a controlled environment with a major technology company capable of securing it, validating it at scale, and deciding where and how it should be deployed.
We will continue releasing selected demonstration models and benchmark results so the capability can be independently tested without exposing the proprietary mechanism that produces it. We are open to serious strategic acquisition discussions with qualified organizations.
Use jBlaze to optimize supported models, create purpose-built variants, improve capability per deployed parameter, and make NVIDIA's AI software stack more valuable alongside its hardware.
Apply jBlaze to Phi and internal model families for enterprise-specific behavior profiles, reasoning improvements, and controlled weight-level customization.
Create specialized Gemma variants and add a new post-training control layer for enterprise and research deployments without repeating full training cycles.
Turn Llama models into purpose-built variants with model-specific reasoning, behavior, identity, and precision profiles while keeping the underlying parameter count fixed.
Offer enterprise customers deeper control over model behavior while reducing the need for expensive retraining for many customization tasks.
Use model-specific discovery to find reasoning, precision, self-correction, and other configurations that improve deployed Qwen variants without increasing model size.
Combine efficient open-weight models with targeted post-training behavior control to create specialized variants without rebuilding the foundation model.
Reasoning, identity, tone, factual behavior, skepticism, precision, and other traits can become optimization targets instead of reasons to train another model from scratch.
Prometheus was our first experiment in what we have coined as CLEAN — Closed-Loop Evolution of Autonomous Neural Systems: autonomous self-improvement at the weight level.
First, the model self-evaluated. It recorded its own results in Atlas memory, including what had already been tried and what had failed. It then proposed a change and used jBlaze to apply that change to a cloned version of itself.
A separate validation step tested the modified clone and decided whether the new version survived. Successful changes were promoted. Failed changes were discarded. The result was stored in Atlas so the next generation started with deterministic memory of the previous attempts.
Prometheus completed more than ten generations autonomously. Most proposed changes were rejected, which was exactly what we wanted. On Generation 4, after several failed strategies, the model selected an analytical-depth modification. The modified clone scored higher than the active model and was promoted. On the next evaluation cycle, precision improved dramatically as an unexpected side effect. The planner had not predicted it. The validator discovered it.
The model identified where it was weak, Atlas preserved the history, it proposed a change, jBlaze modified its cloned weights, and validation determined whether the result survived. No human selected the winning modification. No human decided whether to keep it. The loop ran unattended. That is CLEAN: the model is not merely improving the software around itself; it is participating in the controlled evolution of its own neural weights.
This was not a frontier model redesigning its own architecture. It was a 7B Qwen 2.5 Instruct model inside a controlled software harness that gave it access to the tools it needed. The real question is: "How far can that process scale?" We ran Prometheus only long enough to prove the loop, then redirected the GPU resources elsewhere.
Prometheus has returned with something new, and this time the gods don't have it either. We're curious what they think it's worth. Hopefully more than a rock.
Our preference is simple: prove what jBlaze can do publicly, protect how it does it privately, and place the technology with the organization best equipped to control, secure, and develop it.