The context gap, Treasury pulls back, and scaffolding video

00:00:04 A year ago, Yugabyte built four agents. Two for customer support and sales coordination internally, two external ones for their customers: an agentic database admin called Perf Advisor and a migration tool named Voyager. None of them shipped anything that actually worked.

00:00:22 It wasn't the kind of failure where you miss a deadline or underperform on benchmarks. It's the kind where nothing holds together because every agent in the chain has to rediscover what the first one figured out, burns more tokens doing it, and delivers worse results than if someone had just shown them the context.

00:00:44 Karthik Ranganathan, Yugabyte's co-founder and CEO, laid this out in a YouTube presentation today. His framing is straightforward: agent memory works fine for single agents. The real problem is learning in groups — what happens when Agent A does work that Agent B needs, and all you can hand over is the output?

00:01:06 A markdown file. A PDF. Whatever the model wrote. What gets lost is the reasoning behind it. The dead ends. The count of failures before the approach actually lands. When a new person joins a human team, you don't hand them the deliverable and say 'go.' You bring them into the project, show them the history, and walk through how decisions were made.

00:01:31 Agents don't get that treatment. Yugabyte ran four agents for almost a year before realizing the bottleneck was architectural. They tried distributed RAG pipelines — "extremely scalable, very elastic," according to their own description — letting each agent spin up its own Postgres database.

00:01:51 They tried headless backend processing with no UI. None of it delivered value. Then they hit on the numbers that matter for anyone building agents right now. Faithfulness on public benchmarks jumped from fourteen percent to sixty-five, while PDF retrieval climbed from twenty to seventy-four.

00:02:11 Context precision hit eighty-two, and effective context chunks dropped from roughly 7,000 down to 1,000.

00:02:18 The chunk reduction is where this becomes interesting for builders burning tokens across multiple agent handoffs. They're using less than a tenth of the original context size while seeing higher accuracy and lower spend — a delta builders will notice. What Yugabyte built in response is called Mako, an agent-native persistence layer that unifies vector, graph, relational, and NoSQL storage into what they call data packs.

00:02:46 Agents push pieces of their context into private space, promote them through supervised workflows requiring human approval before anything becomes shared knowledge, and other agents pull high-quality pieces without re-deriving them.

00:03:02 Ranganathan listed five common misconceptions worth reading together because they reveal where the industry is confused about what actually matters: more memory isn't learning; shared state isn't shared knowledge; rag transcripts don't equal quality but just more tokens burning to produce worse results; fine-tuning isn't scalable for persisting lessons across agents; and a bigger context window is the fastest way to fail in the most expensive manner because your context rots.

00:03:35 Every single one of those was a path Yugabyte tried and found wanting. Their distributed RAG pipeline did exactly what it was designed to do — scale elastically — and delivered no value. The promotion workflow is where the design gets interesting. Not everyone contributes to shared context, and pieces are vetted through supervised approval before becoming durable.

00:03:59 It's code review for machine memory. Traceability matters here: you should be able to ask where a piece of information came from and get an answer that traces back to a source, a person, or a conversation. The demo Ranganathan showed at the end was straightforward enough that you might overlook its significance until you think about what it means.

00:04:23 Storing an incident fact about a signup email failure in Mako, killing the session, opening a different IDE under the same account, and posing the query. The updated agent finds the old answer from Mako instead of burning tokens trying to figure it out again. The claim is modest — not full training, just labeled examples that seed agent-specific taste over time.

00:04:48 It sits squarely at the actual gap in today's agentic stack.

00:04:52 On the policy side this morning, WatcherGuru reported that the US Treasury withdrew its proposed crypto surveillance rules targeting unhosted wallets and mixers. The story came in as a JUST IN Monday morning. The proposed rules would have extended financial surveillance obligations to users and tools interacting with private cryptocurrency — one of the more ambitious enforcement vectors the Treasury had been building.

00:05:22 Withdrawing them means regulators stepped back from at least one direction they'd been pushing toward. It's a signal that either the legal foundation was thinner than expected or industry pushback outweighed whatever regulatory ambition was in play. Then there's CFTC Chair Mike Selig saying BIG news is coming.

00:05:44 His tweet has gathered over sixty thousand views and three hundred forty likes as of this morning, so anyone watching crypto regulation closely is probably waiting to find out what it is.

00:05:57 Gitframes appeared on Hacker News with thirty-nine points and nineteen comments. The reaction followed a predictable pattern for a tool claiming Photoshop, After Effects, and Blender-class capabilities in one package. People pointed out that the README reads like an AI wrote it — which it probably did.

00:06:19 But buried under the marketing prose is something worth examining: video composition as software engineering instead of headless browser screenshots. Most automated video generation today goes through headless browsers. Puppeteer or Chromium IPC, DOM reflow, screenshot capture — a slow, memory-heavy pipeline that renders at roughly five to twenty frames per second and consumes two to four gigabytes of RAM per worker.

00:06:49 Gitframes talks directly to the GPU via WebGPU and Dawn, renders frame-accurate video through hardware encoding, ships in about 200 megabytes of RAM instead of gigabytes, and claims sixty to one-hundred-twenty frames per second. The benchmark comparison with Remotion and Hyperframes in the README shows real engineering work even if the writing around it doesn't match.

00:07:16 The sharpest point in the HN thread came from someone suggesting we need less Photoshop-for-AI and more rails-new-my-proj-for-video — scaffolding, not feature parity. That's the actual bottleneck. The models can generate video now. What builders lack is deterministic composition: frame-accurate clocks, reproducible sequences, version control over media that traditionally lives in non-text file formats.

00:07:45 The token spend issue that WSJ flagged this week follows a clear pattern: businesses find it almost impossible to budget for AI usage because every model charges differently, every API shifts its pricing weekly, and usage scales non-linearly with complexity. That's the financial side of the architecture problem Yugabyte documented.

00:08:06 If Mako's claim holds up in production environments — reducing effective context size to one-seventh while improving accuracy by four or five times — then context management stops being an engineering concern and starts becoming a budgeting one. Every organization running multi-agent workflows today should track how their token spending looks with and without durable context layers.

00:08:31 That's the infrastructure question for builders: the layer that matters most isn't always the model layer. It's the layer that determines whether your agents repeat work or remember it, whether they burn tokens or conserve them, and whether the organization can forecast costs instead of guessing.