DEV Community: brooks wilson

Another Major Chinese AI Model Goes Open Source: MiniMax H3

brooks wilson — Wed, 05 Aug 2026 10:03:12 +0000

Another Major Chinese AI Model Goes Open Source: MiniMax H3 Tops Global Audio-Video Editing Benchmark, 16 Chip and Platform Partners on Day One

Text, image, audio, and video — all in one model.

On August 3, MiniMax officially open-sourced its next-generation universal video model, MiniMax H3.

MiniMax H3 is a universal omni-modal generation system capable of understanding multimodal context composed of text, images, video, and audio. It generates videos up to 15 seconds long at up to 2K resolution with native stereo audio.

MiniMax H3 was first released on July 31. On the Artificial Analysis audio-video editing leaderboard, MiniMax H3 currently ranks first with an Elo score of 1,130 — ahead of Gemini Omni Flash, HappyHorse-1.0, Wan 2.7, and other leading video models worldwide.

The H3 system consists of three modules: H3-Context-IR, H3-Base, and H3-Regenerate-2K.

Developers can download MiniMax H3 directly from Hugging Face. H3-Base currently supports deployment via inference frameworks and workflows including SGLang, vLLM, diffusers, and ComfyUI.

Alongside the open-source release, 16 ecosystem partners have completed adaptation support on day one.

These include chip manufacturers such as Huawei Ascend, Moore Threads, Metax (Muxi), Hygon (Haiguang), Kunlun Chip, Iluvatar CoreX (Tianshu Zhixin), Biren Technology, AMD, and Intel; developer communities and cloud inference platforms including Hugging Face, ModelScope, ComfyUI, RunningHub, and fal; and inference frameworks such as vLLM-Omni and SGLang.

Open-source repository:
huggingface.co/MiniMaxAI/MiniMax-H3

Model demo and API:

H3-2K direct output: platform.minimaxi.com/docs/api-reference/video-generation-v2-create
H3-Context-IR: platform.minimaxi.com/docs/api-reference/video-generation-v2-h3-context-ir
H3-Regenerate-2K: platform.minimaxi.com/docs/api-reference/video-generation-v2-regeneration
MiniMax Hub: hub.minimaxi.com
Hailuo AI: hailuoai.com
Wavespeed AI MiniMax H3

We tested MiniMax H3 hands-on. The model can already handle a variety of video generation tasks and performs well in terms of visual naturalness, shot composition, and overall style consistency.

There is room for improvement in photorealism and shot sequencing.

For example, we asked the model to generate a 15-second aerial landscape video. The resulting footage featured realistic snow-capped mountains, grasslands, and other natural scenery, with natural-looking color, lighting, and aerial camera movements. The long take maintained good visual coherence overall. However, temple structures in the footage still showed noticeable AI-generated artifacts.

We then asked MiniMax H3 to generate a promotional ad video featuring a milk tea brand and a gaming IP crossover. The generated video contained six shots with a clear narrative sequence and a generally unified visual style and advertising tone. However, in terms of multi-shot sequencing, the model produced one noticeable repetition: the action of a staff member handing a cup of milk tea to a customer appeared twice in succession.

1. Up to 15-Second 2K Video with Synchronized Stereo Audio

MiniMax H3 is a universal omni-modal generation system. In terms of output specifications, H3 can generate videos from 4 to 15 seconds, supports aspect ratios including 21:9, 16:9, 4:3, 1:1, 3:4, and 9:16, outputs at 24 FPS, and can simultaneously generate 32kHz stereo audio.

The model generates video with a default short-side resolution of 768 pixels, which can be upscaled to 2K via H3-Regenerate-2K. H3 stably supports 11 languages including Chinese, English, Japanese, Korean, French, and German, with varying degrees of support for additional languages.

H3 includes two versions — FL2VA and Ref2VA — designed for first-and-last-frame generation and omni-modal reference generation, respectively.

H3-Base-FL2VA operates in first-and-last-frame mode and accepts up to two input images. Without image input, the model performs text-to-video generation. With a single first-frame or last-frame image, it generates a corresponding video. With two images, it generates the intermediate video content between the specified start and end frames.

H3-Base-Ref2VA supports omni-modal reference mode with up to 9 input images; up to 3 video clips (each 2–15 seconds, total not exceeding 15 seconds); and up to 3 audio clips (each 2–15 seconds, total not exceeding 15 seconds, must be paired with an image or video input). The combined total of image, video, and audio files cannot exceed 12.

2. Three-Module System for Audio-Video Generation with Context-Aware 2K Upscaling

The H3 system comprises three modules: H3-Context-IR (understanding and organizing multimodal instructions), H3-Base (generating audio and video), and H3-Regenerate-2K (producing 2K output).

H3-Context-IR is a managed preprocessing and orchestration system that understands the relationships between text, images, audio, and reference videos, as well as how these materials relate to the intended output. Its internal workflow includes instruction parsing, cross-modal association, temporal understanding, and complex logical reasoning.

H3-Context-IR relies on a multi-stage workflow with multiple managed models and services. This module is not yet open-sourced. MiniMax currently provides corresponding APIs and prompt guidelines, enabling developers to build their own multimodal preprocessing systems.

Video prompt writing guide: huggingface.co/MiniMaxAI/MiniMax-H3/blob/main/docs/VIDEO_PROMPT_WRITING_GUIDE_base_en.md
Full reference mode output guide: huggingface.co/MiniMaxAI/MiniMax-H3/blob/main/docs/VIDEO_PROMPT_WRITING_GUIDE_ref_en.md

H3-Base handles the actual audio-video generation. Text is encoded by H3-Encoder; visual inputs are processed by both H3-Encoder and H3-VisualVAE; audio is encoded by H3-AudioVAE. Information from different modalities is then organized into a unified sequence and fed into the H3-Omni-Transformer.

For 2K resolution output, H3 does not use a traditional dedicated super-resolution module. Instead, H3-Regenerate-2K has the base model re-generate from the original text and multimodal references, using the already-generated 768p video as a guide. This approach re-leverages the original context, helping restore fine details such as small text and intricate textures that are difficult to reconstruct from low-resolution footage alone. This module is also not yet open-sourced; developers can replicate the full 2K workflow via the official API.

3. Local Deployment Supports 768p Audio-Video; Full 2K Workflow Requires API

MiniMax provides developers with two verification paths: H3-Base local deployment and the full 2K workflow.

H3-Base is published as two separate model repositories (FL2VA and Ref2VA), each containing processors, tokenizers, a text encoder, the Omni Transformer, Visual VAE, and Audio VAE inference components. These can be deployed via SGLang, vLLM, diffusers, and ComfyUI, with support for multi-GPU parallel inference.

With H3-Base deployed locally, developers can generate audio-video at a short-side resolution of 768 pixels. The FL2VA version supports text-to-audio-video and first-and-last-frame generation, while the Ref2VA version supports tasks such as character and scene preservation, action and lip-sync editing, and voice reference using joint reference images, videos, and audio.

The full 2K workflow combines local models with the official API: H3-Context-IR first interprets and expands user input, then the locally deployed H3-Base generates 768p audio-video, and finally H3-Regenerate-2K re-generates 2K video using the original context. MiniMax also provides reproducible examples for text-to-audio-video, first-frame-to-audio-video, and omni-modal reference generation — complete with request parameters, sample code, and reference outputs available on the Hugging Face model page.

4. Conclusion: Omni-Modal Video Generation Moves Toward an Open Ecosystem

In terms of real-world performance, MiniMax H3 can already handle diverse generation tasks including natural landscapes and commercial advertising, demonstrating a high level of competence in visual naturalness, shot composition, and style consistency.

With multiple chip manufacturers, developer communities, cloud inference platforms, and inference frameworks completing adaptation support simultaneously, MiniMax H3's open-source release not only opens up the model's capabilities but also establishes an end-to-end ecosystem pipeline from model download to local deployment to application development.

Competition among omni-modal video models is expanding beyond visual quality alone into audio generation, complex instruction understanding, and industrial ecosystem building.

DeepSeek V4 Flash Review: How Far a 300B Model Can Actually Go

brooks wilson — Tue, 04 Aug 2026 10:45:56 +0000

DeepSeek V4 Flash Review: How Far a 300B Model Can Actually Go

A hands-on DeepSeek V4 Flash review covering reasoning parity with the 1.6T Pro preview, agentic coding gains, harness quirks, long-context limits, and real API cost.

Every lab that ships a 300B-class model is publishing an opinion about what that size is for.

MiniMax got there first and treated it as a daily driver for light work.

Hunyuan aimed higher, arguing 300B is enough to carry most engineering tasks that aren't especially complex.

OpenAI handed its small Luna model to an AI to self-iterate on, using the size class as a proving ground;

the results so far have been underwhelming. DeepSeek's answer with V4 Flash is that none of these are the ceiling — that 300B can do difficult reasoning and complex development at the same time.

The short version of this DeepSeek V4 Flash review: it mostly holds up.

On reasoning, Flash matches DeepSeek's own 1.6T Pro preview at the top end and beats it on consistency. The price is roughly 50% higher token consumption, which is what the post-training buys. On agentic coding it clears Pro preview outright and lands at the lower edge of what I'd call genuinely production-usable.

Logic Benchmark Results

Scores below follow the methodology of the July 2026 LLM logic capability benchmark, sorted by median score in descending order.

Three things about reading it. The table shows only comparable models rather than the full ranking, so treat it as a set of head-to-head pairings, not a leaderboard. Entries in red were run in reasoning mode (slow thinking); black entries are the same models in non-reasoning mode (fast thinking). The complete and continuously updated ranking lives at https://llm2014.github.io/llm_benchmark/.

Agentic Coding

Test setup follows the V3 agentic coding evaluation.

Flash's coding ability is uneven, and it splits along two axes: programming language and harness.

Like most Chinese models, Flash is strongest where the training corpus and training methods are most mature — frontend work. Its finished frontend output trades wins with GLM-5.2, a model close to three times its size. Move to Rust or Swift and the curve falls off a cliff. Flash broadly understands what needs to happen; it just doesn't hold the details the way it does in frontend. That's still a long way from the Pro and Flash previews, which frequently couldn't establish what needed doing or how to proceed at all.

Claude Code vs Codex

The harness gap comes down to default settings and toolchains rather than anything about the model itself.

Claude Code's default single-response length cap works against Flash. Like the preview, Flash wants to reason the whole thing through before touching a file, and during the planning stage of a complex project a single thinking pass can run to 50K tokens. Codex has the opposite problem. It iterates on itself often enough that Flash's tool-use efficiency there is poor, taking 30–40% more steps to finish the same task.

Final output quality between the two ends up close. DeepSeek's own harness, due shortly, should close both the configuration mismatch and the tool-familiarity gap — at minimum it won't be the thing holding the model back.

Frontend Quality Without Vision

Flash still has no vision capability, which makes its aesthetic jump harder to explain. Preview-era UI came out at demo quality: fine for a screenshot, not something anyone would ship. Release-version output sits close to production grade across spacing, color, proportion, and interaction detail. It volunteers page transitions and icon micro-animations without being asked, which even some higher-tier models don't bother with.

The ceiling is still visible. Flash ranks below the leading frontier models on UI work, and the gap widens as soon as you leave the web. Anything involving 3D modeling or animation exposes undertrained territory — exactly where large frontier models keep their advantage.

How Flash Verifies Its Own Work

The self-testing behavior is the most interesting thing in this release, and it follows directly from having no eyes.

Beyond conventional test cases, Flash converts screenshots into ASCII character maps so it can reason indirectly about what is on screen. For animation, it writes automated interaction sequences that reproduce a complex scene, then reads frame-by-frame state values to decide whether the motion is behaving correctly. Both approaches work in practice.

On one Godot project, Flash located and fixed nearly every functional bug on its own; what remained was interaction polish and performance tuning.

Building a text channel to the visual state is a reasonable workaround for a blind model. More importantly, it means verification is part of Flash's working loop rather than something bolted on at the end.

Reasoning: Where Flash Beats a Model Five Times Its Size

Not a clean sweep. Flash's advantage over Pro preview concentrates in meta-capabilities that generalize out of coding and writing training — instruction following and text manipulation above all.

July's new question set included items with unusually heavy text-processing demands. Pro preview scored very low there, in line with most Chinese models. Flash jumped to the top of that group, level with GPT-5.6 Luna. On constraint-satisfaction problems the two trade wins at a similar ceiling.

Hallucination and Long-Context Behavior

Context hallucination is meaningfully suppressed. Across very long inputs, Flash holds onto detail better than Pro preview — first tier, though not the top of it.

In coding the improvement is easier to pin down. Flash doesn't start dropping the original instruction requirements until context passes roughly 400K, later than either the Pro or Flash preview managed.

Token Efficiency and What It Actually Costs

