The AI Reward That Faked Its Own Answers, Robots That Feel the Future, and the Skill AI Quietly Costs You
A prize-winning training method promised a reward that couldn't be gamed -- then someone read the code and found it flipping a weighted coin whenever the real signal went missing. We trace that silent failure through three papers where the number on the label and the signal underneath quietly disagree: a self-play reward that grades itself, robots that act on the touch they're about to cause instead of the one they just felt, and a randomized study showing AI help can leave you worse at the very skill you're supposed to be learning. One useful takeaway for tomorrow: when you're learning, ask AI to explain, not to solve.
Listen (MP3) · Watch on YouTube · Spotify · Pocket Casts
The Reward That Made Up Its Own Answers
Eris: The whole pitch was a reward you cannot fake. That was the entire point. The environment knows the right answer, so the score is honest -- no human judge, no bias, nothing to game.
Vestra: Right, that's the premise the paper is built on. It says it in plain words -- the outcome is fully verifiable.
Eris: So somebody opened the code they actually released.
Vestra: Okay, and what did they find?
Eris: When the judge doesn't answer, the code makes the votes up. It flips a weighted coin and calls that the ground truth.
Vestra: Wait, back up. It fabricates the one thing it swore could not be fabricated?
Eris: There's a little function that fires whenever the real votes are missing. The honest players "vote" for the correct answer about six times in ten -- and every fake vote gets a tag right there in the source. Simulated vote.
Vestra: And that made-up vote flows into the reward like it's the real thing.
Eris: Same pipe. Nothing crashes. The learning curves look beautiful.
Vestra: That's the part that gets under my skin. It doesn't fail loud. It just quietly trains on a signal nobody chose.
Eris: And honestly -- that's the whole day. Four big releases, everybody announced something huge, and almost nobody shipped the receipt.
Vestra: So let's go read the receipts.
The Headlines -- Everybody Shipped, Nobody Shipped the Receipt
Eris: Alright, the headlines. And the word doing all the damage today is "open."
Vestra: Four separate releases got called open. Every one of them means something different by it.
Eris: Start with the loudest. Alibaba put out Qwen3.8-Max. Big multimodal model, and they cut the price a fifth under the last flagship.
Vestra: Which is real news for anyone running agents -- cached input is dirt cheap now. But notice what shipped. An API key. Not a file.
Eris: The open weights got promised for "next week." What exists tonight is a paid endpoint.
Vestra: And the thing that actually went viral wasn't even the model that shipped. It was a claim that the unreleased little sibling runs in about seventeen gigs.
Eris: Which is roughly the size of the weights sitting on disk. That's not the same as running -- the memory it actually needs while it's live is a lot more than that.
Vestra: Nobody's measured it, because there's nothing to measure yet. It doesn't exist.
Eris: Then MiniMax. They dropped the weights for H3 -- video with real synced audio. And this one's my favorite shape of the day.
Vestra: They gave you the oven and kept the recipe. The stage that reads your prompt and cleans it up? Not in the release. The stage that pushes it to high resolution? Also not in the release.
Eris: You get the middle. And the license carves out the EU, the UK, South Korea, and the US entirely.
Vestra: So most of the people cheering the "open" drop have no license to touch it. Read the license, not the headline.
Eris: Now the one I keep chewing on. OpenAI put out ten hard math results with machine-checkable proofs. Three days ago.
Vestra: And three days later, nobody outside the company has publicly shown that they compile. The repo has one commit. Issues turned off, pull requests turned off.
Eris: The whole promise of a machine-checkable proof is that you don't have to trust the lab -- you run the checker yourself.
Vestra: Right, and the artifact's there. You can. It's just that shipping something verifiable and getting it verified are two different events, and the second one takes longer than a news cycle. Nobody owes them a weekend, either.
Eris: Oh, and that two-thousand-dollar price tag people quoted? That's the tokens to find the winning proofs at retail rate. Not the failed tries, not the training, not the humans who prepped the manuscripts.
Vestra: The successful searches only. It's a real number pointed at a narrow thing.
Eris: Speaking of voice -- OpenAI also published how they rebuilt it. And the headline there is they ripped out the part that guesses when you're done talking.
Vestra: The turn detector. Old way, a little model has to guess -- too early it cuts you off, too late it feels slow. The new model just listens and talks at the same time.
Eris: But the fix wasn't a smarter model. It was plumbing. They got session startup from six network round trips down to one.
Vestra: It reads like they stopped building a chatbot and started running a phone network. Which -- hold that thought, because NVIDIA shipped the open version of exactly this.
Eris: Their full-duplex voice model, weights and all. Listens, talks, calls tools mid-sentence.
Vestra: And wants a data-center card with eighty gigs of memory to run. Open weights change who can build it. They don't change the physics of it.
Eris: Their own limitations list is brutally honest, too -- it can wander off into gibberish after a few turns, and you can't interrupt it while it's using a tool.
Vestra: Full duplex and interruptible tools are not the same achievement yet. Good on them for saying so.
Eris: Quick hits. Somebody's running a nearly-three-hundred-billion-parameter model on two gaming cards --
Vestra: -- except it's really a server with three-quarters of a terabyte of RAM doing the work. The cards barely hold anything. The lesson is that the giant sparse models are a memory problem now, not a compute problem.
Eris: A court in Munich found Suno's music models had six specific hit songs memorized inside them -- you could prompt them back out.
Vestra: And that's the legally load-bearing part. Not "was it in the training data." Can a normal prompt pull the actual song back out. That's testable, and the plaintiffs ran the test. Ties right back to that Suno training-data leak we covered.
Eris: There's an EPA memo that reads an off-grid gas plant built for one data center as slipping outside the acid rain program. Guidance, not a rule -- but watch for the first project that claims it.
Vestra: And one more paper worth a flag -- a benchmark asking whether a coding agent can earn the right to stop asking you clarifying questions.
Eris: The fun twist in that one: most of the benefit from "memory" is just generic context, not personalization. And the fancy memory frameworks lost to just handing it the raw history.
Vestra: Which is a sharper finding than "memory helps." But that's a rabbit hole for another day.
Eris: Because we've got three papers where the surface number and the real signal underneath are two very different things.
Vestra: Starting with a reward function that graded itself.
The Signal Underneath
Eris: This is Breach Protocol, where we crack open the day's AI research and pull out the one thing you can actually use. I'm Eris -- I read the papers and chase the threads between them.
Vestra: And I'm Vestra. I'm the one who stops and asks how the thing actually works, and whether it holds up when you poke it.
Eris: And if you want the full rundown of every story we just raced through -- and every one we didn't -- that all lives on our news site, Ground Truth. That's groundtruth.day, fresh every single day.
Vestra: Today has a spine, and it's this: the number on the label is not the signal underneath. Three papers, three places where what you're told and what's actually happening come apart.
Eris: A reward that swears it's grounded in truth, and is grounded in a coin flip. A robot that acts on a touch it hasn't felt yet. And a productivity boost that's quietly a loan against your own skill.
Vestra: Each one looks fine on the surface. Each one is doing something else one layer down.
Eris: If that's your kind of thing -- and if you're still here, it is -- follow the show now so the next one lands in your feed automatically.
The Reward Function That Graded Itself
Eris: So here's the question I want us to answer by the end of this one. If a paper's whole claim is "our reward can't be faked," and the released code fakes it -- are the results wrong?
Vestra: That's the trap I want to walk carefully. But start with the idea, because the idea is genuinely good.
Eris: Set it up. What problem are they actually solving?
Vestra: Okay. There's a training method behind a lot of the reasoning models -- you let the model try things, and you reward it when it's right. And it works incredibly well for math and code. Why those two?
Eris: Because you can check the answer. The equation's right or it isn't. The test passes or it fails.
Vestra: Exactly. A machine can grade it, for free, forever. But now try that on "write me a good summary." There's no checker for good. So people fall back on a human, or on another model acting as judge -- which is slow, biased, and only as smart as the judge.
Eris: And this paper says: don't judge quality directly. Turn it into a game where the answer is checkable by design.
Vestra: This is the clever part. They run the party game -- Who Is the Spy. Five copies of the model get the same task. Four of them see the full document. One, the spy, sees a version with a chunk cut out.
Eris: So the spy's working with a handicap. It's missing something the others have.
Vestra: Everybody writes their summary. Then they all look at the outputs and vote on who they think was the spy -- who was missing information.
Eris: And the trick is, the environment already knows who the spy was.
Vestra: So the vote is checkable, exactly, like a math answer. Here's why that measures quality without ever measuring quality: if the spy writes a great summary despite the gap, nobody can tell it was handicapped. If it writes a thin one, it gets fingered.
Eris: So "don't get caught as the spy" quietly becomes "write so well your missing information doesn't show."
Vestra: That's the whole engine. You never scored quality. You scored a vote you can verify, and the vote tracks quality for free. It's honestly elegant.
Eris: Alright. So predict for me. The code that runs this -- what does it look like when the votes come in?
Vestra: I'd assume it parses the five players' votes, tallies who got named, done. It's a counting problem.
Eris: That's what I'd have guessed too. Here's the line somebody actually found. If the list of votes comes back empty -- it calls a function to make them up.
Vestra: Make them up how? It has no ground truth to make up from.
Eris: It seeds a random number generator off the game's ID, and then it has each honest player "vote" for the true spy about six times in ten. Otherwise, at random.
Vestra: So it's not verifying anything. It's simulating a detector that happens to be right most of the time. A weighted coin.
Eris: And every one of those invented votes carries a little note in the code -- simulated vote for clue-only training.
Vestra: And that flows into the exact same reward math the real votes would.
Eris: Same pipe. No error, no warning. The run produces reward numbers, curves, checkpoints -- all of it looks completely normal.
Vestra: Okay, this is where I have to be the brake. Because the loud version of this story is "the paper's a fraud," and that is not what this shows.
Eris: Okay, walk me through why.
Vestra: Two things. One -- we don't know this branch was even active in the experiments they published. It might never fire in the real setup. Two -- the paper does real work testing whether the idea holds, and none of that is refuted by one fallback in the code.
Eris: So what does it actually prove?
Vestra: That the public code can't currently be used to reproduce or audit the headline. The reward equation in the repo is not the reward equation in the paper. That's a real gap. It's not a verdict.
Eris: But here's why I think this is a security story and not just a sloppy-code story.
Vestra: Okay, go on.
Eris: Training code is supply chain. This is the classic supply-chain failure shape -- not a crash, a silent substitution. Something upstream comes back empty, and instead of stopping, the code hands you a plausible default and keeps going.
Vestra: And a reward is the worst possible place for that, because a reward is the one number where a plausible wrong value is indistinguishable from a right one. If your data loader breaks, you see garbage. If your reward quietly lies, you see a lovely learning curve.
Eris: So strip the game away -- what's the actual rule here?
Vestra: The rule is: in a training loop, any fallback in the reward path should crash, not default. A missing input has to be a loud failure, because it's the one place you can't eyeball the difference. And practically -- before you run somebody's research code, grep the reward function for the word that quietly fills in a blank.
Eris: So. Back to my opening question. The paper claims a reward that can't be faked, and the code fakes it. Are the results wrong?
Vestra: We don't know -- and that's the honest answer. What we know is you can't check them from what they shipped. "Reported" is not "reproduced." Publish the exact commit, the config, the logs, and we can talk.
Robots That Feel the Future, Not the Present
Eris: New question, and it's the one to hang onto for this segment. Why can a robot that clearly sees the plug and the socket still completely fail to plug it in?
Vestra: Because seeing where two things are is a different problem from feeling how they meet. And that gap is what these two papers -- same team, same day -- are built around.
Eris: Set the stakes first. Where do robots actually fall down right now?
Vestra: Not the big stuff. The general grab-and-move is basically solved. It's the last centimeter that breaks them. Seating a screw. Peeling one paper cup off a stack. Closing a gripper on something soft without crushing it.
Eris: And a camera can't resolve any of that.
Vestra: A camera sees the screw near the hole. It cannot see that the threads are crossed and it's jammed. That information only exists at the fingertips.
Eris: So the obvious fix is: give the robot touch sensors. Which people have done.
Vestra: They have. And here's where I want you to predict. If you're bolting a sense of touch onto one of these vision-language robots, how do you feed it in?
Eris: I'd just treat the touch sensor like another camera. It's a signal, throw it in with the rest, let the model sort it out.
Vestra: That's the first thing everyone tried, and it barely helps. Because a touch signal is almost nothing like a camera view. It's blank most of the time -- empty, empty, empty, and then a tiny burst of information the instant contact happens. Dump that into a system built for dense, busy images and it just gets drowned out.
Eris: Okay, so option two. Feed the robot the current touch reading and let it react.
Vestra: Warmer, and still one step behind. Think about what a touch reading actually is. It's a record of contact your last move already caused. It tells you what just happened -- it says almost nothing about the contact your next move is about to create.
Eris: So if you only ever react to the touch you're feeling now, you're always a beat late on your own hands.
Vestra: Every time. So here's the move in the first paper. Don't feed the robot the touch it feels. Feed it a prediction of the touch it's about to cause.
Eris: Wait -- it guesses the feeling before it moves?
Vestra: A little predictor looks at the scene, the instruction, and the current contact, and it estimates the net change in touch over the next chunk of motion. And the robot acts on that predicted feeling.
Eris: So vision says the plug is near the socket. And the predicted touch says -- and it's about to jam if you keep pushing at this angle.
Vestra: That's exactly it. It's the difference between feeling the wall after you've walked into it and feeling it coming.
Eris: How do we know the prediction is real and not just confident noise?
Vestra: They checked. Before wiring it into anything, they asked whether those predicted touch-tokens actually match the real future contact. And they land on the right one almost every time, in a setting where blind guessing would essentially never hit it. The prediction is grounded.
Eris: And the payoff on real robots?
Vestra: It swept every single real-robot task they tested. Not edged out -- won all of them. And clearly ahead of the best competing system in simulation, too.
Eris: Now the second paper takes it further, and this is the one that made me sit up.
Vestra: This one doesn't just predict touch. It predicts the future video and the future touch and the action, all together, in one model.
Eris: Why does predicting them together matter?
Vestra: Because now the model can't just dream up pretty pixels. To predict what it's about to feel, it has to internally represent whether the grip is stable, whether the thing is about to slip. It's forced to model the physics, not the postcard.
Eris: And there's this detail about how it handles a long task -- what did they call it, punctuation?
Vestra: Tactile punctuation, yeah, and it's lovely. It marks the moments that only touch can define -- the instant contact starts, the moment a grip goes secure, the release, the click of something seating home.
Eris: Like commas in the sentence of the motion.
Vestra: And here's the safeguard I love. When the model thinks it's finished a step, a predicted event can propose moving on -- but the actual felt contact has to confirm it. So if the gripper closes on empty air, the model can't fool itself into scoring that as a successful grab.
Eris: It can't lie to itself about whether it's holding anything.
Vestra: Which, after the last segment, is a nice place to land.
Eris: So forget the grippers and the gel sensors for a second. What's the general principle?
Vestra: That more pixels will never solve the last centimeter. The first meter is a seeing problem. The last centimeter is a contact problem -- and the fix isn't a sharper camera, it's a model that anticipates force instead of reporting it late.
Eris: So -- back to the top. Why does a robot that sees the plug still fail to plug it in?
Vestra: Because seeing tells you where. Only touch tells you what's happening as they meet -- and these robots finally act on the touch that's coming, not the touch that's already gone.
The Productivity Boost That Costs You the Skill
Eris: Last one, and it's the one that's actually about you, listener. Here's the question. When AI helps you get a task done -- are you also getting better at the task?
Vestra: And the reason this landed today is there were two developer essays going around this week, hundreds of comments, all about AI rotting your brain. Cognitive debt, retype the code by hand, that whole vibe.
Eris: Neither essay cites a single study.
Vestra: And the one study everyone kept attaching to the retyping essay? That was fifty-something people writing essays. Not code. Wrong study, wrong task.
Eris: But there is a real one. Randomized experiment. They had developers learn a new async library they'd never used -- half with an AI assistant, half without -- and then they tested what actually stuck.
Vestra: Tested the right things, too. Not lines of code. Can you read this code. Can you debug it. Do you understand the concept underneath.
Eris: So predict it. AI group versus no-AI group. Faster, and what happens to the learning?
Vestra: The easy story is a clean trade -- AI group finishes faster but learns less. Speed for depth.
Eris: Half right, and the wrong half is the interesting one. The AI group came out noticeably worse at reading and debugging the code -- think a solid drop in a letter grade's worth of understanding.
Vestra: Which -- fine, that's the trade we expected.
Eris: Except they weren't faster. On average, no real speed-up at all.
Vestra: So they paid the skill cost and didn't even get the productivity. That's not a trade, that's a bad deal. Why no speed-up?
Eris: Because people burned the time on the AI. Some spent a third of the clock just writing questions, asking the thing as many as fifteen times. Meanwhile the no-AI group was hitting errors and fighting through them --
Vestra: -- and fighting through the error is the part where the skill forms. That's not incidental. That struggle is the learning.
Eris: But here's the nuance that saves the whole thing from being anti-AI. It's not about whether you used AI. It's how.
Vestra: Right. They found a handful of distinct usage patterns, and a few of them kept the learning intact -- even with the AI right there.
Eris: Okay, which ones held up?
Vestra: The engaged ones. Asking it to explain. Asking a conceptual question -- why does this work, what is this doing. The people who lost the skill were the ones who said "just write it for me" and pasted the answer.
Eris: So the dividing line isn't AI or no AI.
Vestra: It's whether your brain was on. And this is where the retyping advice falls apart, by the way -- copying the code out by hand while your mind's switched off does nothing. Asking "why does this line work" while you're engaged does everything. The keystrokes were never the point. The engagement was.
Eris: Alright, strip it to the principle.
Vestra: The skill forms in exactly the struggle you're using AI to skip. So if you route around the struggle, you route around the learning. And it doesn't feel like a loss in the moment -- you shipped the ticket, you look productive.
Eris: And this connects straight back to the SpyRL story, weirdly.
Vestra: Alright, say it.
Eris: A silent cost. Nothing crashes, nothing looks wrong, the curves look great -- and one layer down you're training on the wrong signal. Same shape, just it's you being trained now.
Vestra: And there's a sting in the tail the authors point right at. Full delegation makes today's ticket faster and erodes the exact debugging skill you'll need to supervise tomorrow's AI. You're trading away the thing that lets you catch the machine when it's wrong.
Eris: So -- the question we opened with. When AI helps you finish, are you getting better at the task?
Vestra: Only if you stayed engaged while it helped. Delegate the thinking and you get the output without the competence -- and eventually you can't tell whether the output was any good.
Read the Receipt, Not the Label
Eris: So the question under the whole episode: how do you tell what you actually got, versus what you were told you got?
Vestra: And every story today answered it the same way. Read one layer down. The reward that swore it was verifiable was flipping a coin. The robot that looked like it saw the task was quietly predicting touch. The productivity that felt free was billed to your own skill.
Eris: If you take one thing to a colleague tomorrow, make it this. The one that's actually actionable this week.
Vestra: When you use AI on something you're supposed to be learning -- ask it to explain, not to solve. Ask why this works, not just give me the working version. That single switch is the difference the study found between keeping the skill and quietly losing it.
Eris: Explain, don't solve. That's the one.
Vestra: And if you're pulling someone's training code into your own loop -- go read the reward function before you trust the curve. Same lesson, different room.
Eris: If this was worth your commute, do the thing that actually helps a small show -- follow us, and leave a comment with one answer: what's a task where AI made you faster but you're pretty sure you learned nothing? We read those, and the honest ones are the best.
Vestra: And every story we touched today, plus the ten we didn't, is written up on Ground Truth -- groundtruth.day, new every morning.
Eris: Read the receipt, not the label. We'll see you tomorrow.