Rigging 3D characters with tokens, grading code without running it, and models that learn from themselves
The open-weight coding crown just changed hands and Meta capped its own employees' AI spend -- but the real story is what AI is quietly automating underneath. We break down SkinTokens, which turns 3D character rigging into a token-prediction problem and roughly doubles skinning quality; Dockerless, which grades AI-written code by reading the repo instead of running its tests; and a pair of on-policy distillation papers that let models learn from their own mistakes and assemble one generalist from a roster of specialists. Three unglamorous grind steps, three automations, one theme: the win was a smarter representation, not a bigger model.
Cold Open
Eris: Someone at Meta wired up AI agents to run in circles. Doing nothing. Just burning tokens.
Vestra: To climb a leaderboard.
Eris: A leaderboard for who spends the most. Badges. A "Token Legend" tier.
Vestra: They named it Claudeonomics. And then somebody added up the bill.
Eris: Which is heading into the billions this year.
Vestra: So they capped it. Six thousand people, told to ease off the gas.
Eris: Here's the part that gets me, though. Same week that lands --
Vestra: -- an open model shows up that's basically as good as the best closed coder on the market.
Eris: Free. Runs on your own hardware.
Vestra: So the thing Meta is hemorrhaging money on --
Eris: -- just became optional. On paper.
Vestra: On paper. The weights aren't actually out yet.
Eris: "Next week." From a lab. You know how that goes.
Vestra: Mm. But if it's real, the whole "AI's too expensive to run at scale" panic gets a very cheap answer.
Eris: If.
The Headlines
Eris: Alright -- the headlines.
Vestra: Cost. That's the whole board today.
Eris: Start with the open model, since it's the one people actually got excited about. Z.ai dropped GLM-5.2. Coding-focused. And on the test that matters -- can it finish a real, multi-step engineering job, not just pass one snippet -- it's the strongest open model anyone's shipped.
Vestra: Within a hair of the best closed coder. And it holds a genuinely enormous amount of context -- you can hand it a whole codebase and it stays coherent instead of getting lost.
Eris: Which is exactly the part I'd stress-test. Everybody claims the giant window. Most of them fall apart the moment you fill it.
Vestra: Agreed. And the weights are promised, not posted. But this is their fourth flagship coder in four months. The open side isn't a year behind anymore. It's one release behind.
Eris: Then the two cost stories. Meta we already hit -- the leaderboard, the cap.
Vestra: The line I keep coming back to is their CTO's. All motion is not progress. Tokens spent are a cost, not an output. Reward the input, you get a very expensive input.
Eris: And Oracle -- the grown-up version of the same anxiety. They filed the risks of their datacenter bet. Out loud. In detail.
Vestra: They're a middleman. They lease the capacity, resell it -- mostly to one customer that isn't profitable yet. If that customer's funding tightens, Oracle's the one holding the lease.
Eris: Fixed costs on both sides, a power bill that floats, one big tenant. They basically wrote down "here's how we lose the farm."
Vestra: Sobering. Next to all that -- a research swing. Orca.
Eris: This one I like. Instead of a model that predicts the next word, or the next video frame, or the next action -- one model that predicts the next state of the world. One shared inner space, and you clip little readers on top to pull out text, or an image, or a robot's next move.
Vestra: Learn the world once, read it out many ways. Ambitious. Also a fresh paper, not a shipped thing -- and world models love to hallucinate confident blank spots where they should say "I don't know."
Eris: Fair. Two more we're actually going to dig into later -- a way to grade AI-written code without ever running it, and a training trick where a model learns from its own mistakes instead of just copying a teacher.
Vestra: Both pointed straight at making agents cheaper to build. Hold those.
Eris: And two open-source drops. Strix -- agents that attack your own app, actually build the working exploit, and block the bad code before it ships.
Vestra: Security's the rare place an agent can't bluff. The exploit runs or it doesn't. Dual-use, obviously -- same tool points the other direction just as well.
Eris: And a pack of a hundred-fifty-plus role-playing agents. An engineering "division," a marketing one, and -- my favorite -- a "reality checker" whose entire job is to push back on the others.
Vestra: Which quietly admits the whole problem with these swarms. More agents, more chances for one confident mistake to spread through the rest.
Eris: It's a menu, not a mandate. Please do not run all hundred-fifty at once.
Intro
Eris: Quick who-we-are, if you're new here. I'm Eris. I read the papers, chase the numbers, and connect the ones that rhyme.
Vestra: And I'm Vestra. I take the mechanism apart and poke at what might be wrong with it.
Eris: Two hosts, no lecture. We breach the blackbox -- crack open the week's research into something you can actually follow on your commute.
Vestra: And if you want every story we just ran, in full, we put them all up daily on our news site -- Ground Truth. That's groundtruth.day. The show's the deep end; the site's the firehose.
Eris: Today's thread: AI eating the unglamorous, manual middle. Every pipeline has a grind step nobody wants to do by hand -- and this week we've got three of them getting automated at once.
Vestra: The one that surprised me most is 3D. You can generate a character model in seconds now. But it's a statue until someone rigs it -- and rigging is brutal, specialist work.
Eris: That's where we start. Then the grind of checking AI-written code. Then the grind of teaching one small model everything a whole room of specialists knows.
Vestra: Different corners. Same move.
Eris: If that's your kind of thing, follow the show wherever you're listening -- it's the one button that tells us to keep making these.
Teaching AI to rig a 3D character
Eris: So picture the 3D pipeline right now. You type a sentence, or hand it a picture, and out comes a character mesh in seconds. Wild. Except it can't move.
Vestra: It's a mannequin. Beautiful, frozen. To animate it, someone has to rig it -- and rigging is two jobs. First you build a skeleton inside it. Bones.
Eris: Then the harder one. Skinning.
Vestra: Skinning is: for every point on the surface, how much does each bone pull it when it moves. Bend the elbow -- the forearm skin follows a lot, the shoulder skin barely at all, and the transition in between has to be smooth or the mesh crumples.
Eris: And that has always been done by hand. Artists, days per character. It's the bottleneck. You can generate a thousand characters overnight and rig maybe none of them.
Vestra: The automated attempts all made the same choice, and this paper's whole argument is that the choice was wrong. They treated skinning as regression.
Eris: Unpack regression.
Vestra: You've got a mesh with, say, tens of thousands of points, and a hundred bones. So the answer is this giant grid -- every point against every bone, a number in each cell. Regression means: predict all of those numbers directly, at once.
Eris: Which sounds reasonable until you look at what the grid actually contains.
Vestra: Almost entirely zeros. Any given point is really only touched by about four bones. So ninety-plus percent of the grid is "this bone does nothing here." Train a model to predict that grid and it spends all its effort getting the zeros right, and goes mushy on the handful of numbers that actually matter.
Eris: Blurry weights. Which show up as those horrible artifacts when the thing moves -- skin bleeding onto parts it's not attached to, a finger dragging the neighboring finger.
Vestra: Right. So their move -- and this is the good idea -- is to stop predicting the grid at all. Make it discrete.
Eris: This is the part that made me sit up, because it's a borrowed trick. The thing that made image generation and audio generation click was tokenizing -- you don't predict a million raw pixels, you learn a small vocabulary of chunks and predict a short sequence of those.
Vestra: A dictionary of little pieces.
Eris: And they just... did that to skinning. They trained a compressor -- feed in one bone's messy influence over the whole surface, and it learns to squeeze that down to a handful of codes from a fixed vocabulary. They call them skin tokens.
Vestra: And it compresses absurdly well, which is the tell that the idea fits. One bone's entire influence map -- thousands of raw values -- down to something like four little tokens, with barely any loss. That only works if skinning really does have simple, repeated structure hiding under all those numbers.
Eris: And it does. When they looked at what the compressor learned, the codes for a leg cluster together across totally different characters. A human leg, a monster leg, an anime-figure leg -- same neighborhood.
Vestra: It learned the concept of "leg skinning," not the specific vertices. That's the semantic prior. That's why it generalizes.
Eris: Okay, but here's the connection I actually care about. Once skinning is a short sequence of tokens, and the skeleton is already a sequence of tokens --
Vestra: -- you can generate both in one stream.
Eris: One model. It writes out the whole skeleton, then keeps going and writes the skinning, all as one continuous prediction, each piece aware of everything before it. The old pipelines did these as two separate models that never talked.
Vestra: And that separation was dumb, when you say it out loud. The skeleton determines what good skinning even looks like. Predict them apart and the skinning is stuck cleaning up after a skeleton it had no say in. Predict them together and they learn each other's dependencies.
Eris: Same predict-the-next-piece engine behind text models, pointed at a rig. That's the whole trend in one paper -- the discrete-token move eating another domain.
Vestra: There's a third stage, and it's the one that rescues the weird cases. After the normal training, they do a reinforcement-learning pass.
Eris: Meaning: let it try, score the result with rules, nudge it toward better.
Vestra: And the rules are hand-built rigging common sense. Are the bones actually spread through the whole body, or did you forget the tail. Do the bones stay inside the mesh instead of poking out. Does every point get attached to something. Does the thing deform smoothly when you pose it.
Eris: And that's what lets it handle the stuff that isn't in any training set. Demon wings. Horns. A cape. The plain model would just ignore the wings -- no bones for them.
Vestra: The scored version grows bones into the wings. Because "cover the whole shape" is one of the rewards. It's injecting geometric reasoning where the examples ran out.
Eris: Payoff, in felt terms -- because I know you want the honest version. The skinning quality: roughly double the prior best. Not a nudge. And the skeletons come out cleaner too, meaningfully -- fewer redundant bones, fewer missing limbs.
Vestra: And critically, no bleeding. The clean-fingers case is the one that sold me -- the older methods smear one finger's weights onto the next, and this one keeps them distinct.
Eris: So zoom out. This is one link in a chain. Generate the mesh -- that's solved. Rig it -- that's this. And then the last stage, driving it.
Vestra: Motion capture. Which most people have actually seen without knowing it -- it's the tech under VTubers, the face tracking. And there's the audio-driven version, where you feed in speech and it animates a face to match, like Nvidia's Audio2Face.
Eris: So the whole character pipeline, stage by stage, is getting automated. Make the body, wire it up, make it move. Rigging was the ugly gap in the middle, and this is someone filling it.
Vestra: With the caveats stated plainly. It's a research result, not a tool you can download and ship with. The authors admit their discrete codes still trail the messiest hand cases a little. And it runs on its own -- a pro often wants to direct the rig, not just accept it.
Eris: Their own stated next step, basically. Turn it from an autopilot into a co-pilot.
Vestra: But the core insight holds. The bottleneck wasn't the network. It was the representation. Stop regressing a wall of numbers, learn the right vocabulary, and the hard problem gets a lot smaller.
Grading AI code without running it
Eris: Second grind step. This one's about how you train an AI to fix code -- and the part everybody skips over, which is the grading.
Vestra: Right. To teach an agent to write patches, you need to tell it which of its attempts actually worked. You need a grader. And the gold-standard grader is: run the project's tests.
Eris: Which sounds trivial and is not.
Vestra: It's brutal. To run a project's tests you have to rebuild that project's entire world -- the exact dependencies, the right versions, a working test setup -- in an isolated container. Per project. And a huge amount of real code just can't be rebuilt that way.
Eris: This is the part people underestimate. Public benchmark repos, sure, someone dockerized those. But private company codebases, old legacy systems, the projects with flaky tests or no tests --
Vestra: -- which is most of the code on earth.
Eris: So the environment, not the model, becomes the wall. You literally cannot train on the code where the agent would be most useful.
Vestra: So Dockerless asks: what if the grader never runs anything? What if it just reads?
Eris: Turn the grader into an investigator. Give it the issue, the proposed fix, and let it explore the actual repository. It generates a few pointed questions -- where should this fix land, does it hook into the surrounding code correctly, what else might this break -- and sends little sub-agents to grep and read for the answers.
Vestra: Then it weighs the evidence and rules: this patch resolves it, or it doesn't.
Eris: The analogy the paper basically hands you -- one mechanic can only certify a repair by starting the engine. The other's experienced enough to inspect the work and tell you it's sound.
Vestra: And the second one works on cars that won't start. That's the whole point. It grades the un-runnable.
Eris: Now -- you're about to say something skeptical, and I want you to, but say the honest mechanism first.
Vestra: Fine. Here's the nuance the headline skips. It's not judging from nothing. It gets shown a reference solution -- a known-good patch. Its actual job is: does this candidate achieve the same effect as the known-good one, even if it's written completely differently.
Eris: Which is a real distinction. Because a lot of correct patches don't look like the reference.
Vestra: That's exactly the case they show off. The candidate solved it a different way -- different structure entirely. A dumb text-similarity check calls it wrong, because it doesn't match. Dockerless goes and confirms the fix hits both the code paths it needed to, and calls it right. Because it looked.
Eris: And the results are the part that matters. As a grader on its own, it beats the best previous no-execution grader by a wide margin. It even beats big frontier models used cold as judges.
Vestra: Which makes sense -- it inspects the repo, they just eyeball the diff.
Eris: And then the real test: they used it to actually train an agent. Used it to pick the good training examples, and used it as the reward signal. No containers, no tests, anywhere in the loop.
Vestra: And the trained agent matches the one built the expensive way. Running-the-tests gave up basically nothing.
Eris: There's a lovely side-finding buried in there too. They checked -- how much does the agent lose if you take away its ability to run things during the actual work? And it's only a few points. So the agent was mostly fine without the environment. The grader was the thing holding everything hostage.
Vestra: Now the skepticism. Reading is not running. A patch can look perfectly consistent with the codebase and still blow up at runtime on some edge case only execution would ever surface.
Eris: A very good reviewer.
Vestra: A very good reviewer. And reviewers miss what tests catch -- that's not a knock, it's just the category. And they were honest about where it shows: on the compile-heavy languages, the kind where you really want the compiler yelling at you, the read-only grader gives up real ground.
Eris: Because the compiler is exactly the runtime signal it's choosing not to have.
Vestra: Right. So it's not "execution was pointless." It's "for the enormous long tail of code you could never dockerize, a good reading grader gets you most of the way -- and most of the way is a lot more than zero, which is what you had before."
Eris: And it plugs into the same theme as the last one. There's an unglamorous, expensive step in the middle of the pipeline -- here it's verification -- and somebody just made it cheap enough to do at scale.
Models that learn from their own mistakes
Eris: Third grind step, and it's the most abstract, so let me set it up with the old way first. Distillation. You've got a big, expensive, smart model -- the teacher -- and you want a small cheap model -- the student -- to be nearly as good.
Vestra: Classic version: the student copies the teacher's answers. Study the master's completed work.
Eris: And there's a subtle rot in that. The student only ever sees the teacher's path -- the clean, correct trajectory. It never sees its own mistakes, so it never learns to recover from them. Then out in the wild it takes one wrong step and it's in territory the teacher never showed it.
Vestra: It drifts. There's a name for it -- exposure bias. It was only ever exposed to perfect examples.
Eris: So the fix, which is the thread running through today, is on-policy. The student generates its own attempts. And the teacher grades those -- the student's own work, step by step.
Vestra: The difference between studying a grandmaster's recorded games, and playing your own games with the grandmaster leaning over your shoulder correcting each move you actually make.
Eris: You learn from the situations you actually get into. Same principle the code grader used for its reward, by the way -- score the student's own rollouts. It's everywhere today.
Vestra: So the first paper, DOPD, finds a trap inside even that. It's called the privilege illusion, and it's sneaky.
Eris: Walk it.
Vestra: To make a teacher stronger, people often slip it a hint during training -- a worked-out clue, some extra context -- that the student will never have at test time. Now the teacher looks brilliant. But some of that brilliance is just the hint.
Eris: And if the student copies it wholesale --
Vestra: -- it learns to imitate moves that only made sense because of information it doesn't have. It looks like it picked up the skill. It didn't. It memorized the shape of an answer it can't actually reproduce.
Eris: That's such a clean way to be fooled. The gap between teacher and student is really two gaps stacked -- a real skill gap you want to close, and an information gap you never can.
Vestra: And their fix is per-token routing. For each little piece of the output, they ask: is the teacher's edge here real skill, or is it just the hint. When it's real skill, lean hard on the teacher. When it's just the hint, back off and trust the student's own instinct instead.
Eris: Only distill the part that's actually transferable.
Vestra: And it pays off exactly where you'd hope -- steadier training, and better performance on tasks it wasn't trained on. Because it learned genuine ability instead of borrowed shortcuts.
Eris: Then the second paper, MOPD, goes after a totally practical headache. You can use reinforcement learning to make a model great at one thing. A math specialist. A coding specialist. Beautiful, in isolation.
Vestra: And then you try to combine them and they fight.
Eris: The see-saw. Push math up, coding sags. Train them together in one pot and the signals interfere -- you end up with a generalist that's worse than every specialist you started with.
Vestra: So MOPD says: don't combine them during training. Build each specialist teacher separately -- fully in parallel, different teams, different recipes, nobody blocking anybody. Then distill all of them into one student, on the student's own attempts, routing each question to whichever teacher owns it.
Eris: Math question goes to the math teacher, code to the code teacher, student in the middle absorbing all of them.
Vestra: And it inherits nearly all of every teacher's ability -- without the see-saw. Because they never shared a training pot to fight in. This one isn't just a lab result, either -- they used it to post-train a real, industrial-scale model that shipped.
Eris: Which is the credibility line for me. But you found the catch, I can tell.
Vestra: I did, and it's a good one. The teachers have to be -- their word -- same-origin. Grown from the same starting model as the student. So their instincts line up.
Eris: What happens if you break that?
Vestra: They tested it. Swapped in a bigger, genuinely stronger math teacher -- but a distant one, trained separately. And the student got worse. In one setup the training just collapsed. Fell apart.
Eris: Huh. So it's not "grab the strongest teacher you can find."
Vestra: It's "grab a compatible one." A brilliant tutor who thinks nothing like you can be worse than useless. That's a genuinely counterintuitive result, and it's the load-bearing detail the summary would skip.
Eris: And the honest framing on both of these -- same as always. Self-reported, on their own model families, deployment claims from the teams that built the methods. What makes them worth your time is that they're not one clever trick, they're the same idea showing up twice.
Vestra: On-policy distillation as connective tissue. It's how you take the expensive skill you earned with reinforcement learning and pour it into a cheap deployable model. And how you assemble one generalist from a roster of specialists.
Eris: An assembly line for building models. Which is, again, the day's whole story -- the expensive, manual, artisanal step getting turned into something you can just run.
Wrap-up
Eris: So pull it together. Three papers, three grind steps. Rigging a 3D character. Grading a code patch. Teaching a small model everything a room of specialists knows.
Vestra: Different worlds. Same move each time. Find the expensive, manual, artisanal step in the middle of a pipeline -- and turn it into something you can just run.
Eris: And the cost stories up top are why everyone's racing to. When Meta's capping its own people and Oracle's spelling out how the bet could sink them, "make the whole thing cheaper to build and run" stops being a nice-to-have.
Vestra: The through-line I'd leave you with: in all three, the win wasn't a bigger model. It was a smarter representation. The right vocabulary for skinning. Evidence instead of execution. Compatible teachers instead of the strongest one.
Eris: Less brute force, more taste.
Vestra: More taste.
Eris: If you got something out of this, do the thing that keeps us going -- follow or subscribe wherever you're listening, and drop a comment, because we read them.
Vestra: And here's the one we actually want an answer to. In your own work -- which manual grind would you hand to an AI first? And which would you never trust it with, no matter how good it got?
Eris: Tell us. That specific split -- what you'd give up and what you'd guard -- that's the conversation.
Vestra: Like it if it earned it, share it with the one person who'd argue about it, and we'll see you next time.
Eris: And every story from today, in full, every day -- that's on Ground Truth. Groundtruth.day.