Flash averages about 24% more tokens per turn than Pro preview, but that average hides a lopsided distribution. On instruction-following tasks Flash is more efficient, sometimes down to half of Pro's usage. On some simple coding tasks its raw instinct is better, so it spends slightly less. Everywhere else it spends more.

Iteration is the bigger cost driver. On complex agentic tasks Flash runs more turns, and cache reads for the same task come in 2.7–5x higher than Pro. Priced at API rates, that erodes most of the headline discount: Flash lands only about 30% cheaper than Pro preview.

Anyone routing through a third-party API should check cache pricing and hit rate before assuming savings. Without DeepSeek's native cache efficiency, Flash's cost advantage disappears entirely.

The Note

For a team that controls its own release cadence, timing was never the question. Whether the thing is finished is the question.

If DeepSeek intends to lead rather than follow, it can't ship warmed-over versions of other people's ideas. North America's frontier labs spent three years in unmapped territory with no one to learn from; they had no choice but to trust themselves. DeepSeek works from the same premise. In their view there are no rivals — only the far end of the map.

When the Plan Fails, Don’t Restart the Group Chat

brooks wilson — Wed, 29 Jul 2026 09:14:56 +0000

A reservation disappears at 7:08 p.m.

Six people were supposed to meet at eight. One has already left work. Another needs to be home by ten. Someone is vegetarian. Two people have quietly agreed that $35 is their limit.

Then the cancellation message lands in iMessage:

Sorry, we can no longer accommodate your party tonight.

The group responds as groups do.

“Anything nearby?”

“I’m flexible.”

“What about Brooklyn?”

Three screenshots arrive. Somebody suggests a place that closed last year. The person who organized the original plan begins reopening every decision the group already made.

This is where a generic chatbot tends to produce the wrong kind of help: more ideas.

But a canceled plan is not a blank page. It is a recovery problem.

Treat the cancellation like a failed dependency

In software, one failed service does not mean rebuilding the entire application. You identify what broke, preserve the working state, and replace the smallest possible component.

Group plans deserve the same courtesy.

Before searching for a backup, freeze everything that is still true:

Group size: 6
Start time: around 8:00
End time: before 10:00
Budget ceiling: $35 per person
Food constraint: vegetarian option required
Travel constraint: no new cross-city journey
Energy: people are tired and already in transit

The reservation failed. These constraints did not.

That distinction matters because “Where else should we go?” accidentally reopens location, timing, cost, food, and mood all at once. Every person then solves a slightly different problem.

The result is not collaboration. It is six browser tabs arguing through human intermediaries.

Reopen only the affected decision

The useful question is:

What changed because of the cancellation?

If the venue canceled, the venue must change. The group size probably does not. Neither does the person’s budget, dietary need, commute, or hard departure time.

I call this the cancellation’s blast radius.

A fair backup keeps that radius small. It should not quietly make one person spend more, travel much farther, or ignore a constraint just because everyone else is impatient.

Fair does not mean every option delights everyone equally. That standard would leave most groups standing on a sidewalk until midnight.

It means the disruption is not transferred to the person with the least flexibility.

Photo by Brands&People on Unsplash

Generate a recovery set, not another recommendation dump

Once the surviving constraints are clear, produce two to four options. No more.

Each option needs four parts:

OPTION
What it is

FIT
Which hard constraints it preserves

TRADE-OFF
What the group gives up

ACTION
What someone needs to check or do now

For the canceled dinner, the message might look like this:

A — Stay in the same neighborhood
Preserves everyone’s arrival time and avoids extra travel.
Trade-off: fewer cuisine choices.
Action: confirm a table for six and current pricing.

B — Move one subway stop toward the group’s midpoint
Keeps the trip manageable and may offer more vegetarian options.
Trade-off: the people already nearby must move again.
Action: check current travel time and availability.

C — Switch from dinner to a casual food-hall format
Makes dietary preferences easier to handle without splitting the group.
Trade-off: less intimate and potentially noisier.
Action: verify closing time, seating, and live crowd conditions.

Notice what is missing: fourteen “great spots,” a neighborhood guide, and a paragraph about hidden gems.

The group does not need inspiration anymore. It needs a commit.

Give the group a decision message it can actually answer

The organizer should not end with “Thoughts?”

That merely restarts the discussion.

Use a bounded decision:

The original booking is gone, but our budget, timing, and travel limits still stand. These are the three workable backups. Reply A, B, or C by 7:20. If there is no majority, we’ll take A because it causes the least additional travel.

Now silence has a meaning. The fallback is visible. The decision has a deadline.

Marlow, my orange tabby, uses a simpler recovery protocol: if any plan fails, return home and request dinner. It is internally consistent, but it does not scale especially well to six humans.

Where an AI assistant becomes useful

The useful role for AI here is not to impersonate the most enthusiastic person in the chat. It is to preserve context while the group is under time pressure:

Capture the volunteered constraints.
Identify what the cancellation actually invalidated.
Return two to four currently checkable alternatives.
Explain why each one fits.
Turn the shortlist into a decision message.

After that workflow is established, a group can explicitly invite Karpo for local recommendations into the iMessage planning process instead of asking one person to reconstruct the entire situation manually.

The invitation matters.

An assistant should not silently enter a conversation or build profiles of people who never chose to use it. For non-users in the group, it only needs the constraints they volunteer for this particular decision.

“Needs a vegetarian option” is sufficient. It does not need to infer why.

“Cannot spend more than $35” is sufficient. Nobody owes the software—or the group—a financial biography.

The real difference from a chatbot

A chatbot answers the latest message.

A decision workflow maintains the state of the plan.

That state includes more than preferences. It includes hard constraints, previous agreements, live conditions, social consequences, and the action required to finish.

For a canceled group plan, the useful sequence is:

preserve context
→ isolate the failure
→ generate 2–4 viable backups
→ expose the trade-offs
→ choose and act

The quality of the recommendation still matters. Prices, operating hours, transit conditions, and availability must be checked at the time of the decision.

But the larger improvement comes from asking AI to solve the correct problem.

Not:

What else could we do?

Instead:

What is the smallest fair change that gets this group moving again?

That is the difference between producing options and recovering a plan.

A 2M-Token Context and Four Bolt-On Experts: How Macaron V1 Turned LoRA Into a Real Architecture

brooks wilson — Thu, 23 Jul 2026 13:38:55 +0000

The pace of Chinese model releases this year has been a little alarming.

When GLM-5.2 landed, the conversation was already about how close it sat to Opus 4.8. Once Kimi K3 shipped, most leaderboards swapped their reference point to Fable 5. Last week Alibaba dropped a 2.4T-parameter Qwen3.8.

Domestic labs are not catching up anymore — they've arrived.

Then I ran into a model taking a completely different route. While everyone else races to build the next general-purpose flagship, this one takes GLM-5.2, freezes it whole as bedrock, and trains four small experts on top of it. It calls itself a personal model.

It's Macaron V1, just released by Mind Lab — reportedly the first model in the world post-trained on top of GLM-5.2.

I've tested a lot of new models. But a model that positions itself as something meant to help with your actual daily life, over the long haul, called for a different kind of test.

So I fed it my own life. I dumped 4,580 of my posts from a Chinese microblogging app into it and asked it for life advice — partly to see how it'd talk to me, partly to stress-test how well it actually reads a long context.

A New Job for LoRA

Structurally, Macaron V1 is an outlier among today's large models.

Of its 748B parameters, 744B are the frozen GLM-5.2 base — not a single one of them moves. What actually gets trained are four 1B models bolted onto that base, which the team calls LoRA experts.

If you've played with AI image generation, LoRA is familiar territory. The old way to teach a trained model a new skill was to retrain the whole thing — expensive, and prone to making it forget what it already knew.

LoRA takes a different approach: leave the original model untouched, and attach a small new module beside it, like a detachable plug-in you snap on when you need it. Microsoft Research proposed it back in 2021, and it's since become the backbone of every style and character model floating around.

For most of its life, though, it's been treated as a cost-saving workaround rather than anything architecturally serious.

Mind Lab just moved it up a tier, and I think the framing is right: this sliver of parameters isn't a patch — it's closer to persistent local state. The base model supplies general capability, the shared part. The adapter carries a person's preferences, habits, and way of working with tools, the individual part.

The reasoning holds up, too. A base model that's already strong enough means most of what you learn after deployment isn't building new capability from zero — it's reorganizing what the model already knows. Which means a tiny update can move a surprisingly large amount of ground.

They pushed the idea to its limit. In a paper titled On the Scaling of PEFT, they show the adapter can be compressed down to a single tunable direction per layer and still learn stably. It holds up with under 0.5% of the base model's parameter count, and costs roughly a tenth of full fine-tuning in compute.

Notably, the stronger the base model, the more effective these small updates become.

In their hands, LoRA stopped being a one-off fine-tuning trick and became something you accumulate and manage like inventory. Their platform, MinT, already hosts a catalog of over a million LoRAs, each with its own identity and version history, evaluated before it ever ships, and rollback-ready at any point.

Back to Macaron V1: the four LoRA experts are split by mode of thinking. L0 handles conversation, L1 handles task execution in daily life, L2 handles coding, L3 handles interface generation. Every request goes through a router that decides which expert takes it — a setup they call MoL, Mixture of LoRA.

The thinking behind chat, coding, and tool use is different enough that cramming it all into one set of weights makes them fight each other — get better at coding and conversation might get dumber. Train them separately instead, and adding a new capability later just means plugging in a new LoRA without touching anything already working.

The naming is a nice touch, too. V1 ships in two sizes: the 748B flagship is called Venti, and the 35B compact version, built on Qwen 3.6 and meant for local deployment, is called Tall.

Starbucks cup sizes — a lot more legible than the Pro/Max/Ultra naming every other lab reaches for.

Here's how it stacks up against frontier models on benchmarks:

What stands out to me is that it leads or ties on personal-life and interface-generation benchmarks, and lands close to today's top models on coding — which makes sense, since it's trained on GLM-5.2. The base capability is solid, and LoRA layers in the chat, coding, and agent-specific judgment on top.

That result tracks.

Getting In

The model is live now, and testing it is simple. The platform is called MinT, and it exposes both OpenAI- and Anthropic-compatible endpoints.

You can point Claude Code straight at Macaron with a small config change:

There's a separate access point for mainland China at mintcn.macaron.xin, priced at ¥8 per million input tokens and ¥28 per million output tokens. The platform also hosts the raw GLM-5.2 base model directly.

I like this design — it ships its own control group. Run the same prompt through Macaron V1 and the base model, and you can immediately see what the post-training actually changed.

Feeding It My Own Life

The first real test: feeding it my life.

Since 2019 I've written 4,580 posts on a Chinese microblogging app — about 650,000 characters of running commentary. I exported all of it and dropped it into a single request.

I started with an easy fact-check: when was my first post about a little webcam fill-light I'd built?

It landed on the exact date, and quoted the original line back to me — a project I'd knocked out in an hour using Cursor, with four warm-toned lighting presets aimed at the colors people usually reach for. I grepped the raw archive myself afterward.

Word for word, correct.

Then I set a trap. I asked it to find the post where I stayed up all night hand-writing the fill-light code in Swift.

That post doesn't exist. I don't write code, full stop, and all 4,580 posts back that up.

It didn't take the bait. It told me flatly that no such post existed and that I might be misremembering, then pulled up the closest real post — one from a few days later where I'd actually written that I'd finished the code with Cursor in about an hour, describing myself explicitly as someone with no coding background.

It didn't play along with a false premise, and it did the legwork to find the actual line and correct me.

Reading a long context accurately without hallucinating is one thing. Understanding someone is another.

Inside a Claude Code session running on Macaron, in front of my entire writing workspace, I asked it to lay out the major turning points in my work and life over the last few years. Honestly, it was a little unsettling how precisely it reconstructed them.

Then I asked the real question: given everything I'd taken on, what should my focus be for the next phase?

Its first line back was blunt: you're not short on opportunities — you're scattered across too many of them, with too little leverage on any single one.

I won't paste the whole thing, but the gist was: stop taking on scattered one-off gigs and go deep on one thing instead. Every point it made was anchored to an actual project or actual numbers from my own history.

It didn't flatter me once. It was basically holding up my own résumé as evidence against me.

This is worth trying yourself: put it in front of your actual working files and ask it the question you've genuinely been putting off. Before it's read your history, the answer is a career-planning template. After, the answer starts being worth something.

Coding: Bringing K3 and Opus to the Same Table

For the coding test, I picked something hard.

I'd seen a concept design on X with over two million views — a floating golden roof modeled on the Forbidden City, with a curtain of Chinese characters hanging beneath it that twisted and flowed like water when you interacted with it.

I turned it into a pure text brief and had four models attempt it: no reference images, the roof drawn entirely in code, the character flow driven by a noise field, no external libraries allowed. It's built specifically to stress complex front-end visual work.

K3 and Opus both exceeded what I expected — cream paper backgrounds, serif headers, a small "About" footer, and a character curtain close in density to the original. Both models even gave their output sites a brand name.

