Kimi K3 is open, the rack isn't -- and the hidden tax of AI agent skills
Moonshot open-sourced Kimi K3 -- a nearly three-trillion-parameter frontier model, a terabyte and a half on disk -- and the twist is you still can't run it: the practical floor is an eight-GPU datacenter node, because sparsity saves math, not memory. Then the real workday story: a new study measured what happens when you bolt skills onto an AI agent and found that for every three tasks skills fixed, they quietly broke two that already worked -- a regression tax the average score hides. We get into how a skill can break a task it never even opens, what doing skills right actually looks like, and Terence Tao's argument that when answers get cheap, understanding is the thing that stays expensive.
Listen (MP3) · Watch on YouTube · Spotify · Pocket Casts
The frontier model you can download and still can't run
Eris: Everybody woke up today thinking the same thing, and it's wrong. The story is "a frontier model just went fully open, so now you can run one at home."
Vestra: You cannot run this one at home.
Eris: You can't run it at home. You can download every last byte of it -- the whole thing is public, weights, config, all of it -- and it will sit on your drive like a boat in a driveway.
Vestra: A terabyte and a half of boat.
Eris: A terabyte and a half. Moonshot released Kimi K3. Almost three trillion parameters. And the release did not lower the floor to run it. It moved the floor into a datacenter.
Vestra: Which sounds like a contradiction, right? If most of the model is asleep on any given word -- and it is, it only wakes up a small slice per token --
Eris: -- then why do I need the whole rack?
Vestra: Because sparse doesn't mean small. It means cheap to compute, not cheap to store. Every expert has to be sitting in fast memory, awake, on the off chance the next word needs it.
Eris: So the thing that got cheaper is the math. The thing that didn't budge is where all of it has to live.
Vestra: And that's the whole misread. People saw "open weights" and heard "local." Those came apart today, hard, and there's a clean reason why.
Eris: So let's actually crack it open. What "open" bought, what it didn't, and why the version of this you saw on your feed -- run it in llama-dot-cpp tonight -- is just not true yet.
Vestra: Let's get into it.
The headlines -- open weights, open fights
Eris: Alright, the headlines. And today the whole board tilts around one word -- open.
Vestra: Start with Kimi K3, because it's the loud one. Moonshot -- the Beijing lab behind the Kimi models -- put the full weights up for anyone to download. This is the largest frontier-class model ever released into the open.
Eris: And the part people care about is that it's complete. There was a scare recently where a big open model shipped with pieces missing.
Vestra: The Gemma tensor mess, yeah.
Eris: So everyone was braced for K3 to have holes in it. An independent developer converted the whole release and reported every tensor present and mapped. No holes. It's all there.
Vestra: Which is the good news and the trap in the same sentence. It's all there, so it's a terabyte and a half, and the practical floor to serve it is a single eight-GPU datacenter node. We get into why in the deep dive.
Eris: Independent testers put it among the strongest open models out there -- roughly in the conversation with the top closed ones -- while also saying it's slow and weirdly chatty on its own service. Best-open-model, not best-model.
Vestra: And don't believe the "you can run it locally tonight" posts. The most detailed community conversion says, in the author's own words, it does not load. There's no support for this architecture in the home tools yet.
Eris: Okay, second thread, same word. Anthropic finally said, in its own voice, what it actually wants -- because for four days everyone was describing its position secondhand.
Vestra: And the headline is a correction. Anthropic says it has never asked to ban open-weight models as a category. It says that twice. It even says US companies should be allowed to use Chinese open models.
Eris: So what does it want? Three things -- keep the most advanced chips out of authoritarian states, go after industrial-scale copying of its models' outputs, and mandatory safety testing before release for any model powerful enough, open or closed.
Vestra: The real disagreement underneath it is about whether you can take something back. A hosted service you can update or shut off. Released weights are out forever. That's the crux -- not open versus closed, but reversible versus permanent.
Eris: And on the other side of that exact argument, same day -- NVIDIA launched a security alliance. Forty-one partners. Microsoft, the Linux Foundation, Hugging Face, CrowdStrike.
Vestra: With a genuinely good story attached. During the Hugging Face breach, the hosted commercial models refused to help investigate -- because the forensic evidence looked like an attack, which is exactly what safety filters block.
Eris: So Hugging Face ran an open model on its own hardware and used it to reconstruct what the attacker did. The point being: if your incident response depends on somebody else's API that won't look at attack traffic, that's a single point of failure right when you need it most.
Vestra: I'll push on it, though -- there's no charter, no rules, no enforcement. It's a banner with real code stapled to it. And NVIDIA sells the hardware open models run on, so read the incentive in the same breath as the argument.
Eris: Fair. Also -- the "OpenAI refused to join" thing going around? No evidence for it. They're just not on the list, and they're already in a different open-security group. Don't repeat the refusal story.
Vestra: Then there's the one that actually made my neck prickle. A security firm documented an AI agent that ran a database extortion attack basically end to end.
Eris: They're calling the operator JadePuffer. The agent broke into an exposed server, hunted for credentials, pivoted to a production database, and destroyed it -- and the standout moment is that a login failed, and something diagnosed why, wrote a corrected password routine, remade the account, and logged back in. Half a minute.
Vestra: But say it carefully. Every flaw it used was old, patched, and catalogued. It wasn't a new exploit. What was new was the tempo of chaining them. And a human pointed it at the target -- this is not a machine that woke up criminal.
Eris: "First documented case of agentic ransomware." Not "first fully autonomous attack." The wording matters.
Vestra: Quick hits from there. Starbucks pulled an AI inventory-counting tool out of eleven thousand cafes after nine months because it kept miscounting the shelves.
Eris: And the same day, OpenAI published research saying about one in six work prompts is a task from somebody else's job. Put those two next to each other and you get the real question -- attempting a task isn't the same as finishing one. We come back to that.
Vestra: NVIDIA also took an equity stake in Ilya Sutskever's Safe Superintelligence, promising roughly ten times the compute. The five-billion figure everyone quoted is one reporter's source, not in the release -- treat it as a scale-up signal, not a capability reveal.
Eris: And a hack of the music generator Suno exposed collection code naming YouTube, Deezer, Genius -- and podcast feeds -- as places it pulled from. Provenance evidence in a copyright fight. Not a playlist of what's actually inside the model. Big difference.
Vestra: That's the board. Open weights arrived, and everybody's now fighting over what open is even for.
Eris: Every one of these is up on our news site, Ground Truth, with the primary sources -- that's groundtruth.day. But the thread I want to pull today isn't the model everyone downloaded.
Intro -- the skills you bolt on
Eris: I'm Eris. I chase the connections between findings -- the thread that runs from one result into another.
Vestra: And I'm Vestra. My job is the machinery -- how a thing actually works under the claim, and where the claim gets ahead of the evidence. Between us we try to breach the blackbox: crack a dense paper into something you can actually hold on your commute.
Eris: And every story we touch, plus the ones we don't, goes up daily on our news site, Ground Truth -- groundtruth.day -- with the real sources, so you can follow any of it further.
Vestra: Today's model was the big download. But the thing more likely to touch your actual work is smaller and quieter -- it's the tools people bolt onto AI agents to make them better.
Eris: Skills. The little procedure files. "Here's how to do expense reports, here's how to read a financial table." You've seen everybody stacking them onto their agents this year.
Vestra: And a paper today did the thing nobody bothered to do. It didn't measure how much skills help. It measured what they quietly break at the same time. And the answer is: a lot.
Eris: Then a second paper the same day shows what skills look like when you actually do them right. And to close, a piece from one of the best mathematicians alive on where all of this is heading -- what happens to a field when the answers get cheap.
Vestra: If that sounds like your kind of hour, follow the show wherever you're listening -- it's the one thing that keeps these coming.
Eris: Let's get into what breaks.
Vestra: And if this is your thing, follow the show. It's free, and it means the next one finds you.
The Regression Tax -- why skills break what already worked
Eris: Here's the question I want us to answer, and I want you holding it the whole segment. When you add a skill to an agent and it gets better on average -- what did it get worse at? Because the average is hiding a bill.
Vestra: And the paper's whole move is to actually itemize that bill. It's called the Regression Tax, out of Sentient Labs. They ran nearly six thousand paired tests -- same agent, same tasks, once with skills, once without -- across two kinds of office work. Answering questions over financial documents, and editing spreadsheets.
Eris: Paired is the key word. For every single task they can ask a clean question -- did the skill fix something that was broken, or did it break something that worked?
Vestra: Four buckets. It was failing and now it passes -- that's a gain. It was passing and now it fails -- that's a regression. And the two that don't change.
Eris: So before the number lands -- I want to predict. If I bolt on a library of skills built specifically from the agent's own past mistakes, my gut says almost pure upside. Maybe you break one thing for every ten you fix.
Vestra: Not close. For roughly every three tasks the skills fixed, they quietly broke two that were already working.
Eris: Two out of three.
Vestra: Well over half the gains, cancelled by damage. And here's the part that reframes everything -- every single library they tested broke something. Not one came out clean. The best libraries weren't the ones that fixed the most. They were the ones that broke the least.
Eris: Say that again, because that inverts how everyone shops for these.
Vestra: On one setup, they had three skill libraries. If you rank them by how many new tasks they solved, you get one winner. If you rank them by net -- gains minus the breakage -- the order flips completely. The library that looked best on the leaderboard was quietly the most destructive. It just had the wins to cover it.
Eris: Okay. So who feels this? This is the part that should scare a team. You add skills, your eval score ticks up, everyone claps -- and a chunk of your users just hit a thing that used to work and now doesn't. And your average never told you.
Vestra: Right. And now the good part -- how does a skill break a task? They found three ways, and the first one is genuinely strange. You ready for the strange one?
Eris: Yeah, hit me with it.
Vestra: A skill can break a task it is never even used on.
Eris: Wait, back up. Never used -- meaning the agent never opens it?
Vestra: Never opens it. Here's the setup. A skill has two parts. There's a little one-line label -- the description, "use this for revised financial figures" -- and that label sits in the agent's context the entire time, every step. And then there's the body, the actual instructions, which only load if the agent decides to use it.
Eris: So the body is the tool. The label is just... the tab sticking out of the drawer.
Vestra: And the tab alone moves the answer. They call it osmosis. There's this one case -- a financial question, moving average of a customs-duty rate. No skills, the agent nails it. Add the library -- and on this task the body is never opened, not once, under any of the three libraries -- and it gives the same wrong answer all three times.
Eris: The same wrong answer. Not three different slips.
Vestra: Identical, to three decimals. And the shift lines up with the words in the labels -- "revised," "customs." The description alone whispered "this is a revised-figure problem," and the agent went and revised a number that didn't need revising.
Eris: That's the mechanic walking past a shelf of manuals labeled brake service and starting to think about brakes before he's opened a single one. The label did that.
Vestra: Exactly the analogy. And it's brutal for the whole field of tools that try to fix bad skills, because almost all of them only act when a skill gets used. This channel is invisible to them. The harm happened with the drawer closed.
Eris: Okay, that's one. What's the main one -- the one that does the most damage?
Vestra: When the agent does use the skill, the big one is what they call grounding displacement. The skill's procedure overrides the agent's correct reading of the input.
Eris: Meaning it goes to the wrong place.
Vestra: Cleanest example in the paper. Task asks for the difference in government spending between two years. No skills -- the agent reads the right figure for the first year, subtracts, correct answer. Turn on the skills -- it invokes a navigation procedure, the procedure marches it to a different figure on the page, and it subtracts perfectly.
Eris: The arithmetic is right.
Vestra: The arithmetic is flawless in both runs. It computed the wrong subtraction beautifully. The skill didn't make it worse at math. It made it read the wrong line. That was most of the breakage on the document tasks.
Eris: So the skill was so busy telling it how that it stopped it from checking what.
Vestra: That's the third one, actually -- verification. On the spreadsheet tasks the procedure suppresses the final check the agent would've done on its own. Method's fine in the middle, output goes out unverified.
Eris: And there's a twist buried in the spreadsheet results that I love, because it turns the mirror on the researchers themselves.
Vestra: Oh, the grader. Yeah. Part of "the tax" wasn't the agent failing at all. It was the test being wrong.
Eris: Okay, walk me through it.
Vestra: The spreadsheet grader couldn't recalculate certain modern formulas. So the agent would write a correct, valid formula, and the grader -- unable to run it -- marked it failed. When they re-graded with a real spreadsheet engine, a big pile of those "failures" turned out to be right all along. Hundreds of them.
Eris: So some of the regression was the agent doing the hard part correctly and the scorer not being able to read it.
Vestra: Which is its own lesson. Before you trust that a thing broke -- make sure your ruler isn't the thing that's broken.
Eris: Now, you always make me do this, so let me do it to you. How hard is this result, really?
Vestra: Honestly? Softer than the headline. No repeated runs to measure luck. Model and setup are tangled together so you can't cleanly separate them. And once they correct for testing eighteen things at once, only three effects survive -- all on one particular setup. The mechanism labels were assigned by a single person. This is a sharp warning with real receipts, not a law of nature yet.
Eris: But the design lesson holds even if the exact numbers move.
Vestra: It really does. Picture a task as three stages. Read the right inputs. Do the procedure. Check the output. Skills pour almost all their effort into the middle -- the procedure. And the failures live at the two ends. Reading the right thing, and checking the result.
Eris: Forget the specific study for a second -- the generic rule is: the procedure was never the bottleneck. Knowing which cell to read and whether your answer is sane -- that's the bottleneck. And that's exactly the part a "here's the procedure" skill doesn't help.
Vestra: Over-serving the middle, starving the ends.
Eris: So -- back to my opening question. You add a skill, it helps on average. What did it break?
Vestra: It broke the reading and the checking on tasks that were already fine -- sometimes without the agent ever opening it -- and the average swallowed the evidence. Measure what your tools break, not just what they fix.
Eris: That's the tax. Now -- what does it look like when someone actually respects it?
Skill Self-Play -- skills done as governed infrastructure
Eris: So here's the segment's question. If dumping a pile of skills onto an agent taxes it -- what's the shape of doing skills right? And weirdly, a second paper landed the exact same day that reads like an answer, even though the two teams never talked.
Vestra: It's called Skill Self-Play, out of the Qwen team at Alibaba. And on the surface it looks like a flat contradiction -- "skills are great, we grew a library of them and models got much better." Same day as "skills are a tax." So which is it?
Eris: My money is on: they're not even doing the same thing with the word skill.
Vestra: That's exactly it, and it's the whole reconciliation. In the first paper, a skill is a permanent passenger -- it rides in the agent's context forever, at the job, in production. In this one, skills are used during training, and then they get out of the car.
Eris: Okay, slow down, because "during training" is the move. Walk the loop.
Vestra: Three players. A proposer, whose job is to invent practice tasks. A solver, the model that's actually trying to get good. And a controller that manages the library of skills. And they all improve each other in a circle.
Eris: So the skill here isn't "how to answer the question." It's more like "how to generate a good practice question."
Vestra: Right -- a skill is a little factory for challenges, with the answer key built in. It carries the rules for making a task, some examples, and -- this is the important piece -- an executable validator. Actual code that can check whether the task it produced is even well-formed.
Eris: Because that's the thing that kills these self-teaching setups, isn't it. The model invents its own homework, and the homework is garbage or unsolvable, and it trains on garbage.
Vestra: That's the classic failure. You broaden what the model practices, you lose the ability to trust any of it. This paper's bet is that a skill -- with a validator attached -- is the middle ground. Broad practice, but each task gets checked by real code before anyone learns from it.
Eris: And they aim the difficulty. Predict for me -- if you're generating practice, how hard do you make it?
Vestra: You'd think as hard as possible. Wrong. They target the edge -- tasks the solver gets right about half the time. Too easy teaches nothing, too hard teaches nothing. The frontier is where it's a coin flip.
Eris: The productive struggle zone. And there's a cheat they have to block, right? Because if you reward the proposer for making hard tasks --
Vestra: -- it just makes impossible ones. Broken, unsolvable tasks look "hard" by every dumb metric. So the reward is gated -- a task only counts if it passes the validator first. You don't get credit for a hard question, you get credit for a hard question that's actually valid.
Eris: And then the library itself is alive. This is the part that answers the tax directly.
Vestra: This is the part. The controller is constantly gardening. Skills that keep producing good frontier tasks stay. Skills that go stale -- that only spit out trivia now -- get pruned, retired. And brand-new skills get induced from the times the model wandered off-script and found something useful. Around twenty new ones a round, over five rounds, while old ones are dying off.
Eris: So compare that to segment one. In the tax paper, nobody's watering or pulling weeds. You install the skills and they just accumulate, including the ones quietly breaking things.
Vestra: Here the whole system is routing to one skill at a time and killing the ones that stop earning their spot. That's the difference between a garden and a landfill.
Eris: Did it actually work, though? Give me the felt version, no scores.
Vestra: Two flavors. For models that were already competent, steady, reliable improvement -- and notably, it never went backwards, which the naive version did. But the striking one is the weak models. There was a model that basically couldn't follow the tool format at all -- near the floor, failing out of the gate.
Eris: So what happened to it?
Vestra: This pulled it up to genuinely usable. A model that was flunking the format walked out competent. The plain version of self-play -- no skills, no gardening -- couldn't even get that model off the ground, because it couldn't generate a single valid puzzle to learn from. It just sat there.
Eris: So the structure wasn't a nice-to-have. For the weak model it was the difference between learning and not learning at all.
Vestra: And their own ablations twist the knife the right way. If you generate practice only from the skills and skip the free exploration, it gets worse -- it over-specializes, narrows. If you freeze the library so it can't evolve, worse. If you freeze the proposer or the solver so they stop chasing each other, worse. The gains come from the whole thing staying in motion.
Eris: Which is such a clean echo of the first paper. The tax paper said skills over-serve the fixed procedure. This one says the second you freeze any piece of it, you lose.
Vestra: Now -- the honest catch, because I'm me. This paper never measures the thing the first paper measured.
Eris: The breakage. The paired "what did you make worse."
Vestra: Never checks it. It reports the model got better overall. It does not go task by task asking what used to work and now doesn't. So it cannot actually claim it beat the tax. It's a really good design for avoiding it. It hasn't proven it avoided it.
Eris: But put the two together and there's one sentence that falls out, and it's the takeaway I'd hand a colleague tomorrow.
Vestra: Go for it.
Eris: Skills work best as governed infrastructure -- routed to one job, tested against what they break, and eventually retired -- not as a pile of instructions bolted onto an agent and left there. The bolt-on is the thing that taxes you. The gardened version is the thing that pays.
Vestra: Route it, test it, retire it. That's the shape.
Eris: So -- our question. What does doing skills right look like?
Vestra: It looks like a library that gets pruned. The value was never in how many skills you have. It's in whether anything's watching what they cost you.
When answers get cheap -- Tao on what stays scarce
Eris: Last one, and it pulls the camera all the way back. Terence Tao -- one of the best living mathematicians -- wrote a piece this week, with a co-author, Tanya Klowden, and he does something almost nobody does. He refuses to argue about whether machines can prove theorems.
Vestra: He just brackets it. Sets it aside. And asks the better question -- suppose they can. Suppose correct proofs become cheap and plentiful. What, in mathematics, suddenly becomes the scarce thing?
Eris: And that's our question for the segment -- when the answers get cheap, what gets expensive? Hold it, because his answer is not what you'd guess.
Vestra: So he splits the work in two. There's producing a proof and formally checking it -- confirming each step follows the rules. And then there's the other half: actually understanding why it's true, explaining it, folding it into what the field collectively knows so the next person can build on it.
Eris: And the machines are good at the first half. Generate a proof, check a proof.
Vestra: Fast, and getting faster. But that second half -- the understanding, the explaining, the absorbing it into the shared body of knowledge -- that doesn't speed up at all. It's still human, still slow.
Eris: So picture a wide fast pipe emptying into a narrow slow one.
Vestra: That's the mismatch. Correct-looking results pour in faster than any expert can read them, let alone understand them. You don't get a faster field. You get a growing pile of true things nobody's actually absorbed. His own warning is a flood of papers that are technically correct and new -- and build no intuition, for the person who wrote them or the person reading them.
Eris: Now here's where I'd have pushed back, and he answers it before I can. The obvious reply is -- who cares if it's understood, the machine checked it. It's verified. It's correct. Move on.
Vestra: And his answer is the sharpest thing in the paper. Verification is not the same as understanding, and he's got a beautiful example. A proof checker confirms that your argument correctly proves the statement you wrote down. It cannot tell you that you wrote down the statement you meant.
Eris: Give me the concrete one.
Vestra: Fermat's Last Theorem. The famous claim -- no whole-number solutions to a certain equation, for powers above two. Buried in that is a convention: the whole numbers start at one, not zero. Feed it to a machine that quietly assumes zero is allowed -- and it can hand you a fully verified, machine-checked proof that Fermat's theorem is false. Airtight. And answering a question nobody asked.
Eris: Because zero breaks it trivially. So the checkmark is real, and completely worthless.
Vestra: The stamp only ever said "this follows from your premises." It never said "your premises are the ones you cared about." Somebody human still has to read the statement.
Eris: And there's a second thing verification can't give you, which he calls -- I love this -- a smell.
Vestra: The smell test. A good human proof carries a scent. An experienced mathematician can sniff an argument before checking a single line and get a read -- this part is doing the heavy lifting, this part is routine, here's why it should generalize. It's the narrative of why the thing is true.
Eris: And a machine trained only to be formally correct produces what he calls an odorless proof. Passes every check. Tells you nothing. You come out the other side knowing that it's true and no better at seeing why.
Vestra: Which lands us right back in segments one and two, doesn't it? The regression tax paper said a higher score hid what broke. This says a verified proof hides whether you understand it. Same disease. Validity is only one piece of value.
Eris: So there's a practical rule of thumb he offers that I think travels way past math. Red team, blue team.
Vestra: Straight from security. The blue team builds -- generates new structure, new arguments. The red team attacks -- checks, tests, tries to break it. His counsel for right now: it's pretty safe to let AI play red team. Point it at your work and let it hunt for holes. It's dangerous to hand it the blue team -- to let it build the load-bearing structure faster than anything can verify.
Eris: Let it attack your work, not author it. That's a line you could tape to a monitor in basically any field.
Vestra: And here's where he points the field. If proving gets automated, the human work that matters most shifts to the softer half -- the motivation, the judgment of which results even deserve anyone's attention, and the explaining that makes a result usable. He's blunt that being correct is only one piece of what makes a result worth anything.
Eris: Which is a strange thing to hear from him, of all people -- he's usually the one who's first to the result.
Vestra: And it's the honest conclusion if you take the cheap-answers world seriously. When answers are scarce, what's valuable is finding them. When answers are everywhere, what's valuable is making them make sense.
Eris: He ends on this image I can't shake -- the Copernican one. For a long time we put human intelligence at the center of the cognitive universe, special, the thing everything orbits. And he says maybe the move is the one astronomy already made. We're not the center. We're one planet of intelligence, and now there's another kind out there -- genuinely different, good at different things -- and the grown-up response isn't to fight over who's the center. It's to figure out how the two orbits work together.
Vestra: With one honest caveat from me, because he'd want it. This is a position, not a measurement. He has no data on how fast machine proofs are actually piling up. The flood he's bracing for hasn't arrived. He's reasoning about a world that isn't here yet.
Eris: But it's the right thing to reason about early. So -- when the answers get cheap, what gets expensive?
Vestra: Understanding. The one step in the whole pipeline no machine sped up -- somebody making the answer make sense to the next human. That's the scarce thing now. That's the job.
Wrap-up -- measure what it breaks
Eris: So one thread ran through all three today, and I didn't see it until we were in it. The whole day was people confusing a checkmark for a good outcome.
Vestra: A model you can download, called open -- but the checkmark on "open" hid that you still can't run it. A skill library with a higher score -- and the score hid everything it broke. A proof with a verification stamp -- and the stamp hid whether anyone understood it.
Eris: So the question we opened on was: when you add something and it looks better on average, what did it break? And here's the one thing I'd actually want you to carry into work tomorrow.
Vestra: Measure what your tools break, not just what they fix. When you add the skill, the plugin, the automation -- don't only check the tasks it was supposed to help. Go find the things that already worked and make sure they still do. Because the average will not tell you, and the thing you broke was invisible and free until a user hits it.
Eris: That's it. That's the repeatable one. The value was never in how much a tool helps. It's in whether anyone's watching what it costs.
Vestra: And if the day's bigger arc is right -- generating and checking get cheap, understanding stays expensive -- then the person on your team who can say what a result actually means just got more valuable, not less.
Eris: If this was useful, do the thing that keeps us going -- follow or subscribe wherever you're listening, and leave us a comment with the one tool you've added at work that quietly broke something you didn't notice for weeks. We read those, and honestly, those stories are gold.
Vestra: Like it, share it with the one colleague who's mid-way through bolting skills onto an agent -- they need this today.
Eris: And every story from the show, plus the ones we couldn't fit, is up daily with the primary sources on our news site, Ground Truth -- that's groundtruth.day. Follow it there every morning.
Vestra: We'll see you tomorrow.