The Competitive Dimension of AI Models Has Shifted: Some Compete on Parameters, Others Compress Parameters to 1 and -1

A 7.75GB image generation model is compressed to 0.93GB.

Not distillation, not pruning—it directly cuts weights to just two numbers: {-1, +1}.

Released last week by PrismML, Bonsai Image 4B makes an original FLUX.2 image model that required 16GB of memory run on an iPhone and generate an image in 9.4 seconds. The significance of this goes far beyond "a phone can draw now."

A Counterintuitive Fact

Let’s talk about something the industry rarely states explicitly: Over the past two years, competition among AI models has been largely on the same dimension—who has more parameters, who has bigger data, who has more compute power. From 7B to 70B to 405B, the path is almost identical.

But there has always been an undercurrent: Can we express the same intelligence with fewer bits?

In 2024, Microsoft released BitNet, proposing 1.58-bit ternary weights {-1, 0, +1}, which caused a stir in academia. But papers are papers; no one actually turned it into a product.

Until PrismML.

This company, spun out of Caltech labs, came out of stealth mode in March this year, with investment from Vinod Khosla. Their first product was a 1-bit language model (8B parameters occupying only 1.15GB). Bonsai Image 4B is their second move—bringing 1-bit quantization from language models to image generation models.

This is important. Because image models are more sensitive to precision than language models. You might tolerate a slightly garbled sentence from a 1-bit LLM, but if a picture has wrong colors or broken structure, your eyes spot it instantly.

What It Actually Did

Simply put: it compresses the diffusion transformer weights of FLUX.2 Klein 4B from 16-bit floating-point numbers to 1-bit binary {-1, +1}.

Two variants:

Including text encoder and VAE, the full deployment package on Apple Silicon is only 3.42GB—the original requires nearly 16GB.

The 1-bit version is equivalent to 1.125 bit/weight, while the Ternary version is 1.71 bit/weight, adding a zero state for greater expressiveness.

PrismML evaluated on three benchmarks (GenEval for object composition, HPSv3 for human preference, DPG-Bench for dense prompt following). The Ternary version retains 95% of the original quality overall.

"Without careful inspection, the difference is minimal"—that's not marketing talk; it's what the benchmarks say.

But Another Number Concerns Me More

1.5GB active memory, 9.4 seconds to generate a 512×512 image.

What does this mean?

It means the iPhone 17 Pro Max can run it. Not the "it can run" from a demo video, but the kind where you open an app, enter a prompt, and get an image in 9 seconds. PrismML even built an iOS app called Bonsai Studio, available directly on the App Store.

unwire.hk tested it on an iPhone Air: generated over a dozen images in a row, the device only got slightly warm, no overheating at all. However, Chinese language support is poor—traditional Chinese characters all turned into pseudo-Chinese gibberish. There's also safety filtering; it directly rejects generation for sensitive content.

There's also a WebGPU demo—open a browser, enter a prompt, and generate locally. No registration, no API key, data never leaves your device.

This is what 1-bit quantization truly changes: it turns "local image generation" from impossible into possible.

Why "Local" Deserves a Special Mention

Generating an image on Midjourney means modifying the prompt three times, waiting 30 seconds each time—that's a minute and a half total. With DALL·E, every API call has latency and is charged per token.

Image generation is inherently iterative. You never generate just one image—you tweak prompts, change seeds, adjust parameters, compare results. In the cloud, every iteration carries latency and cost. Locally, this loop becomes second-level feedback with zero cost.

PrismML wrote this in their announcement, hitting the nail on the head:

"Cloud APIs will continue to be the right choice for many products. But cloud-only generation imposes certain product constraints: every prompt is a remote request, every iteration carries marginal serving cost, and every interaction adds round-trip latency."

In other words: Cloud APIs have their place, but if every prompt modification requires waiting for a server and paying, the creative rhythm is broken.

Get Started in Three Steps

If you'd rather skip the theory and jump in, go ahead:

git clone https://github.com/PrismML-Eng/Bonsai-image-demo.git
cd Bonsai-image-demo
./setup.sh

The setup script automatically pulls model weights—MLX format for macOS, Gemlite format for Linux/Windows.

Download model variant:

# Recommended: ternary version (better image quality)
./scripts/download_model.sh

# For the smallest 1-bit version
./scripts/download_model.sh binary

Generate an image:

./scripts/generate.sh -p "An icy bonsai tree in a rainy forest, photo realistic." --size 1024x1024 --seed 9909

Or start a web studio with one command (FastAPI + Next.js):

./scripts/serve.sh
# Open browser at localhost:3000

Note for Windows users: Make sure your driver version is recent enough; GPUs with less than 4GB VRAM should stick to 512×512. If you don't want to deploy, there's a WebGPU demo on HuggingFace that runs directly in your browser.

The Competitive Dimension Has Indeed Shifted

This discussion on Hacker News scored 464 points and 201 comments. One comment that stuck with me:

"I actually can't wait for the future where I upgrade hardware in order to upgrade my ai as an alternative to an expensive subscription."

Upgrading hardware to upgrade your AI, instead of paying increasingly expensive subscription fees. This may be the most radical business implication of 1-bit quantization.

PrismML calls this "Intelligence Density"—instead of competing on parameter count, compete on intelligence per bit. The 1-bit Bonsai 8B occupies only 1.15GB, runs at 40 tokens/s on an iPhone, and holds its own against models 14 times larger. The image model follows the same philosophy.

When a 0.93GB model can generate images on a phone, and a 1.15GB language model can match 16GB models, is "parameter count" still the only metric for model capability?

Perhaps soon, we'll start comparing models on another dimension: How many bits do you need to accomplish the same task?

GitHub: github.com/PrismML-Eng/Bonsai-image-demo

WebGPU Demo: huggingface.co/spaces/webml-community/bonsai-image-webgpu

PrismML Official Announcement: prismml.com/news/bonsai-image-4b