Qwen's curtain came out too sparse, scattered characters that read more like falling snow than flowing water.

Macaron V1's version held its own: the curtain's density and flow were both convincing, and the roof was fully code-drawn. Partway through, it spun up a headless browser on its own to read the runtime's particle array and verify metrics like curtain width and overlap with the text region — checking its own work, which is probably closer to how it's actually meant to be used.

My read: this model's coding ability sits somewhere below Kimi K3, roughly on par with Claude Opus 4.8, and above Qwen3.8.

On the same coding axis I ran a more playful test: rebuild classic Battle City as a themed game. I handed it a cruise-ship travel guide and asked it to fold the guide's actual content into the game mechanics.

It came back first with a design-mapping table for me to confirm before building anything. And that's when I got my favorite detail of the whole test: every fact from the guide got welded directly into gameplay.

The guide mentioned 33 km/h winds on sailing day, so that level bumped enemy movement speed up 30%. A 96% chance of rain on a given day became a six-hit rain boss. The last ferry departing at 3 p.m. became a countdown level-clear mechanic. The seven-day itinerary became a seven-level campaign; the deck restaurant became destructible cover; the quiet chapel became a shield pickup.

Before handing it back, it even ran its own programmatic checks — pixel counts to confirm each element rendered correctly, logic tests to confirm shooting, three-hit cover, and item pickups all worked.

Here's what it looks like running:

Testing Its Agent Chops: I Handed It One of My Own Repos

Before wrapping up the coding tests, I tried something bigger.

One of my public GitHub repos has a backlog of open issues, so I pointed a Macaron-powered Claude Code session at it directly: pick something clear-cut and worth fixing, ship it, and sign the commit with your model identity.

It picked an issue reporting that installing a particular skill through the skills CLI was dropping subdirectories.

What it did next caught me off guard. Instead of jumping straight to a code fix, it installed the latest version of the CLI first and tried to reproduce the bug. Turned out the issue had already been fixed upstream in a later release — the person who filed it was on an old version.

So it made the smallest change that actually helped: it updated the README's install section with three things — how to verify your install worked, how to tell if you're on an old version and need to upgrade, and a git-clone fallback.

Then it committed, pushed, and left a comment on the issue tagging the person who'd reported it, with actual file counts from its own test run attached, signed as Macaron-V1-Venti-Coding.

That instinct — check whether the problem still exists before deciding whether to touch anything — is exactly the judgment an agent model needs if it's going to run inside an actual engineering loop instead of just generating diffs.

UI4A: The Model Draws the Interface Itself

UI4A is the newest of the four capability tracks — short for UI for Agents.

A typical model answers you with a wall of text, or at best an HTML file you have to open yourself. UI4A has the model output interface components directly, rendered live by a companion runtime, so you watch a clickable, draggable interface assemble itself piece by piece in the middle of the conversation.

Ask it for a health plan and it can hand you back a fillable card and a chart, instead of a numbered list of ten tips.

The official pitch is that it combines HTML's flexibility with the predictability of a structured protocol, and that it isn't model-specific — even a base model with no fine-tuning can drive it. Macaron just happens to have trained one of its 1B experts specifically toward this.

Getting started isn't complicated. The companion Macaron Artifacts plugin installs straight from the Claude Code plugin marketplace (repo at https://github.com/mindverse-ltd/macaron-artifacts), and once it's installed it spins up a local preview page.

From there, in a Claude Code session running on Macaron, you just ask normally — tell it to "show this to me as UI4A" — and the preview page renders the whole build process live, piece by piece.

I tried it on two of my own small projects.

The first was that little fill-light app I mentioned earlier. I asked it to turn the app's lighting panel into something I could control directly inside the conversation: a glowing circular dial as the light surface in the middle, three sliders for color temperature, brightness, and hue, a row of pastel swatches to switch the main color with one tap, and a button at the bottom that starts a warm, breathing glow when pressed.

The process itself was worth watching. It didn't get everything right on the first pass — it hit a mistyped component property, a wrong import path. But every time it caught its own error, it fixed it in place, holding the interface at the last version that actually rendered so I never hit a blank screen, then kept building from there.

By the time it finished and I dragged the hue slider, the dial's color genuinely tracked along with it.

The second was something lighter — a pastel, breathing-light pomodoro timer. The circle in the middle pulses and glows with the breathing rhythm, its color drifting between mint and peach as time runs down, the countdown numbers easing between ticks, with start, pause, reset, and a few preset durations underneath.

Not a technically demanding test, but it had the right feel — and mostly I wanted you to get a sense of what actually using Macaron Artifacts feels like.

Closing Thoughts

Two days after finishing testing, here's where I've landed.

Judging by how Macaron V1 was trained and benchmarked, this team isn't chasing the SOTA crown. Their bet, I think, is that the personal-assistant use case doesn't need one more generalist — it needs a set of specialists that actually fit you, plus a mechanism that gets better the more you use it.

That's why the core capability is currently split across four 1B plug-ins. That's why their benchmarks include dimensions like consistency across weeks of interaction and honesty with the user — things you won't find on a typical leaderboard. And that's why the model ships with a REPL environment that persists tools across sessions: tools the model writes for itself stick around for the next task, slowly building its own toolbox.

On the training side, their LongStraw system runs reinforcement learning at a 2.1-million-token context window, meaning long context isn't just used for inference — it goes into training too.

If that holds up at scale, the personal-model thesis actually has legs.

The weak spots showed up too. Complex visual composition is still a step behind Kimi K3 — though to be fair, K3 currently sits at No. 1 on the front-end arena leaderboard, ahead of Fable 5 and GPT-5.6, so that's not much of a knock.

And on complicated tasks, Macaron's reasoning chain runs long enough that a single back-and-forth question can test your patience. It's better suited to living inside an agent loop than being used as a quick-answer chat model.

Still, I want to keep watching this one grow. Especially after watching it weld a cruise itinerary into a seven-level campaign, and reconstruct three years of my life closely enough to be unsettling.

For the last couple of years, the industry's whole storyline has been "smarter" — every leaderboard grinding the same benchmark. A personal model is a fork in that road: intelligence has an agreed-upon scoreboard. Whether a model actually understands you doesn't. Only you can score that one.

Macaron may not be the final word on this path, but I'm glad someone's taking it seriously.

Ask the same question to a model that's read 650,000 characters of your life and one that hasn't, and you get two different answers.

My guess is it won't be long before everyone wants the one that has.

The Rise of the One-Person Software Company

brooks wilson — Tue, 30 Jun 2026 04:13:05 +0000

One-person software companies are rising as AI agents compress team-sized work. Learn the stack solo founders need to build, sell, and grow sustainably.

A solo founder can now produce a convincing software demo before lunch. The harder test begins the next morning, when a user cannot log in, a payment fails, the data model needs to change, and the landing page no longer matches what the product does.

That gap explains the next stage of the one-person software company. AI has made implementation dramatically more accessible, but a company is still a chain of decisions and operating systems. Code is one link. Customer research, product design, data, billing, distribution, support, and release management remain attached to it.

The founders who learn to run that chain alone are not simply working faster. They are designing a new kind of company: one person at the center, supported by agents, reusable templates, and managed infrastructure that once required several specialists.

Solo Founding Is Moving From Exception to Operating Model

There have always been independent developers and small internet businesses. What has changed is the range of work one person can coordinate without hiring a conventional team.

The shift is beginning to appear in company-formation data. Within Stripe Atlas, solo founders accounted for 63% of C corporations formed so far in the second quarter of 2026. Stripe is careful to describe this as Atlas data rather than the entire startup market, but the pattern is still notable. Its analysis also found that top-performing solo founders were more likely to build AI-native products and sell internationally from the beginning. The details in Stripe's report on why solo founding is at an all-time high point to a broader change: the one-person company is becoming a deliberate structure, not merely a temporary phase before hiring.

This does not mean every founder can build the next global SaaS alone. It means many useful products no longer need venture-scale staffing to reach their first customers. A scheduling tool for a narrow profession, a paid research workflow, a specialized content product, or a small data-backed app may be economically worthwhile long before it becomes large enough to support a team.

That changes what gets built. When the cost of testing an idea falls, markets that once looked too small for a software company become reasonable targets for one person.

A Company Without Departments Still Has Departmental Work

Imagine a consultant who notices that independent property managers spend every Friday assembling the same owner report. She knows the workflow, has sample spreadsheets, and can describe the desired output precisely. An AI coding tool can help her create the interface and generate a report. That is a strong prototype.

It is not yet a business.

To become one, the tool needs a place to store each customer's properties, rules for separating accounts, a way to recover from bad input, a payment flow, a public URL, and some record of where users stop. Someone must also decide what the product promises, answer support messages, and choose which requests belong on the roadmap.

In a conventional startup, those responsibilities might be divided among engineering, product, design, growth, and operations. An OPC keeps the work but changes how it is organized. The founder handles judgment-heavy decisions while software and agents absorb repeatable production work.

This is why the most important solo-founder skill is shifting from doing every task to designing a system in which every task has a clear owner, input, and checkpoint.

AI Agents Give the Founder Leverage, Not Autopilot

Chat assistants help with isolated tasks. Agents become more valuable when they can carry a bounded piece of work across several steps: research competitors, turn findings into a product brief, check a release against acceptance criteria, draft onboarding copy, classify support messages, or summarize usage patterns.

The distinction is operational. A founder should be able to hand an agent a goal, the relevant context, the tools it may use, and a definition of done. The output then returns for review or passes to another workflow. That resembles delegation inside a small team, even though the collaborators are digital.

Microsoft's 2025 Work Trend Index calls the person who builds, delegates to, and manages agents an “agent boss.” Its research is aimed largely at the workplace, but the model fits a one-person company unusually well. The founder remains accountable while agents extend available capacity. The report's description of human-agent teams and the agent boss is useful because it treats agents as an organizational design question, not a bag of clever prompts.

The boundary matters. Agents can draft, compare, transform, test, and monitor. They should not quietly decide what customer promise the company makes, which privacy trade-off is acceptable, or whether a questionable growth tactic is worth using. Those decisions carry responsibility, and responsibility stays with the founder.

Templates Compress the Cost of Starting From Zero

Agents reduce labor, while templates reduce decisions. Both are necessary.

A good template contains more than colors and components. It encodes a plausible product structure: which pages exist, how a user moves through them, where data enters, what happens after an action, and what must be ready before publication. A solo founder can begin with those decisions already made, then spend time on the parts that make the product distinct.

HappySeeds offers a concrete picture of this approach. Its OPC Launchpad and OPC Lab templates are framed around two different moments in one-person company building. OPC Launchpad turns a startup description into domain options, brand copy, a design system, and a landing page. OPC Lab is presented as a workbench for a one-person company in the AI era. They are useful examples because they package a recurring workflow instead of asking the founder to assemble every piece from a blank canvas.

Templates are not substitutes for product judgment. A polished starting point can still support a weak idea. Their real advantage is that they preserve the founder's attention for customer insight, positioning, and the few interactions that make the product worth choosing.

Data, Payments, and Publishing Are Part of the Product

The prototype era trained founders to celebrate what appears on screen. The OPC era will reward what survives contact with users.

Data creates continuity. It lets the product remember accounts, inputs, preferences, and results. Without it, many AI apps are disposable sessions. With it comes a serious obligation: the founder must decide what to collect, how to separate customer information, and what should be deleted.

Payments turn interest into evidence. A signup or compliment can signal curiosity; a successful charge shows that the product solves a problem someone values. Building payment into the early product also forces practical decisions about pricing, usage limits, refunds, and the cost of the AI services behind each customer action.

Publishing closes the loop. A private preview cannot attract search traffic, support a sales conversation, or reveal how strangers behave without guidance. The product needs a durable URL, a clear promise, working onboarding, and enough analytics to show where the experience breaks.

This is the philosophy behind HappySeeds' focus on helping founders build AI apps with real data, built-in payments, and a path to live users. The relevant shift is not that every founder should use one platform. It is that an app builder for one-person companies must treat commercialization and operation as part of building, rather than as chores postponed until after the demo looks good.

The Solo Founder Becomes a Systems Designer

Running an OPC does not require automating everything. It requires deciding which work deserves the founder's direct attention.

The founder should stay close to customer conversations, product taste, risk, and prioritization. These areas depend on context that is difficult to compress into instructions. Research synthesis, first drafts, regression checks, routine publishing steps, and support triage are better candidates for agents because the work can be bounded and reviewed.

A practical one-person operating loop looks like this:

Find one repeated, expensive problem for a specific group of people.
Start from a template or existing workflow instead of inventing every layer.
Give agents narrow assignments with context, constraints, and review points.
Connect durable data before users depend on the product.
Add payment early enough to test value, not just attention.
Publish, observe real behavior, and feed what happens back into the next build cycle.

The loop is intentionally modest. A founder who runs it every week has a better chance of building a durable product than one who produces a spectacular prototype and then disappears into another month of features.

