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.
Top comments (0)