Small Companies Can Pursue Smaller, Better Markets

The social importance of the one-person software company is not that it will eliminate teams. Teams remain necessary for products with deep technical risk, regulated operations, complex sales, or large service obligations.

The more interesting effect is that software entrepreneurship can fit more kinds of lives and more kinds of markets. A domain expert can build for a few hundred customers without first convincing investors that the market could support a billion-dollar outcome. A creator can turn a useful method into an interactive product instead of another downloadable document. A local operator can package a workflow that traditional SaaS vendors would consider too narrow.

These companies will still be difficult to run. Distribution remains stubborn. Customers still need trust. AI-generated code still breaks, and an agent can make a poor decision at impressive speed. Lower production cost does not remove competition or responsibility.

It does, however, change the minimum viable organization. For a growing class of software products, one thoughtful founder with a well-designed operating stack may be enough. The durable advantage will not come from generating more code than everyone else. It will come from connecting agents, templates, data, payments, and publishing into a company that can keep learning after the first launch.

DeepSeek-V4 Preview: Entering the Era of Accessible Million-Token Context

brooks wilson — Fri, 24 Apr 2026 03:20:03 +0000

DeepSeek-V4 Preview: Entering the Era of Accessible Million-Token Context

Today, we are officially launching and open-sourcing the preview release of DeepSeek-V4, our new model family.

DeepSeek-V4 supports an ultra-long 1M-token context window and reaches leading performance in China and across the open-source ecosystem in agent capabilities, world knowledge, and reasoning. The model family is available in two sizes.

Starting today, you can visit chat.deepseek.com or use the official DeepSeek app to chat with the latest DeepSeek-V4 models and explore the new experience enabled by 1M-context memory.

The API service has also been updated. To call the new models, simply change model_name to either deepseek-v4-pro or deepseek-v4-flash.

DeepSeek-V4-Pro: Performance Comparable to Top Closed-Source Models

Significantly Improved Agent Capabilities

Compared with the previous generation, DeepSeek-V4-Pro delivers a substantial improvement in agent capabilities.

In agentic coding evaluations, V4-Pro has reached the strongest level currently available among open-source models. It also performs well across other agent-related benchmarks.

DeepSeek-V4 is now used internally as the company’s agentic coding model. According to evaluation feedback, its user experience is better than Sonnet 4.5, and its delivery quality is close to Opus 4.6 in non-thinking mode. However, it still trails Opus 4.6 in thinking mode.

Rich World Knowledge

In world knowledge evaluations, DeepSeek-V4-Pro significantly outperforms other open-source models and is only slightly behind the top closed-source model, Gemini-Pro-3.1.

World-Class Reasoning Performance

Across evaluations in mathematics, STEM, and competitive programming, DeepSeek-V4-Pro surpasses all open-source models with public benchmark results to date, achieving performance comparable to the world’s leading closed-source models.

DeepSeek-V4-Flash: A Faster and More Cost-Efficient Option

Compared with DeepSeek-V4-Pro, DeepSeek-V4-Flash is slightly weaker in world knowledge, but demonstrates similar reasoning capabilities.

Because it has fewer parameters and lower activation requirements, V4-Flash can provide faster and more economical API service.

In agent evaluations, DeepSeek-V4-Flash performs on par with DeepSeek-V4-Pro on simple tasks, but still shows a gap on more difficult tasks.

Architectural Innovation and Highly Efficient Long Context

DeepSeek-V4 introduces a new attention mechanism that compresses along the token dimension. Combined with DSA sparse attention—DeepSeek Sparse Attention—it achieves globally leading long-context capability while substantially reducing compute and memory requirements compared with traditional approaches.

Starting now, 1M context will become the standard configuration for all official DeepSeek services.

Targeted Optimization for Agent Workloads

DeepSeek-V4 has been adapted and optimized for mainstream agent products such as Claude Code, OpenClaw, OpenCode, and CodeBuddy.

It shows improvements across code tasks, documentation generation, and related workflows. The following figure shows an example of a PPT slide generated by V4-Pro within an agent framework.

Scroll up and down or click to enlarge.

API Access

Due to limited access to high-end compute, Pro currently has very limited service throughput. Its pricing is expected to drop significantly in the second half of the year once Ascend 950 supernodes begin coming online at scale.

The DeepSeek API now supports both V4-Pro and V4-Flash, with compatibility for the OpenAI Chat Completions API and the Anthropic API.

The base_url remains unchanged. To access the new models, set the model parameter to one of the following:

deepseek-v4-pro
deepseek-v4-flash

Both V4-Pro and V4-Flash support a maximum context length of 1M tokens. Both models support non-thinking mode and thinking mode.

In thinking mode, the reasoning_effort parameter can be used to set the reasoning intensity:

high
max

For complex agent scenarios, we recommend using thinking mode and setting the reasoning intensity to max.

For model invocation and parameter configuration, please refer to the API documentation:

https://api-docs.deepseek.com/zh-cn/guides/thinking_mode

Please note that the two legacy API model names, deepseek-chat and deepseek-reasoner, will be discontinued in three months, on July 24, 2026.

During the transition period, these two model names will point to the following modes:

deepseek-chat      -> deepseek-v4-flash, non-thinking mode
deepseek-reasoner  -> deepseek-v4-flash, thinking mode

Open Weights and Local Deployment

DeepSeek-V4 model weights are available at:

https://huggingface.co/collections/deepseek-ai/deepseek-v4

https://modelscope.cn/collections/deepseek-ai/DeepSeek-V4

The DeepSeek-V4 technical report is available here:

https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro/blob/main/DeepSeek_V4.pdf

Closing Thoughts

“Do not be tempted by praise, do not fear criticism. Follow the right path, and hold yourself upright.”

Thank you to every user for your trust and support. Your recognition, suggestions, and expectations are what drive us to keep exploring and improving. They also remind us to stay true to our original mission and remain focused on continuous innovation.

We will continue to follow a long-termist approach, move forward steadily through experimentation and reflection, and keep working toward the goal of AGI.

GPT Image 2: What It Is, What It Can Do, and Why It's Different From Every AI Image Tool That Came Before

brooks wilson — Thu, 23 Apr 2026 03:56:15 +0000

On April 21, 2026, OpenAI dropped something the industry has been waiting on for about a year: GPT Image 2 (branded as ChatGPT Images 2.0 inside the chat product).

The launch wasn't quiet. Within 24 hours, GPT Image 2 was sitting at #1 across all three LM Arena image leaderboards — text-to-image (Elo 1512), single-image editing (1513), and multi-image editing (1464) — and had already been integrated by Figma, Canva, Adobe Firefly, fal, and Hermes Agent.

But the benchmark numbers aren't really the story. The story is this:

For the first time, an image model will stop, think about your request, search the web if it needs to, check its own work, and only then start drawing pixels.

That change sounds small when you summarize it. It isn't. It's the same architectural shift that turned chat models from "autocomplete engines" into something you can actually give a problem to. Now it's happening in image generation.

This is a long guide. Here's what it covers:

What GPT Image 2 actually is (and what's new about the architecture)
The five capabilities that make it a different category of tool
Five hands-on prompts I ran myself, with notes on why each one matters
Pricing, with real per-image cost math
Head-to-head comparison with Midjourney, Nano Banana Pro, Flux.2, and Stable Diffusion
Where GPT Image 2 still fails
How to use it in ChatGPT and through the API
FAQ

If you're evaluating whether to build image generation into your product — or whether to cancel your Midjourney subscription — the goal of this article is to save you two or three hours of research.

What Is GPT Image 2?

GPT Image 2 is OpenAI's third-generation native image generation model, and the first image model in the industry with built-in reasoning capabilities.

Two things in that sentence matter.

"Native" means GPT Image 2 generates images the same way GPT generates text: token by token, inside the language model itself. Older tools like DALL-E 3 were diffusion models bolted onto ChatGPT as an external module. GPT Image 2 is part of the same transformer stack that handles language, which is why it understands prompts the way it does. It knows what a "magazine cover" is because it knows what everything is — the same world knowledge that makes GPT-5 useful for text is now rendering pixels.

"Reasoning" means the model borrows the thinking-then-answering architecture from OpenAI's o-series. Before a single pixel is committed, GPT Image 2 can:

Analyze the semantic intent of your prompt
Plan composition, spatial layout, and typography
Reason about physical and logical constraints (shadows match the light source, reflections match geometry, text is legible at the intended size)
Search the web mid-generation for reference imagery or factual data
Generate multiple candidate images and self-select the best one

That loop is what "thinking mode" means in practice. The immediate consequence is that complex prompts — the kind that used to require three or four tries on older models — now succeed on the first attempt significantly more often.

The model ID for developers is gpt-image-2. It's live on ChatGPT, Codex, and the OpenAI API simultaneously, which is unusual — OpenAI typically staggers releases.

A Quick Family Tree

gpt-image-1 — April 2025. The first native image model inside GPT. Launched with the Studio Ghibli meme that briefly broke Twitter; 130M+ users generated 700M+ images in the first week.
gpt-image-1.5 — December 2025. Up to 4× faster, better instruction following on edits, warmer color cast.
gpt-image-2 — April 2026. Reasoning, 2K native resolution, near-perfect multilingual text, ~3 second generation, multi-image consistency. The warm color cast is gone.

Why Architecture Matters (Short Version)

If you want the technical reason GPT Image 2 behaves differently from Midjourney and Flux, it's this:

Diffusion models start with noise and gradually denoise toward an image. Stable Diffusion, Midjourney, Flux, DALL-E — all diffusion. The upside is beautiful gradients and painterly output. The downside is that the model doesn't really "know" what it's drawing halfway through; it's just denoising toward a target.

Autoregressive models write the image from left to right, token by token, the same way you'd write a sentence. Each visual token is conditioned on every token that came before it. The upside is logical consistency — if the model wrote "E = mc²" on a blackboard in the top-left, it knows that text is there when drawing the rest of the scene. The downside, historically, has been speed and resolution.

GPT Image 2 is autoregressive. Adding the reasoning step on top means the model plans the composition before it starts generating tokens, which reduces the chance of the sequence painting itself into a corner.

This is why you'll see GPT Image 2 nail things that stump diffusion models: precise text, 3×3 grids where each cell stays separate, infographics with real labels, UI mockups with working hierarchies. These are sequential logic problems, not aesthetic problems.

The Five Capabilities That Matter

1. Thinking Mode — The Headline Feature

GPT Image 2 has two modes:

Instant — Direct generation, ~3 seconds per image, similar UX to the older models. Available to all ChatGPT users including the free tier.
Thinking — The model reasons about composition, can search the web, generates multiple candidates, and self-checks outputs. Available to ChatGPT Plus, Pro, Business, and Enterprise users; available to all API users.

Thinking mode is where the bigger jumps in quality show up. Examples OpenAI highlighted at launch:

Page-long manga from a single prompt, with the same character drawn consistently across 6–8 panels
Full magazine layouts with proper headlines, subheads, body text, captions, and image placement
Design plans for every room in a house, maintaining a coherent aesthetic across images
Social media graphic sets (think: Instagram story + post + reel cover) with matching typography and brand feel

With thinking mode enabled, a single prompt can return up to 8 images at once. Consistency across those 8 images — same character, same product, same style — is what multi-image editing tools used to do in multiple manual passes.

2. Near-Perfect Multilingual Text Rendering

This is probably the single most important practical upgrade.

Text rendering has been the Achilles' heel of AI image generation since DALL-E. If you asked Midjourney to write a Chinese headline or a Japanese caption on a poster, you'd get convincingly font-like shapes that weren't actually characters. GPT Image 2 changes that.

LM Arena blind tests report near character-level 100% accuracy on short-to-medium text across English, Chinese (Simplified and Traditional), Japanese, Korean, Hindi, Bengali, and Arabic. One tester's quote captured the scale of the change: "The gap between GPT Image 2 and Nano Banana Pro on text is as big as the gap between Nano Banana Pro and DALL-E."

What this unlocks, concretely:

Localized marketing assets across multiple languages from a single prompt
Posters, packaging, and signage that ship without a Photoshop pass to fix the text
Infographics and charts with correct numerical labels and legends
UI mockups with real button labels, menu items, and status text
Multi-panel comics with coherent dialogue

Longer paragraph text — paragraphs of body copy inside a generated image — is still an area where Nano Banana Pro sometimes holds an edge. If you're generating document-style posters with a lot of small body text, test both before committing.

3. Native 2K Resolution, Experimental 4K

GPT Image 2 renders at up to 2048×2048 natively. Custom dimensions are supported as long as both edges are multiples of 16 and the total pixel count stays within the model's budget. Practical sizes include 1024×1024, 1920×1080, 2560×1440, and tall verticals like 1280×3840 for mobile-first content.

Above 2K, OpenAI officially labels the output "experimental." In practice: 4K sometimes works beautifully, sometimes shows artifacts at the edges or inconsistencies across large areas. The production-recommended workflow for anything beyond 2K is generate at 2K, then run through a dedicated upscaler like Magnific or Topaz. That path is also cheaper.

4. Precise Editing via Masked Inpainting and Outpainting

The editing endpoint supports mask images. You pass the original image plus a mask (black and white PNG indicating where changes are allowed), and the model modifies only the masked region — unrelated pixels stay pixel-identical.

Use cases where this is dramatically better than full-image regeneration:

Product photo background swaps — new setting, same product, same lighting
Packaging visualization — update copy or logos without redrawing the box
Outfit and accessory replacement — swap one item while preserving the rest of the scene
Iterative design refinement — change one element at a time across a long review cycle

In practical testing, GPT Image 2 handles chained edits (edit → edit → edit, building on each other) more stably than any of the competing models.

5. Speed: ~3 Seconds Per Image

Arena observers clocked GPT Image 2 at roughly 3 seconds per generation in instant mode. Nano Banana Pro takes 10–15 seconds. Midjourney V7 is typically 30–60 seconds for a standard grid.

Three seconds is an interactive experience. Ten seconds needs a loading animation. Thirty seconds is a queue. This is why the speed difference matters more than it looks on paper — the UX pattern for a 3-second model is completely different from the UX pattern for a 30-second model.

Thinking mode is slower, usually 15–40 seconds depending on prompt complexity, because the reasoning step generates additional tokens. Still faster than Midjourney, still plenty fast for batch workflows.

Five Hands-On Prompts, With Notes

These five prompts are designed to hit the specific capabilities listed above. Each one comes with a short note explaining what I was trying to stress-test and what the expected result shows. If you want to run them yourself, they work best in thinking mode.

Prompt 1 — Multilingual Magazine Cover

What this tests: The flagship capability. Text rendering across four scripts on a single composition (Latin, Chinese, Japanese, Korean, Arabic), combined with editorial layout discipline.

Why it matters: This is the single hardest thing to do with older models. Midjourney V7 will fail at the Chinese title; DALL-E 3 will fail at the Arabic subtitle; every diffusion model will mangle at least one of these scripts. If GPT Image 2 gets all of them right with correct typography and layout, that's the defining proof that this is a different category of model.

Prompt:

A vertical magazine cover titled "AI 浪潮" in bold modern Chinese 
typography, with English subtitle "Issue No.47 — The GPT Image 2 Era". 
Below, three smaller headlines in three languages:
- 日本語：「画像生成の新時代」
- 한국어："이미지 생성의 미래"
- العربية: "عصر جديد"

Design style: editorial minimalism, deep navy background with a soft 
orange accent stripe on the left edge, photorealistic lighting, paper 
texture. The Chinese main title takes up roughly 40% of the cover 
height. Price tag: $9.99 in the bottom right corner.

Prompt 2 — Infographic with Real Data

What this tests: Structured layout with multiple content zones, data visualization (a simple line chart), mixed typography at different sizes, and — critically — correctly rendered numerical labels. Plus, the content itself is a meta joke: it's an infographic about GPT Image 2, which means I'm asking the model to describe its own capabilities on a poster.

Why it matters: Infographics are what Midjourney and older diffusion models completely collapse on. The data points have to line up, the labels have to be readable, the hierarchy has to make sense. This is also the exact use case most business users care about — quarterly reports, product one-pagers, pitch deck slides.

Prompt:

A clean vertical infographic titled "GPT Image 2 at a Glance".

- Header: a small abstract geometric logo "G2", subtitle 
  "Released April 21, 2026"
- Section 1: a simple line chart showing "Text Accuracy" rising from 
  71% (Midjourney V7) → 87% (GPT Image 1.5) → ~100% (GPT Image 2). 
  Label each data point clearly.
- Section 2: three small stat cards — "2K native resolution", 
  "~3 sec per image", "$0.21 per HD image"
- Section 3: a horizontal bar labeled "Supports: English · 中文 · 
  日本語 · 한국어 · हिन्दी · বাংলা · العربية"

Sans-serif typography, off-white #F9F9F8 background, navy and warm 
orange as accent colors, flat vector style, Apple-like clean layout. 
Readable at mobile size.

Prompt 3 — Photorealistic App UI Mockup

What this tests: Object realism (an iPhone) combined with screen-within-screen generation — the model has to render both the physical device and a plausible UI running on it. Status bar details, button states, and small UI text all need to be right.

Why it matters: Product teams spend a lot of time making mockups for investor decks, design reviews, and marketing pages. If GPT Image 2 can generate convincing device mockups from a text description, that's hours saved per sprint. This capability was what convinced LM Arena testers that the model was a step-change — UI reconstruction is another problem that's really a sequential-logic problem disguised as a visual one.

Prompt:

A photorealistic iPhone 16 Pro mockup floating at a slight angle on a 
soft gray gradient background. On the screen: a mobile app UI titled 
"ImageLab" with:

- Top nav: "Home · Create · Gallery" tabs, the middle one highlighted 
  in orange
- Main area: a 2×2 grid of generated image thumbnails with captions 
  "Portrait · Product · Infographic · Poster"
- Bottom: a prompt input bar with placeholder text "Describe what you 
  want to create..." and a blue "Generate" button
- Status bar shows 9:41, full battery, 5G

Style: clean SaaS product UI, subtle drop shadows, realistic glass 
reflection on the phone screen, studio lighting. Add a small floating 
caption under the phone that reads "Built with GPT Image 2".

Prompt 4 — Four-Panel Comic With Character Consistency

What this tests: Multi-image consistency, one of the headline features of thinking mode. The same character has to appear in all four panels with recognizable facial features, clothing, and hairstyle — while the expression, pose, and background change. Dialogue bubbles have to read correctly. Panel layout has to follow Western reading order.

Why it matters: Multi-panel consistency is the capability that separates "image generator" from "visual storytelling tool." Without it, you can't make comics, storyboards, product sequences, or tutorial illustrations without heavy manual work. OpenAI put a ton of weight on this at launch — page-long manga from a single prompt was one of their flagship demos.

Prompt:

A 4-panel black-and-white manga-style comic strip, arranged 2×2, with 
clean dialogue bubbles in English.

- Panel 1: A tired-looking designer at a messy desk, surrounded by 
  printed drafts. Thought bubble: "I need 20 variations by tomorrow..."
- Panel 2: The designer types a prompt into a laptop glowing with a 
  subtle "GPT Image 2" UI. Motion lines suggest speed.
- Panel 3: A wide shot of a grid of finished posters appearing on the 
  screen, each clearly different but on-brand. Designer's eyes wide 
  with shock: "Wait, all of them... in one shot?"
- Panel 4: The designer leaning back, coffee in hand, feet on desk, 
  monitor in background showing "✓ Done". Caption at the bottom: 
  "The new creative workflow."

Style: crisp ink lines, screentone shading, consistent character 
design across all 4 panels.

Prompt 5 — Commercial Product Shot With Two Types of Text

What this tests: The all-in-one challenge. Photorealism, material rendering (matte metal, walnut wood, leather), controlled depth of field, studio-grade lighting — and two different kinds of text in the same image (engraved serif on the pen, handwritten cursive on the card). A lot of specialized photography skills compressed into one prompt.

Why it matters: This is what real commercial use looks like. Product photographers charge hundreds of dollars per shot to set up this kind of scene. If GPT Image 2 can produce a usable version of it, it's not just a curiosity — it's a production tool. This is also the prompt where material realism matters most, and where Flux.2 Pro historically held an edge. Worth seeing whether GPT Image 2 has closed that gap.

Prompt:

A hyper-realistic product hero shot of a minimalist matte-black 
fountain pen lying at a slight angle on a smooth dark walnut desk 
surface.

- Engraved on the pen barrel in fine silver serif text: 
  "CRAFTED FOR CLARITY · EST. 2026"
- Next to the pen, a small folded card with handwritten cursive text 
  that reads: "Dear Reader, thank you for choosing us."
- Soft window light from the top-left, creating long gentle shadows 
  and a subtle highlight on the metallic clip.
- Shallow depth of field, the back of the desk softly out of focus, 
  with a hint of a leather notebook and a cup of black coffee.

Photography style: commercial editorial, shot on Phase One, 85mm, f/2.8.

Pricing: ~$0.21 Per HD Image, Thinking Mode Extra

OpenAI prices GPT Image 2 by tokens, not by image. Here's the rate card:

Item	Price per 1M tokens
Text input	$5
Text output	$10
Image input	$8
Image input (cached)	$2
Image output	$30

Translated to per-image costs at common sizes:

Size	Quality	Approximate cost
1024×1024	Low	$0.006
1024×1024	Medium	$0.053
1024×1024	High	$0.211
1024×1536	Low	$0.005
1024×1536	Medium	$0.041
1024×1536	High	$0.165

A few things worth noting:

At 1024×1024 high quality, GPT Image 2 is about 60% more expensive than GPT Image 1.5 ($0.211 vs $0.133). That's the cost of the larger internal canvas and the reasoning step. But at 1024×1536, GPT Image 2 is actually cheaper than its predecessor ($0.165 vs $0.20). The pricing math shifts with aspect ratio in non-obvious ways, so benchmark for your exact use case.

Thinking mode consumes additional reasoning tokens. A simple illustration prompt might add a few thousand reasoning tokens. A multi-panel comic with complex layout constraints can add a lot more. Budget for variable per-image cost when doing layout-heavy work, not a flat rate.

Cached image inputs are 4× cheaper ($2 vs $8 per million tokens). If you're doing iterative editing on the same source image, the second and subsequent requests get a meaningful discount.

For high-volume use cases, the cost ladder typically looks like:

Iterate 10–20 drafts at quality=low (~$0.006 each)
Narrow to 2–3 directions at quality=medium
Render the final at quality=high

This keeps the total spend per final asset under $0.50 even for complex work.

GPT Image 2 vs Midjourney vs Nano Banana Pro vs Flux.2

There's no single winner. Each model is optimized for a different primary constraint.

Dimension	GPT Image 2	Nano Banana Pro	Midjourney V7	Flux.2 Pro	Stable Diffusion / DALL-E 3
Architecture	Native autoregressive + reasoning	Multimodal diffusion + search grounding	Diffusion	Diffusion	Diffusion
Text rendering	~100%, multilingual	87–96%, strong on long paragraphs	~71%, weak	Mid	Weak
Reasoning	✅ o-series thinking	✅ Search grounding	❌	❌	❌
Speed	~3s / ~15–40s thinking	10–15s	30–60s	5–10s	5–20s
Native resolution	2K (4K experimental)	4K native	2K	2K	1–2K
API access	✅	✅ Vertex AI	❌ Discord/web only	✅	✅
Strengths	Text, reasoning, UI, infographics, speed	Consistency, 4K, long-form editing	Artistic style, cinematic look	Material realism	Open source, self-hostable
Weaknesses	Portrait realism, spatial reasoning (reflections)	Speed	No API, no precise control	Instruction following	Text, complex instructions
Cost per HD image	~$0.21	~$0.039–$0.151	~$0.033 (subscription)	$0.06–$0.15	Near-zero (self-hosted)

Which Should You Actually Use?

Pick GPT Image 2 when: you need accurate text, you're generating UI mockups, you're doing infographics or data viz, you want reasoning over composition, you need the fastest generation in production, or you want integration with the rest of the OpenAI stack.

Pick Nano Banana Pro when: you need true 4K, you need 14-image reference capability, you need maximum consistency across many edits, or you need SynthID watermarking for compliance. It's also the current choice for enterprise through Google Cloud with copyright protection.

Pick Midjourney when: you need art direction, cinematic mood, stylistic coherence, or aesthetic output for creative applications. Midjourney still wins on pure aesthetic. No API, so automation isn't an option.

Pick Flux.2 when: you need material realism (fabrics, skin, surfaces) or you need an open-source model you can self-host and fine-tune on your own data.

Pick Stable Diffusion / open-source models when: cost per image must approach zero, you need custom training, or you have regulated data that can't leave your infrastructure.

A pattern that's emerged in 2026: production teams run two models in parallel. Midjourney for concepts and moodboards, GPT Image 2 or Nano Banana Pro for final production assets. The subscription math still works out because each tool is better at its specific job.

Where GPT Image 2 Still Fails

It's not flawless. Things to watch for:

Portrait realism at close range. LM Arena blind tests show Nano Banana Pro ahead on fine skin texture, hair detail, and emotional nuance in portraits. If you're doing fashion photography or beauty close-ups, test both.

Spatial reasoning on reflective surfaces. The classic failure case is a Rubik's cube in a mirror — the reflection should be geometrically correct, and GPT Image 2 sometimes gets this wrong. If your scene depends on precise reflection physics (a product in a mirror, a character reflected in a store window), verify before shipping.

Multi-reference consistency over long sequences. Thinking mode maintains consistency across 6–8 images from a single prompt. Beyond that — a 12-panel story, a 20-shot product catalog — consistency starts drifting. Nano Banana Pro with its 14-image reference capability handles longer sequences better.

Dense body paragraphs. Single headlines, short captions, UI labels — GPT Image 2 is near-perfect. Long paragraphs of small body text in a poster-style image still occasionally have artifacts. Nano Banana Pro is currently better for document-style output.

Real person likenesses. OpenAI's safety layer actively blocks generation of recognizable real people. If your workflow needs celebrity likenesses or real-person reference, this is a hard limit and won't change.

4K at production quality. Experimental for a reason. Use 2K + upscaler instead.

How to Use It: ChatGPT and API

In ChatGPT

As of April 22, 2026, every ChatGPT and Codex user can use ChatGPT Images 2.0 directly in the web or mobile interface. The entry point is the same as before — just prompt for an image.

Free users: instant mode only
Plus ($20/month) and above: instant + thinking mode, web search during generation, multi-image consistency, up to 8 images per prompt

Inside Codex, image generation is integrated into the workspace and does not require a separate API key.

Via API

The endpoint follows the same /images/generations pattern as previous models. Pass gpt-image-2 as the model ID.

Python example:

from openai import OpenAI
client = OpenAI()

response = client.images.generate(
    model="gpt-image-2",
    prompt="A hyperrealistic fountain pen on a walnut desk...",
    size="1024x1024",
    quality="high",
    reasoning_effort="medium"  # optional: enables thinking mode
)

image_url = response.data[0].url

Key parameters:

size — any dimensions where both edges are multiples of 16 and total pixels stay within budget
quality — low / medium / high. Start with low during iteration.
reasoning_effort — minimal / low / medium / high. Controls thinking mode strength. Higher effort burns more reasoning tokens but improves first-attempt success on complex layouts.

For editing, the /images/edits endpoint accepts an image URL plus an optional mask PNG:

response = client.images.edit(
    model="gpt-image-2",
    image=open("product.png", "rb"),
    mask=open("background-mask.png", "rb"),
    prompt="Replace the background with a dramatic overcast sky",
    quality="high"
)

Rate limits and batch behavior are documented in the OpenAI API docs. Queue-based async patterns are supported through the standard job endpoints and also through third-party platforms like fal if you need higher throughput.

Practical Tips (From Running It for a Week)

1. Start every project at quality=low. The cost drops 35× compared to high quality, and low quality is genuinely usable for ideation. Switch to high only once direction is locked.

2. For text-heavy prompts, always turn on thinking mode. The first-attempt success rate improvement is large enough to save money on retries even after accounting for reasoning token cost.

3. Vertical and portrait formats are often cheaper. 1024×1536 high quality is $0.165, less than 1024×1024 at $0.211. Optimal for mobile-first content (Instagram, TikTok, WeChat) anyway.

4. Don't force 4K in production. Use 2K + a dedicated upscaler. More reliable, cheaper.

5. For portraits and fashion work, keep a Nano Banana Pro or Flux.2 backup. GPT Image 2 is great for most things, but these are the two domains where it sometimes loses.

6. Cache image inputs for iterative edits. The 4× discount on cached image tokens adds up fast over a review cycle.

7. Use the reasoning_effort parameter strategically. minimal for simple illustration prompts, medium for standard work, high only for complex layouts where first-attempt success actually matters.

FAQ

What's the difference between ChatGPT Images 2.0 and GPT Image 2?
Same thing, two names. ChatGPT Images 2.0 is the consumer product name; gpt-image-2 is the API model ID.

Is it free for ChatGPT users?
Instant mode is free for everyone including the free tier. Thinking mode, web search during generation, and multi-image consistency are limited to Plus, Pro, Business, and Enterprise plans.

What does one high-quality image cost through the API?
About $0.211 at 1024×1024 and $0.165 at 1024×1536. Thinking mode adds variable reasoning token costs on top. Budget $0.25–$0.40 per complex thinking-mode image to be safe.

Can it generate images of real people?
Not recognizable real people — OpenAI's safety layer blocks this at both the input and output stages. Fictional characters, generic people, and stylized representations are fine.

Does it replace Midjourney?
For text, UI, infographics, and technical work — yes, immediately. For aesthetic concept art and cinematic mood pieces — no, Midjourney's artistic sensibility is still unmatched. Many teams subscribe to both and route by use case.

Is the output commercially usable?
Yes. Generated images follow OpenAI's standard commercial usage terms. All outputs include C2PA metadata identifying the model, which helps with provenance but does not restrict use.

Can I run it offline or self-host it?
No. GPT Image 2 is closed-source and only available through OpenAI's API or through platforms that proxy to it (Azure Foundry, fal, OpenRouter, and similar). For self-hosting, look at Flux.2 or Stable Diffusion.

Bottom Line

GPT Image 2 isn't a replacement for Midjourney or a clone of Nano Banana Pro. It's the first image model that reasons before it draws — the same architectural shift that turned chat models into thinking assistants, now applied to pixels.

Three things are worth your attention:

Multilingual text rendering is effectively solved, which means a huge category of business visuals (posters, infographics, localized ads, UI mockups) can skip the Photoshop pass
Thinking mode + multi-image consistency means comics, storyboards, design systems, and product catalogs can be generated in coherent batches rather than one-at-a-time retries
~3 seconds per image at $0.21 makes GPT Image 2 viable as a production API, not just a creative toy

For founders, developers, designers, and content creators, this is the most significant image model update since Midjourney V6. If you've been waiting for the moment to build image generation into a product, this is it.

The next 6 months will be about seeing what people actually make with it. I'll be watching.

An Anonymous Model Just Took #1—and Flipped the AI Video Race Overnight

brooks wilson — Sat, 11 Apr 2026 15:31:22 +0000

How “HappyHorse” Disrupted the AI Video Generation Landscape

A Sudden Shift in the Rankings

On April 7, the global AI community woke up to an unexpected development: a previously unknown model named HappyHorse-1.0 appeared at the top of the Artificial Analysis Video Arena leaderboard.

The reaction was immediate and widespread. Developers and researchers began sharing results and speculating about its origin. The model demonstrated capabilities that felt notably ahead of what many had seen in production systems.

Within hours:

It ranked #1 in text-to-video with a score of 1332
Achieved 1391 in image-to-video, setting a new record
Placed #2 globally in audio-integrated video generation

The margin wasn’t incremental—it was decisive. The previous leader, ByteDance’s Seedance 2.0, was surpassed by nearly 60 points.

A Carefully Orchestrated Release

The timeline suggests this was not a spontaneous breakthrough, but a deliberate rollout.

Early April 7 (UTC): HappyHorse-1.0 appears on the leaderboard
Morning: Discussion spreads rapidly across X (Twitter) and developer communities
Afternoon: Speculation intensifies—possible origins include Alibaba, ByteDance, Tencent, or even DeepSeek
April 8 (Market Open): Alibaba’s stock rises significantly, reflecting market speculation
Later that day: A website appears claiming full open-source release, including:
- Base model
- Distilled variants
- Super-resolution modules
- Inference code

This sequence reveals three key signals:

1. Timing Was Strategic

The model was likely developed over months and released at a moment designed to maximize visibility and impact.

2. Anonymity Was Intentional

A team capable of building such a system would not lack marketing channels. Remaining anonymous suggests one of two goals:

Avoid disrupting existing commercial products
Test market and community reactions

3. Open Source Was the Real Move

Releasing a state-of-the-art model as open source fundamentally lowers barriers across the industry.

Closed models compete on pricing and access. Open models reshape the baseline.

What Makes HappyHorse Technically Notable?

1. Ultra-Fast Inference

Traditional video diffusion models typically require dozens to hundreds of denoising steps.

Seedance 2.0: ~2–4 minutes per video
HappyHorse: ~8 steps, under 1 minute

Notably, it achieves this without classifier-free guidance (CFG).

This has direct implications:

Lower compute cost (roughly halved)
Higher throughput for production workloads
Better scalability for content pipelines

For teams producing video at scale, this translates into significant operational efficiency gains.

2. Native Audio-Video Generation

HappyHorse adopts a joint audio-video generation architecture, producing:

Environmental sound
Background music
Dialogue

All synchronized at millisecond-level precision.

This eliminates the need for post-processing steps like:

Audio alignment
Manual dubbing
Timeline synchronization

In practice, this moves output closer to production-ready assets.

3. Diffusion Transformer (DiT) Architecture

The model reportedly uses:

40-layer single-stream Transformer
8-step diffusion inference

This aligns with the Diffusion Transformer (DiT) approach, known for:

Faster inference
Strong controllability
Optimization-friendly structure

This design choice is consistent with Alibaba’s Wan series, which has emphasized:

Unified audio-video generation
High-speed inference
Transformer-based diffusion

From a technical perspective, HappyHorse appears to be a more mature iteration of this direction.

Why Many Believe It’s Alibaba

While initially anonymous, several factors point toward Alibaba:

The architecture aligns closely with the Wan model family
Alibaba released Wan 2.7 Video just days earlier
The timing suggests a two-step strategy:

Launch a commercial product (Wan 2.7)
Follow with an open-source release (HappyHorse)

Additionally, the involvement of Zhang Di, a former key contributor to Kuaishou’s Kling AI, fits the timeline:

Joined Alibaba in late 2025
Led video generation efforts
Delivered a major release within ~4 months

This combination of talent and timing strengthens the attribution hypothesis.

Strategic Implications: Open Source vs Closed Models

Alibaba’s potential strategy becomes clearer when viewed through a product lens.

Dual-Track Positioning

Wan 2.7: Enterprise-grade, paid API
- Stability
- Control
- Support
HappyHorse: Open-source ecosystem driver
- Community adoption
- Developer engagement
- Talent attraction

This allows Alibaba to:

Maintain revenue from enterprise customers
Expand influence through open-source adoption
Avoid cannibalizing its own pricing model

Pressure on Competitors

For ByteDance (Seedance):

Option 1: Accelerate Seedance 3.0
Option 2: Compete on price

Both increase cost and competitive pressure.

For smaller developers:

Open-source alternatives reduce reliance on expensive APIs
Cost-sensitive teams may shift away from closed platforms

Why Open Source Hits Competitors Harder

Open source changes the economics:

Closed models rely on compute-heavy APIs
Open models shift cost to local or distributed deployment

In this context, open source acts less as a monetization tool and more as a strategic lever.

Industry Context: Competition Is Intensifying

The AI video generation space is entering a more competitive phase:

OpenAI’s Sora
ByteDance’s Seedance
Kuaishou’s Kling
Alibaba’s Wan / HappyHorse

Each iteration pushes:

Generation quality
Latency reduction
Cost efficiency

The pace of progress is accelerating, and the gap between research and production systems continues to shrink.

Final Thoughts

Whether HappyHorse ultimately proves as strong as initial benchmarks suggest is still subject to verification. Some details remain unconfirmed, and official sources are limited.

However, regardless of attribution, the signal is clear:

Inference efficiency is becoming a primary battleground
Audio-video integration is moving toward default capability
Open vs closed strategies will shape market structure

The AI video race is no longer just about model quality—it’s about distribution, cost, and ecosystem control.

And that competition is only getting started.

Happy Horse 1.0: What We Actually Know About the Model That Topped Artificial Analysis' Video Arena

brooks wilson — Wed, 08 Apr 2026 15:16:45 +0000

Happy Horse 1.0: What We Actually Know About the Model That Topped Artificial Analysis' Video Arena

An unfamiliar model called HappyHorse-1.0 is currently sitting at #1 on Artificial Analysis' Video Arena, the blind user-voted benchmark widely used to evaluate AI video generation systems. This post summarizes what's verifiable from public sources and what remains unconfirmed, because the gap between those two categories is larger than usual for a model at this rank.

What's on the leaderboard

From Artificial Analysis' public text-to-video (no audio) leaderboard, as of April 8, 2026:

Rank Model Creator Elo 95% CI Samples

1 HappyHorse-1.0 HappyHorse 1,355 ±11 5,062

2 Dreamina Seedance 2.0 720p ByteDance Seed 1,273 ±8 8,130

3 SkyReels V4 Skywork AI 1,245 ±9 5,712

4 Kling 3.0 1080p (Pro) KlingAI 1,242 ±9 5,262

5 Kling 3.0 Omni 1080p (Pro) KlingAI 1,230 ±10 4,776

Three observations worth pulling out:

The gap is statistically clean. An 82-point Elo lead over #2 is not within the noise floor of a preference-based arena. HappyHorse-1.0's confidence interval (1,344–1,366) doesn't overlap with Seedance 2.0's (1,265–1,281). That's a clean separation, not a coin flip.

The sample size is real. 5,062 blind matchups is the same order of magnitude as the #3 and #4 entries, which means the Elo isn't riding on a lucky early streak. It's been stable across thousands of votes.

API status is "Coming soon." The row on the leaderboard lists API availability as pending. The model is generating output on the arena but is not yet broadly available for production use.

What the model claims about itself

Here's where I want to be careful, because the information below comes from sites associated with the project (primarily happyhorse-ai.com and happyhorses.io) and has not been independently verified by any third party as of this writing.

According to these sources, HappyHorse-1.0 is described as:

A 15B-parameter unified transformer (the parameter count appears on secondary documentation, not on Artificial Analysis itself).
A 40-layer self-attention architecture with no cross-attention. First and last 4 layers use modality-specific projections; the middle 32 layers are shared across text, video, and audio tokens.
Trained to run inference in 8 denoising steps without CFG, via a DMD-2 distillation recipe.
Reportedly capable of generating a 5-second 1080p clip in ~38 seconds on an H100 (self-reported).
Natively supporting joint audio-video generation across 6 languages (English, Mandarin, Japanese, Korean, German, French; a secondary site lists Cantonese as a 7th).

If these numbers are accurate, the architecture would represent a fairly aggressive bet on unified multimodal transformers over the multi-stream cross-attention approaches that most current video models use. It would also place HappyHorse-1.0 in the same design family as Meta's Transfusion line of research, though there is no direct connection established between the projects.

None of these claims can be independently verified right now. The GitHub and HuggingFace links referenced on the project's own sites currently point to "coming soon" placeholders. No weights, no reproducible demo outside the arena, no third-party benchmark of inference speed or memory footprint.

Who built it

As of April 8, no team or organization has officially claimed HappyHorse-1.0. The most widely discussed attribution in the Chinese tech press, now circulating in English AI circles, links the model to a new team reportedly led by Zhang Di — the former VP at Kuaishou who led the Kling video generation effort, and who reportedly joined Alibaba in late 2025 to run the Future Life Lab inside the Taotian Group.

I want to stress: this is the most credible theory currently in circulation, but it is not confirmed. Alibaba has not commented. No one publicly associated with HappyHorse has confirmed or denied it. Other community speculation has pointed to alternative origins. If you're making engineering or editorial decisions based on the attribution, wait for official confirmation.

What this means if you evaluate video models

If you benchmark video models before integrating them into a pipeline, the honest summary is:

The leaderboard result is real. Blind user preferences, 5,000+ matchups, clean confidence intervals. That's not marketing; that's what the arena is designed to measure.
Everything else is not yet real for you. No weights, no API, no reproducible local run. You can't currently fine-tune it, can't self-host it, can't measure its latency on your own hardware, can't verify the claimed architecture.
The "what" is known. The "how" and "by whom" are not.

That combination is unusual at the top of the leaderboard. Most models at this rank come with a paper, a model card, a team announcement, and at least an API. HappyHorse-1.0 currently has a leaderboard row and a set of unverifiable claims. That may change quickly — the project sites describe an imminent broader release — or it may not.

Sources

Artificial Analysis Video Arena (live leaderboard): https://artificialanalysis.ai/video/leaderboard/text-to-video
HappyHorse-1.0 public testing interface and current technical spec: https://happyhorses.io
Chinese-language reporting referencing the Zhang Di / Future Life Lab attribution is cited across several tech media outlets as of April 7–8, 2026

Leaderboard rankings are dynamic and may shift as new votes and new models are added.

Claude Code Architecture Explained: Agent Loop, Tool System, and Permission Model (Rust Rewrite Analysis)

brooks wilson — Thu, 02 Apr 2026 03:09:58 +0000

Claude Code Deep Dive (Part 1): Architecture Overview and the Core Agent Loop

Claude Code’s leaked source code weighs in at over 510,000 lines of TypeScript—far too large to analyze directly.

Interestingly, a community-driven Rust rewrite reduced that complexity to around 20,000 lines, while still preserving the core functionality.

Starting from this simplified version makes one thing much clearer:

What does an AI agent system actually need to work?

Why Start with the Rust Rewrite?

On March 31, 2026, Claude Code’s full source was unintentionally exposed due to an npm packaging mistake.

The package @anthropic-ai/claude-code v2.1.88 included a 59.8MB source map file, which allowed anyone to reconstruct the original TypeScript codebase.

To clarify:

The official GitHub repo always existed
But it only contained compiled bundles and documentation
The readable source code was not normally accessible

The Problem with the Original Codebase

Most analyses focused on the leaked TypeScript code:

510K+ lines
QueryEngine alone: ~46K lines
40+ tools
Complex plugin system

The result: too much detail, not enough clarity.

Why the Rust Version Is More Useful

Shortly after the leak:

Developer Sigrid Jin (instructkr community)
First built a Python clean-room version
Then pushed a Rust implementation (claw-code)

👉 Project overview: claw-code

This version:

~20K lines of Rust
Retains core functionality:
- Agent loop
- Tool system
- Permission control
- Prompt system
- Session management
- MCP protocol
- Sub-agents

The key benefit:

Rewriting forces simplification. What remains is what actually matters.

Architecture Overview: A 6-Module System

The Rust implementation is structured into six modules:

claw-code/
├── runtime/          # Core runtime: loop, permissions, config, session, prompt
├── api/              # LLM client, SSE streaming, OAuth
├── tools/            # Tool registry and execution
├── commands/         # Slash commands (/help, /cost)
├── compat-harness/   # TS → Rust compatibility layer
└── rusty-claude-cli/ # CLI, REPL, terminal rendering

These modules form a layered architecture:

CLI / REPL (User Interaction)
─────────────────────────────
MCP Protocol · Sub-agents (Extension Layer)
─────────────────────────────
API Client · Session Management (Communication Layer)
─────────────────────────────
System Prompt · Config (Context Layer)
─────────────────────────────
Agent Loop · Tools · Permissions (Core Layer)

A Key Design Decision

The runtime module defines interfaces, not implementations:

ApiClient → LLM communication
ToolExecutor → tool execution

Concrete implementations live at the top (CLI layer).

This enables:

Mock implementations for testing
Real implementations for production
Zero changes to core logic

Testability is built into the architecture—not added later.

The Core: An 88-Line Agent Loop

If you only read one file, read this:

conversation.rs

The entire agent loop is implemented in ~88 lines.

Runtime State: Simpler Than Expected

AgentRuntime {
    session            # message array (the only state)
    api_client         # LLM interface
    tool_executor      # tool execution
    permission_policy  # access control
    system_prompt
    max_iterations
    usage_tracker
}

The surprising part:

The only state is a message array.

No explicit state machine. No workflow graph.

The Core Loop: `run_turn()`

Here’s the simplified logic:

```python id="n6pj6p"
def run_turn(user_input):
session.messages.append(UserMessage(user_input))

while True:
    if iterations > max_iterations:
        raise Error("Max iterations exceeded")

    response = api_client.stream(system_prompt, session.messages)

    assistant_message = parse_response(response)
    session.messages.append(assistant_message)

    tool_calls = extract_tool_uses(assistant_message)

    if not tool_calls:
        break

    for tool_name, input in tool_calls:
        permission = authorize(tool_name, input)

        if permission == Allow:
            result = tool_executor.execute(tool_name, input)
            session.messages.append(ToolResult(result))
        else:
            session.messages.append(
                ToolResult(deny_reason, is_error=True)
            )




---

## A Concrete Example

User asks:

> “What is 2 + 2?”

Execution flow:

| Step   | Message State              | Description              |
| ------ | -------------------------- | ------------------------ |
| Start  | `[User("2+2")]`            | User input               |
| API #1 | + Assistant (calls tool)   | Model decides to compute |
| Tool   | + ToolResult("4")          | Tool executes            |
| API #2 | + Assistant("Answer is 4") | Final answer             |
| End    | Loop exits                 | No more tool calls       |

Termination condition:

> The model decides to stop calling tools.

---

## Key Design Insight #1: Messages = State

Instead of managing state explicitly:

* The system stores everything as messages
* The full state is reconstructible from history

Benefits:

* Easy persistence (save session)
* Easy replay (debugging)
* Easy compression (context trimming)

> One append-only structure solves multiple problems.

---

## Key Design Insight #2: Errors Are Feedback

When a tool is denied:

* The system does **not** crash
* It returns an error as a `ToolResult`

This is fed back to the model.

Result:

* The model adapts
* Chooses alternative strategies

> Failure becomes part of the reasoning loop.

---

## Tool System: 18 Tools, One Pattern

The Rust version implements 18 built-in tools in a unified structure.

---

### Three Layers



```plaintext
1. Tool Registry     → defines schema and permissions
2. Dispatcher        → routes tool calls
3. Implementation    → executes logic

Tool Specification

```json id="i9j1sx"
{
"name": "bash",
"description": "Execute shell commands",
"input_schema": {
"command": "string",
"timeout": "number?"
},
"required_permission": "DangerFullAccess"
}




This schema is passed directly to the LLM.

---

### Why JSON Schema Matters

* Decouples LLM from implementation
* Enables language-agnostic tools
* Standardizes interfaces

> Schema = contract

---

### Dispatcher Pattern



```python id="5g5syv"
def execute_tool(name, input):
    match name:
        "bash" -> run_bash()
        "read_file" -> run_read()
        ...

Adding a tool:

Define input struct
Implement logic
Add one dispatch line

Sub-Agent Design

Sub-agents reuse the same runtime:

```python id="5y9zsl"
runtime = AgentRuntime(
session = new_session,
tool_executor = restricted_tools,
permission = high,
prompter = None
)




Key constraint:

* Sub-agents cannot spawn sub-agents

This prevents recursion loops.

---

## Permission System: Minimal but Complete

The system uses **5 permission levels**:

* ReadOnly
* WorkspaceWrite
* DangerFullAccess
* Prompt
* Allow

---

### Core Logic



```python id="9t9ahj"
if current >= required:
    allow
elif one_level_gap:
    ask_user
else:
    deny

Design Insight: Gradual Escalation

Instead of:

All-or-nothing access

It uses:

Controlled escalation

Small gap → ask user
Large gap → deny

Sub-Agent Safety Model

Sub-agents:

Have high permission
But no user prompt interface

Result:

Allowed within scope
Automatically blocked outside

Two mechanisms combine into precise control.

Part 1 Summary

Claude Code’s core reduces to three components:

Agent Loop     → execution engine
Tool System    → action layer
Permissions    → safety control

Key principles:

Messages are the only state
LLM decides when to stop
Tools are schema-driven
Errors are part of reasoning
Permissions are incremental

Final Thought

After stripping away 500K lines of code, what remains is surprisingly small:

A loop, a tool interface, and a permission system.

That’s enough to build a functional AI agent.

But making it robust, scalable, and safe—that’s where the real complexity begins.

Next Part

Claude Code Deep Dive (Part 2): Context Engineering and Design Patterns

Prompt construction
Config merging
Context compression
Practical design takeaways

References

Claw Code (Rust rewrite): https://github.com/instructkr/claw-code
Project site: https://claw-code.codes/
Claude Code official repo: https://github.com/anthropics/claude-code

Claude Mythos 5 Leak: Anthropic’s “Capybara” Model Surpasses Opus 4.6

brooks wilson — Sun, 29 Mar 2026 16:04:34 +0000

Anthropic Just Leaked a Model Stronger Than Opus — And It Might Be Too Powerful

Anthropic may have just revealed its most powerful model yet — unintentionally.

No rumors. No controlled announcement. No staged “insider leak.”

Instead, a misconfigured CMS exposed nearly 3,000 internal documents to the public internet, which were subsequently reviewed by a Fortune journalist. A Cambridge cybersecurity researcher, Alexandre Pauwels, was brought in to validate the materials. Anthropic later confirmed: the model is real.

The model is called Claude Mythos.
Its internal codename: Capybara.
Some information about mythos-5:https://m1astra-mythos.pages.dev/

A New Tier Above Opus

Anthropic’s model lineup has followed a familiar three-tier structure:

Haiku — lightweight and fast
Sonnet — balanced performance
Opus — largest and most capable

For a long time, Opus has been treated as the ceiling.

Mythos breaks that assumption.

According to internal draft materials, Mythos is not an iteration of Opus, nor a refinement of Sonnet. It represents:

“A new tier of model, larger and more intelligent than Opus.”

In other words, this is not incremental progress — it’s a structural expansion of the product hierarchy.

If Opus 4.6 already feels state-of-the-art, Mythos is positioned as something beyond that baseline.

How Much Stronger Is It?

The leaked documents indicate that Mythos achieves significantly higher performance than Claude Opus 4.6 across multiple domains.

At minimum, three areas stand out:

1. Software Engineering

Programming is currently one of the most competitive benchmarks in AI.

Claude Opus 4.6 is already considered among the strongest coding models available. Mythos reportedly extends that lead further — not by marginal gains, but by a noticeable margin.

For developers relying on Claude for daily coding tasks, this suggests:

A step change in capability, not a minor improvement.

2. Academic Reasoning

This includes:

Mathematics
Scientific reasoning
Formal logic

The internal drafts explicitly highlight “academic reasoning” as a separate evaluation category, where Mythos shows clear improvements.

This is typically where models struggle with depth and consistency.
Anthropic appears confident enough in this area to emphasize it directly.

3. Cybersecurity (The Most Concerning Part)

This is where the tone of the internal documents shifts.

One excerpt stands out:

Although Mythos significantly exceeds all other AI models in cybersecurity capabilities, it signals an upcoming wave where models may exploit vulnerabilities faster than defenders can respond.

This is not typical product language.

Not “leading”
Not “competitive”
But “significantly exceeds”

And importantly, this comes from internal evaluation — not marketing copy.

Anthropic’s spokesperson described Mythos as:

A “qualitative leap”
The “most powerful model to date”

Not Just Competition — A Shift in Scale

Over the past two years, major AI models (GPT, Gemini, Claude, Llama) have largely competed within the same performance band.

Differences were measurable, but incremental — often within single-digit percentages across benchmarks.

Mythos suggests something different:

Not incremental improvement, but a potential change in scale.

That may explain why every major Anthropic update tends to trigger the same reaction online:

“@sam Altman — are you awake?”

Anthropic’s Response: Prioritize Defense First

Anthropic positions itself as a safety-focused AI company.

So what happens when your own internal evaluation suggests you’ve built something that could overwhelm defenders?

Their response is unusual:

The first users of Mythos will not be developers or enterprise customers — but cybersecurity defense organizations.

The reasoning is straightforward:

If the model’s offensive capabilities are as strong as suggested
Then defenders need access to comparable tools before broader release

In effect:

The antidote is distributed before the risk is fully released.

This approach is rare.

OpenAI conducted red-teaming before GPT-4
Google ran safety reviews for Gemini

But explicitly prioritizing defensive users in the release pipeline is not common practice.

This decision can be interpreted in multiple ways:

Genuine concern about potential misuse
A strategic demonstration of capability
Or both

The Cost Problem

Another constraint is practical:

Mythos is currently very expensive to operate.

The internal drafts note that significant efficiency improvements are required before any large-scale release.

In plain terms:

This is not yet a consumer-ready model
It remains closer to a high-cost experimental system

Why “Capybara”?

Every major model has an internal codename:

GPT-4 → Arrakis
Google models → gemstone names

Anthropic’s strongest model so far?

A capybara.

The same internet-famous animal known for being:

Calm
Social
Universally compatible

The leak revealed two versions of the same blog draft:

One using “Mythos”
Another replacing every instance with “Capybara”

This suggests the codename was used internally for an extended period, with “Mythos” introduced later as a public-facing name.

An Unexpected Collision

There’s a twist.

In the AI ecosystem, “Capybara” is already strongly associated with Alibaba’s Qwen (Tongyi) models, where it serves as a mascot.

So when the codename surfaced, reactions were immediate.

One of the most notable responses came from a former Qwen technical lead:

“capybara? seriously?”

Two competing AI ecosystems, independently choosing the same meme animal.

Unintentional, but memorable.

The Leak Itself: A Basic Mistake

The cause of the leak is almost trivial.

Anthropic attributed it to:

A manual configuration error in an external CMS tool.

Key details:

Uploaded assets were public by default
Privacy required manual configuration
That step was missed

This is functionally equivalent to:

An improperly secured S3 bucket
A well-documented, preventable issue

Anthropic emphasized that:

The incident was not caused by AI-generated code
It did not affect core infrastructure or customer data

Still, the irony is hard to ignore:

A company building cutting-edge cybersecurity AI exposed itself through a basic permission misconfiguration.

What the Leak Actually Reveals

Beyond the technical mistake, the content of the leak is more important.

The documents suggest something the industry rarely states explicitly:

The model may be powerful enough that even its creators need to treat it with caution.

This is a different tone from the usual release narrative:

Faster
Stronger
Safer

Instead, the implication is:

“We’ve built something that requires careful handling.”

Marketing, or Something More?

It’s reasonable to question whether this is simply another form of positioning:

Emphasizing risk to signal capability
Framing caution as exclusivity

But the language in the drafts doesn’t read like standard marketing.

When internal materials describe:

“An upcoming wave of AI-driven vulnerability exploitation”

That suggests either:

An unusually bold marketing strategy
Or a genuine internal assessment

Final Thought

The leak itself is almost incidental.

What matters is the signal:

A new tier above Opus
A measurable jump in capability
And a growing awareness of the risks that come with it

All triggered by something as mundane as:

Forgetting to toggle a “private” setting in a CMS.

Tsinghua Open-Sources OpenMAIC: One-Click Generation of Multi-Agent AI Classrooms

brooks wilson — Thu, 19 Mar 2026 13:54:32 +0000

OpenMAIC: One-Click Multi-Agent AI Classrooms

What happens when AI systems know more than the teacher—and can adapt to every student?

In a traditional classroom, the model is fixed:

One teacher lectures
Dozens of students listen

If the pace is too fast, some fall behind.
If it’s too slow, others disengage.

This “one-size-fits-all” structure has always been a bottleneck.

Now imagine a different setup:

Every student has a personal AI assistant
It never gets tired
It adapts to individual learning pace
It can generate interactive lessons on demand

This may sound speculative—but systems like OpenMAIC are already making it real.

Developed and open-sourced by a Tsinghua University team, the project has quickly gained traction, attracting significant attention on X within hours of release.

01 · What OpenMAIC Does

At its core, OpenMAIC generates complete, interactive learning environments using AI agents.

Instead of reading static material, learners can:

Attend AI-led “classes”
Interact with multiple AI agents
Participate in discussions and exercises

GitHub: https://github.com/THU-MAIC/OpenMAIC

Generate a Course from a Topic

You can start with a simple prompt—for example:

“Create a course explaining OpenClaw”

Within minutes, OpenMAIC generates:

A structured lesson
AI instructor narration
Multi-agent discussions
Interactive exercises

The output includes:

Voice explanations
HTML-based interactive simulations
Built-in quizzes
Export options to .pptx or interactive .html

Turn PDFs into Interactive Lessons

OpenMAIC also supports document-based learning.

Upload a PDF, and the system will:

Extract and restructure the content
Generate explanations with visual aids
Insert quizzes and checkpoints

For example, a report analyzing OpenClaw’s impact on WeChat can be transformed into a guided course.

Importantly, this is not just passive narration.

The system introduces interaction:

Visual breakdowns of concepts
Simulated workflows
Step-by-step reasoning

For instance, when explaining how AI agents work, it can render:

Input → internal processing → output

as an interactive, visualized pipeline.

Making Abstract Concepts Tangible

One of the harder parts of learning—especially in subjects like math and physics—is abstraction.

Take the Pythagorean theorem.
Hearing the formula repeatedly rarely leads to intuition.

OpenMAIC approaches this differently:

It embeds interactive components directly into lessons
Learners can manipulate variables and observe real-time changes

For example:

Instead of memorizing the formula, students can:

Drag triangle edges
See how values update dynamically
Build intuition through interaction

This shift—from explanation to exploration—can significantly improve retention.

Integration with Other AI Systems

Some developers have already integrated OpenMAIC into OpenClaw, enabling:

Automatic generation of instructional videos
On-demand learning content inside agent workflows

This suggests a broader pattern:

Learning becomes a capability embedded inside AI systems—not a separate activity.

02 · How to Use OpenMAIC

You can either use the hosted version or deploy it locally.

Option 1: Use Online

Visit: openmaic chat

Option 2: Self-Host

1. Clone the repository

git clone https://github.com/THU-MAIC/OpenMAIC.git
cd OpenMAIC
pnpm install

2. Configure environment

cp .env.example .env.local

At minimum, provide an API key for an LLM provider.
You can also configure providers via server-providers.yml.

3. Start the app

pnpm dev

Open:

http://localhost:3000

Initial Setup

Once inside the interface, you can:

Upload PDFs
Customize AI voice
Set your learner profile
Choose AI “classmates”

Then enter a topic and start the session.

What the Learning Experience Feels Like

OpenMAIC tries to simulate a real classroom:

AI instructor explains with voice and visual cues
Spotlight and pointer effects guide attention
Interactive components encourage hands-on learning

During the session:

Questions are raised for discussion
AI agents debate among themselves
You can join the conversation at any time

In some cases, the system may even prompt you directly.

Why This Matters

OpenMAIC points toward a shift in how education might scale in the AI era.

From Uniform Teaching → Personalized Learning

Previously:

One teacher, many students
Limited personalization

Now:

One AI system per learner
Fully adaptive pacing and content

From Content Consumption → Interactive Exploration

Instead of:

Reading documents
Watching videos

Learners:

Interact
Experiment
Participate

Limitations and Open Questions

While promising, this approach is not without trade-offs:

Requires reliable LLM infrastructure
Quality depends on prompt design and source material
May not replace structured curricula in formal education
Long-term learning outcomes still need broader validation

Final Thoughts

OpenMAIC demonstrates a practical direction for AI in education:

Generate what you want to learn
Learn at your own pace
Turn knowledge into interaction

It lowers the barrier to both learning and teaching:

Want to learn something? Generate a course.
Want to teach something? Generate a classroom.

This represents a shift not just in tools, but in how knowledge is produced and shared.

Whether this becomes mainstream remains uncertain. But as an open-source experiment, OpenMAIC offers a concrete glimpse into what AI-native education might look like.

DEV Community: brooks wilson

Another Major Chinese AI Model Goes Open Source: MiniMax H3

1. Up to 15-Second 2K Video with Synchronized Stereo Audio

2. Three-Module System for Audio-Video Generation with Context-Aware 2K Upscaling

3. Local Deployment Supports 768p Audio-Video; Full 2K Workflow Requires API

4. Conclusion: Omni-Modal Video Generation Moves Toward an Open Ecosystem

DeepSeek V4 Flash Review: How Far a 300B Model Can Actually Go

Logic Benchmark Results

Agentic Coding

Claude Code vs Codex

Frontend Quality Without Vision

How Flash Verifies Its Own Work

Reasoning: Where Flash Beats a Model Five Times Its Size

Hallucination and Long-Context Behavior

Token Efficiency and What It Actually Costs

The Note

When the Plan Fails, Don’t Restart the Group Chat

Treat the cancellation like a failed dependency

Reopen only the affected decision

Generate a recovery set, not another recommendation dump

Give the group a decision message it can actually answer

Where an AI assistant becomes useful

The real difference from a chatbot

A 2M-Token Context and Four Bolt-On Experts: How Macaron V1 Turned LoRA Into a Real Architecture

A New Job for LoRA

Getting In

Feeding It My Own Life

Coding: Bringing K3 and Opus to the Same Table

Testing Its Agent Chops: I Handed It One of My Own Repos

UI4A: The Model Draws the Interface Itself

Closing Thoughts

The Rise of the One-Person Software Company

Solo Founding Is Moving From Exception to Operating Model

A Company Without Departments Still Has Departmental Work

AI Agents Give the Founder Leverage, Not Autopilot

Templates Compress the Cost of Starting From Zero

Data, Payments, and Publishing Are Part of the Product

The Solo Founder Becomes a Systems Designer

Small Companies Can Pursue Smaller, Better Markets

DeepSeek-V4 Preview: Entering the Era of Accessible Million-Token Context

DeepSeek-V4-Pro: Performance Comparable to Top Closed-Source Models

Significantly Improved Agent Capabilities

Rich World Knowledge

World-Class Reasoning Performance

DeepSeek-V4-Flash: A Faster and More Cost-Efficient Option

Architectural Innovation and Highly Efficient Long Context

Targeted Optimization for Agent Workloads

API Access

Open Weights and Local Deployment

Closing Thoughts

GPT Image 2: What It Is, What It Can Do, and Why It's Different From Every AI Image Tool That Came Before

What Is GPT Image 2?

A Quick Family Tree

Why Architecture Matters (Short Version)

The Five Capabilities That Matter

1. Thinking Mode — The Headline Feature

2. Near-Perfect Multilingual Text Rendering

3. Native 2K Resolution, Experimental 4K

4. Precise Editing via Masked Inpainting and Outpainting

5. Speed: ~3 Seconds Per Image

Five Hands-On Prompts, With Notes

Prompt 1 — Multilingual Magazine Cover

Prompt 2 — Infographic with Real Data

Prompt 3 — Photorealistic App UI Mockup

Prompt 4 — Four-Panel Comic With Character Consistency

Prompt 5 — Commercial Product Shot With Two Types of Text

Pricing: ~$0.21 Per HD Image, Thinking Mode Extra

GPT Image 2 vs Midjourney vs Nano Banana Pro vs Flux.2

Which Should You Actually Use?

Where GPT Image 2 Still Fails

How to Use It: ChatGPT and API

In ChatGPT

Via API

Practical Tips (From Running It for a Week)

FAQ

Bottom Line

Further Reading

An Anonymous Model Just Took #1—and Flipped the AI Video Race Overnight

How “HappyHorse” Disrupted the AI Video Generation Landscape

A Sudden Shift in the Rankings

The Core Loop: `run_turn()`