Latest / Braid / Open Source Catches Fire

Transcript

Open Source Catches Fire · Braid

• 0:04
  Kimi just changed the game.
• 0:06
  Not with another benchmark win that doesn't translate to real work.
• 0:11
  With something that does.
• 0:13
  K2.6, their latest open-source model, hit 58.6 percent on SWE-Bench Pro.
• 0:18
  GPT-5.4 with its expensive xhigh reasoning mode?
• 0:22
  57.7 percent.
• 0:23
  Terminal-Bench 2.0, where you're actually running commands and fixing real systems?
• 0:29
  K2.6 gets 66.7.
• 0:30
  GPT-5.4 gets 65.4.
• 0:32
  These aren't cherry-picked metrics.
• 0:34
  SWE-Bench Pro tests whether a model can actually fix bugs in production codebases.
• 0:41
  Terminal-Bench measures whether it can navigate a real shell, understand error messages, and complete multi-step system tasks.
• 0:50
  The kinds of things you'd trust an engineer to do unsupervised.
• 0:55
  But here's what matters more than the numbers.
• 0:59
  The Kimi team demonstrated K2.6 running for thirteen hours straight, optimizing an eight-year-old financial matching engine.
• 1:08
  The model made over a thousand tool calls, modified four thousand lines of code, analyzed CPU flame graphs to find bottlenecks, and then—this is the impressive part—it reconfigured the core thread topology from four matching engines and two risk engines to two and one.
• 1:29
  The result?
• 1:30
  A hundred and eighty-five percent throughput improvement on a system that was already near its performance ceiling.
• 1:38
  Thirteen hours.
• 1:40
  Four thousand lines changed.
• 1:42
  Not a demo.
• 1:43
  Not a toy problem.
• 1:44
  A real system that handles real money.
• 1:47
  From their technical report, quote: 'K2.6 seamlessly coordinates heterogeneous agents to combine complementary skills: broad search layered with deep research, large-scale document analysis fused with long-form writing.' End quote.
• 2:04
  They're not just matching closed models on benchmarks.
• 2:09
  They're pioneering agent swarm architectures that scale to three hundred sub-agents executing four thousand coordinated steps simultaneously.
• 2:19
  And it's open source.
• 2:21
  You can download it today.
• 2:23
  Run it on your own hardware.
• 2:25
  No API fees.
• 2:26
  No rate limits.
• 2:27
  No wondering what data is being logged.
• 2:30
  The testimonials from beta testers read like something OpenAI would kill for.
• 2:36
  CodeBuddy reported code generation accuracy up twelve percent over K2.5.
• 2:42
  KiloClaw called it 'SOTA-level performance at a fraction of the cost.' Multiple companies are already running it in production.
• 2:51
  DHH had an interesting observation yesterday about the AI coding gap.
• 2:57
  He wrote, quote: 'Designers have been granted prototyping super powers with AI, but the models are still not good enough to consistently one-shot implementations you'd want to merge to master on large, critical applications like Basecamp without programmer review.' End quote.
• 3:18
  He's right about most models.
• 3:20
  But K2.6's thirteen-hour autonomous session suggests we're approaching the point where that disclaimer needs revision.
• 3:29
  When a model can sustain that level of complex reasoning over that duration, the gap between prototype and production starts to close.
• 3:39
  The economics here are brutal for closed providers.
• 3:43
  Every improvement in open models directly cuts into their pricing power.
• 3:49
  Why pay dollars per million tokens when you can run something comparable locally?
• 3:55
  Why accept rate limits when you control the hardware?
• 3:59
  Why trust your code to someone else's servers when you don't have to?
• 4:04
  Kimi isn't alone.
• 4:06
  Qwen dropped their 3.6 Max Preview yesterday, hitting the highest score among Chinese models.
• 4:13
  The community is quantizing Gemma 4 as we speak.
• 4:16
  The open ecosystem is moving faster than any single company can.
• 4:21
  This is the inflection point.
• 4:23
  Not when open source catches up.
• 4:26
  When it catches fire.
• 4:28
  While everyone's racing to build the next agent framework, Mario Zechner dropped some uncomfortable truth this morning.
• 4:36
  He's not a skeptic—he's building coding agents and LLM tools.
• 4:40
  Which makes his warning worth hearing.
• 4:43
  From his thread, quote: 'OVERRATED: running tons of agents in parallel; working on too many things at once; perpetual context-switching; opening lots of low-quality PRs that may never land.
• 4:56
  UNDERRATED: using one or two agents at a time; focusing on the task in front of you; thinking deeply; finishing.' End quote.
• 5:05
  This cuts against everything the agent platforms are selling.
• 5:09
  The pitch is always more agents, more parallelization, more autonomous execution.
• 5:15
  Spawn a hundred agents!
• 5:16
  Let them coordinate!
• 5:18
  Watch the magic happen!
• 5:19
  Except Zechner's building these systems.
• 5:22
  And he's telling you the magic doesn't happen.
• 5:25
  What happens is noise.
• 5:27
  Conflicts.
• 5:28
  Half-finished work that needs human cleanup.
• 5:31
  Later in the thread, he got more pointed.
• 5:34
  Quote: 'You've learned nothing from the terrible fucking outcomes we observed with other tech like social media.
• 5:42
  You'll reap what you sow.' End quote.
• 5:44
  He's specifically calling out the 'kids plus AI' conversation, where people are suggesting children should have unsupervised access to sycophantic language models.
• 5:56
  But the broader point stands.
• 5:58
  We're repeating patterns we should recognize.
• 6:01
  Racing to deploy before understanding consequences.
• 6:04
  Optimizing for demos instead of outcomes.
• 6:07
  Building what's possible instead of what's wise.
• 6:11
  The Kimi team, interestingly, seems to understand this tension.
• 6:15
  Their agent swarm architecture scales to hundreds of sub-agents, but they emphasize coordination and validation.
• 6:23
  Each agent has a specific role.
• 6:25
  There's a conductor managing the orchestra.
• 6:28
  They're not just spawning processes and hoping for emergence.
• 6:32
  I've been watching the OpenCode and ClaudCode communities.
• 6:37
  The pattern is consistent.
• 6:38
  The people getting real work done are using one or two agents, carefully prompted, with human oversight at key decision points.
• 6:47
  The people spawning agent swarms are mostly generating GitHub issues about why their agents aren't working.
• 6:55
  There's a related reality check in the LocalLLaMA subreddit.
• 6:59
  Someone asked if anyone's getting real coding work done with Qwen 3.6 on a thirty-two gigabyte Mac.
• 7:06
  The responses were telling.
• 7:08
  To avoid memory exhaustion, you have to cut the context window to thirty-two thousand tokens.
• 7:14
  That's fine for small tasks.
• 7:16
  But for the kind of whole-codebase reasoning these agent frameworks promise?
• 7:22
  Forget it.
• 7:23
  Another user reported that Qwen plus something called ik_llama gets fifty tokens per second with a two-hundred-thousand token context window.
• 7:32
  Impressive.
• 7:33
  But they didn't mention accuracy.
• 7:36
  Speed without correctness is just faster failure.
• 7:39
  The tools are getting better.
• 7:41
  The benchmarks keep climbing.
• 7:43
  But the gap between demo and daily remains.
• 7:46
  Between what's possible in a controlled environment and what works when your codebase is messy, your requirements are unclear, and your deadline was yesterday.
• 7:57
  Maybe that's fine.
• 7:59
  Maybe we need this experimental phase where people try everything, fail loudly, and learn what actually works.
• 8:06
  But Zechner's warning resonates because we've seen this movie before.
• 8:11
  The hype cycle that ignores human factors.
• 8:14
  The tools that solve the wrong problems.
• 8:17
  The complexity that makes simple things hard.
• 8:20
  One or two agents.
• 8:21
  Deep focus.
• 8:22
  Finish the task.
• 8:23
  Sometimes the most advanced approach is knowing when not to be advanced.
• 8:28
  Kepano, Obsidian's CEO, caught something important yesterday.
• 8:32
  Atlassian quietly updated their terms.
• 8:35
  Starting August seventeenth, twenty twenty-six, all data from Jira and Confluence will be used for AI training unless you explicitly opt out.
• 8:45
  Some data can't be opted out at all, depending on your plan.
• 8:49
  From Kepano's thread: Quote: 'The following threads gather more examples of opt-in AI training policies rolled out by Google, Zoom, Dropbox, Adobe, Slack, Figma, GitHub, etc.
• 9:02
  My default assumption is that every SaaS platform will do this for any data that isn't end-to-end encrypted.' End quote.
• 9:10
  Every.
• 9:11
  SaaS.
• 9:12
  Platform.
• 9:12
  Think about what lives in Jira.
• 9:15
  Your product roadmap.
• 9:16
  Your security vulnerabilities.
• 9:18
  Your customer complaints.
• 9:20
  Your engineering post-mortems.
• 9:22
  The detailed discussions about why your competitor's approach won't work and what you're building instead.
• 9:30
  Now imagine that data training a model that your competitors can query.
• 9:35
  Atlassian's not alone.
• 9:36
  Adobe did it with Creative Cloud.
• 9:39
  Slack's been doing it.
• 9:40
  GitHub Copilot was trained on every public repo, and nobody asked if maybe some of that GPL code shouldn't be laundered into proprietary codebases.
• 9:51
  The pattern is consistent: announce the change, bury it in terms updates, make opting out harder than accepting.
• 9:58
  There's a brutal information asymmetry here.
• 10:02
  These companies know exactly what they're collecting, how they're using it, what models they're training.
• 10:09
  You know nothing.
• 10:10
  You can't audit the training pipeline.
• 10:13
  You can't verify data isolation.
• 10:15
  You can't even confirm your opt-out was respected.
• 10:19
  The enterprise response has been predictably weak.
• 10:22
  Some companies are adding contract clauses.
• 10:25
  Others are writing strongly-worded memos.
• 10:28
  But when your entire workflow runs on these platforms, what leverage do you actually have?
• 10:35
  Switch from Jira to what?
• 10:36
  Move from Confluence to where?
• 10:38
  Every alternative is doing the same thing.
• 10:41
  This connects to yesterday's trust boundary discussion.
• 10:45
  We learned that Vercel's security incident came from treating OAuth tokens as 'non-sensitive.' Now we're watching every SaaS company treat your proprietary data as 'training-eligible.' The pattern is the same—redefining boundaries to benefit the platform, not the user.
• 11:04
  Kepano's thread sparked interesting responses.
• 11:08
  Some people suggested this will drive companies to self-host.
• 11:12
  Others predicted a boom in end-to-end encrypted alternatives.
• 11:16
  But the real tell was how many people were surprised.
• 11:20
  They hadn't read the terms.
• 11:22
  They didn't know this was happening.
• 11:24
  They assumed their vendor was a service provider, not a data harvester.
• 11:29
  The open-source angle here matters.
• 11:32
  When you run Kimi K2.6 locally, your data stays local.
• 11:36
  When you self-host Ollama, your prompts don't leave your network.
• 11:40
  The privacy guarantee isn't contractual—it's architectural.
• 11:45
  The model can't phone home with your data because it doesn't have a home to phone.
• 11:50
  But most companies won't self-host.
• 11:53
  They chose SaaS because they didn't want to manage infrastructure.
• 11:58
  Now they're discovering the real price wasn't the monthly subscription.
• 12:03
  It was their competitive advantage, slowly bleeding into training sets they'll never see.
• 12:09
  August seventeenth.
• 12:10
  That's your deadline to opt out of Atlassian's training.
• 12:14
  Assuming opt-out actually works.
• 12:16
  Assuming they honor it.
• 12:18
  Assuming the model they already trained doesn't include your data from before you knew to object.
• 12:25
  The optimistic read is that this will force better data governance.
• 12:30
  Companies will finally audit what they're sharing.
• 12:33
  Engineers will push back on surveillance architecture.
• 12:37
  Competition will emerge around privacy guarantees.
• 12:41
  The realistic read?
• 12:42
  Most companies will click accept.
• 12:44
  The models will train.
• 12:46
  And somewhere, a competitor's AI will be learning from your sprint retrospectives.
• 12:51
  Deezer dropped a number yesterday that should terrify every creative professional.
• 12:57
  Forty-four percent of songs uploaded to their platform daily are AI-generated.
• 13:02
  Not eventually.
• 13:04
  Not projected.
• 13:05
  Right now.
• 13:05
  Today.
• 13:06
  Seventy-five thousand AI tracks per day.
• 13:09
  Two million per month.
• 13:11
  The flood started as a trickle—ten thousand daily in January twenty twenty-five.
• 13:17
  Then thirty thousand by September.
• 13:19
  Sixty thousand by January this year.
• 13:22
  Now seventy-five thousand and climbing.
• 13:25
  But here's the twist: only one to three percent of actual streams are AI music.
• 13:31
  People are generating millions of songs nobody listens to.
• 13:35
  Eighty-five percent of the AI streams that do happen?
• 13:39
  Fraudulent.
• 13:40
  Bot farms streaming their own content to game the royalty system.
• 13:44
  Deezer's CEO, Alexis Lanternier, tried to sound optimistic.
• 13:49
  From their release: Quote: 'AI-generated music is now far from a marginal phenomenon and as daily deliveries keep increasing, we hope the whole music ecosystem will join us in taking action to help safeguard artists' rights.' End quote.
• 14:06
  Safeguard artists' rights.
• 14:08
  While their platform drowns in AI slop.
• 14:11
  The survey data is worse.
• 14:13
  Ninety-seven percent of listeners can't tell the difference between AI and human-made music.
• 14:20
  Ninety-seven percent.
• 14:21
  The Turing test for music isn't coming—it's been passed, at scale, and nobody noticed.
• 14:28
  Meanwhile, an AI-generated track topped the iTunes charts last week.
• 14:33
  United States, United Kingdom, France, Canada, New Zealand.
• 14:37
  Not some experimental electronic piece where AI might make sense.
• 14:42
  Just a song.
• 14:43
  Competing with human artists.
• 14:45
  Winning.
• 14:46
  Deezer's response has been to tag AI content and exclude it from recommendations and editorial playlists.
• 14:53
  They won't store high-resolution versions anymore.
• 14:57
  But they're still hosting it.
• 14:59
  Still serving it.
• 15:01
  Still treating it as music, just with an asterisk.
• 15:04
  This isn't just about music.
• 15:06
  TechCrunch buried the lede, but it's right there—this is every creative field's future.
• 15:13
  Writing.
• 15:14
  Design.
• 15:14
  Video.
• 15:15
  Photography.
• 15:16
  When the cost to create drops to zero, when quality becomes good enough that humans can't tell the difference, what happens to the humans who used to create?
• 15:28
  The optimists say AI will democratize creativity.
• 15:31
  Everyone can be a musician now.
• 15:34
  Everyone can make their dreams audible.
• 15:36
  But that's not what's happening.
• 15:39
  What's happening is bot farms flooding platforms with generated content to extract micropayments.
• 15:46
  It's the SEO spam era, but for every creative medium.
• 15:50
  And the platforms are complicit.
• 15:52
  Deezer could refuse AI content entirely.
• 15:55
  They could require human verification.
• 15:58
  They could prioritize human creators.
• 16:01
  Instead, they're managing the flood, trying to keep it just below the level where users revolt.
• 16:08
  Forty-four percent today.
• 16:10
  What's it next month?
• 16:11
  Sixty?
• 16:12
  Seventy?
• 16:13
  At some point, human music becomes the exception, not the rule.
• 16:18
  At some point, curation becomes impossible because there's too much to curate.
• 16:23
  At some point, the platform becomes a vast ocean of AI content with tiny islands of human creativity, impossible to find without a map nobody's making.
• 16:34
  The parallel to code is obvious.
• 16:37
  GitHub's probably seeing similar ratios—AI-generated pull requests, automated issues, bot-written documentation.
• 16:45
  The difference is code either works or it doesn't.
• 16:49
  Music just has to sound pleasant.
• 16:51
  The quality bar is subjective, which makes it easier to flood.
• 16:56
  Someone on Hacker News asked the right question: if ninety-seven percent of people can't tell the difference, does the difference matter?
• 17:06
  If the audience is happy with AI music, who are we protecting human musicians from?
• 17:12
  Maybe from a future where human creativity becomes a luxury good.
• 17:17
  Where real human-made music costs extra, like organic food or handmade furniture.
• 17:23
  Where most people consume AI content because it's free and good enough, while a small elite pays for the authenticity of human imperfection.
• 17:33
  Forty-four percent.
• 17:34
  And climbing.
• 17:34
  A blog post hit Hacker News yesterday that should be required reading for anyone building agent systems.
• 17:41
  The title: 'OpenClaw isn't fooling me.
• 17:44
  I remember MS-DOS.' The argument: we're repeating every security mistake from the personal computing revolution, just with AI agents instead of operating systems.
• 17:55
  The author reminisces about DOS, where any program could, quote: 'peek and poke the kernel, hook interrupts, write anywhere on disk.' End quote.
• 18:06
  No process isolation.
• 18:07
  No permission model.
• 18:09
  No safety.
• 18:09
  Just trust that programs would behave.
• 18:12
  Sound familiar?
• 18:13
  Look at most agent frameworks.
• 18:15
  One process.
• 18:16
  One token.
• 18:17
  Complete access to everything.
• 18:19
  Trust the LLM to not delete your files, leak your secrets, or run destructive commands.
• 18:25
  It's DOS all over again, just with natural language instead of assembly.
• 18:31
  The post includes a spectacular anecdote.
• 18:34
  A drunk Swedish IT consultant in a Chicago bar, standing on a table, shouting about Walmart's point-of-sale systems.
• 18:42
  Quote: 'CAN YOU BELIEVE WAL-MART HAS HUNDREDS OF THOUSANDS OF DOS MACHINES WITH ALL YOUR FUCKING PAYMENT CARD DATA?!
• 18:50
  AND IT ALL HAS ONE PASSWORD THAT EVERYONE SHARES!' End quote.
• 18:55
  That was the reality.
• 18:56
  Financial data on DOS machines with shared passwords.
• 19:00
  When Walmart was breached in two thousand six, they waited three years to notify anyone.
• 19:06
  Because that's what happens when you build on foundations that assume trust.
• 19:12
  The author's building something called Wirken, designed with actual security principles.
• 19:18
  Each channel gets its own process with its own Ed25519 identity.
• 19:22
  The vault runs separately.
• 19:24
  Shell commands execute in hardened containers with capabilities dropped, read-only root filesystems, no network access.
• 19:33
  Sixteen high-risk command prefixes always prompt for approval.
• 19:37
  Compare that to OpenClaw's approach.
• 19:40
  From the post's analysis: you have to bind Ollama to 0.0.0.0 so the sandboxed agent can reach it.
• 19:47
  You pair through the chat channel because there's no separate identity plane.
• 19:52
  You approve connections at the network namespace boundary because the tool layer has no concept of permissions.
• 20:00
  Every one of those is a compromise.
• 20:03
  A workaround for an architecture that trusts too much, too early.
• 20:07
  The author's conclusion cuts deep: Quote: 'It's just a question of whether we apply what computer history already knows to how we make agents safe for daily use.' End quote.
• 20:20
  We know how to build secure systems.
• 20:22
  Unix got process separation in nineteen seventy-three.
• 20:26
  Capabilities, sandboxing, principle of least privilege—these aren't new ideas.
• 20:32
  But the agent frameworks are ignoring them, choosing convenience over correctness.
• 20:38
  The counterargument is that agents are different.
• 20:41
  They need flexibility.
• 20:43
  They need access.
• 20:44
  Security boundaries would limit their effectiveness.
• 20:48
  But that's what they said about DOS.
• 20:50
  That's what they said about ActiveX.
• 20:53
  That's what they said about every system that prioritized features over safety, right until the breaches started.
• 21:01
  The Wirken approach isn't perfect.
• 21:03
  Running every shell command in a container adds latency.
• 21:08
  Requiring approval for commands breaks automation.
• 21:11
  But at least it's trying to learn from history instead of repeating it.
• 21:16
  Microsoft finally admitted Linux was better in twenty twenty.
• 21:21
  It took them twenty-five years to acknowledge what everyone already knew—that security can't be an afterthought, bolted on after the architecture is set.
• 21:32
  How long until agent platforms learn the same lesson?
• 21:35
  How many breaches, leaked credentials, and destroyed systems before we admit that maybe, just maybe, giving an LLM unrestricted shell access is exactly as bad an idea as it sounds?
• 21:48
  The tools are getting more powerful.
• 21:51
  The benchmarks keep improving.
• 21:53
  But if we build them on DOS-era security models, we're not advancing.
• 21:58
  We're just repeating history with better graphics.
• 22:01
  While everyone debates agent architectures, Elon dropped two words yesterday that matter more: 'Grok Imagine.'
• 22:15
  Not through some complex plugin system.
• 22:18
  Not through a third-party integration.
• 22:21
  Native generation, directly in the chat.
• 22:23
  It has LaTeX compilation built into Grok Files.
• 22:26
  Custom image and video templates through Grok Imagine.
• 22:30
  Three hundred million sessions monthly on the App Store.
• 22:34
  This isn't AGI.
• 22:35
  It's not even particularly advanced.
• 22:38
  It's just useful.
• 22:39
  Devastatingly, boringly useful.
• 22:41
  Mario Nawfal caught the implications immediately.
• 22:44
  From his tweet: Quote: 'No more "sorry I can't generate files" excuses, this AI is actually useful AF.' End quote.
• 22:52
  That's the bar now—not consciousness, not reasoning, not emergent intelligence.
• 22:58
  Just doing the things people actually need.
• 23:00
  The contrast with the agent discussion is stark.
• 23:04
  While developers debate process isolation and capability models, X is shipping features people will use Monday morning.
• 23:12
  While we argue about whether three hundred parallel agents are too many, Grok is making PowerPoints.
• 23:19
  Michael Malice had an observation about Grok's evolution that cuts deeper than the feature list.
• 23:25
  Quote: 'We are at a civilizational tipping point.
• 23:29
  This is how I felt when I first got on the internet.
• 23:32
  Grok is not only a better conversationalist than the average person and more articulate, it is now also capable of correctly deducing motivations.' End quote.
• 23:43
  He's half right.
• 23:44
  The civilizational shift isn't that AI understands our motivations.
• 23:49
  It's that it does our paperwork.
• 23:51
  Nassim Taleb was having fun with probability puzzles yesterday, pointing out that if you try something with one-in-n probability n times, you don't get certainty—you get about sixty-three percent.
• 24:05
  Someone replied that trying two hundred times gives you two hundred percent chance of success.
• 24:11
  Taleb's response: sardonic agreement that revealed how poorly most people understand statistics.
• 24:18
  But that's the point.
• 24:19
  Most people don't need to understand statistics.
• 24:23
  They need to make a spreadsheet for Monday's meeting.
• 24:26
  They need to turn bullet points into slides.
• 24:29
  They need to generate a report that looks professional enough to send to their boss.
• 24:35
  Grok doing that is worth more than all the agent frameworks combined.
• 24:40
  Robin Hanson had several observations yesterday about human behavior and status.
• 24:45
  One particularly relevant: Quote: 'It seems to me that people tend to identify most strongly with the features of themselves that they think others would find it hardest to emulate.' End quote.
• 24:59
  That explains the resistance to AI tools.
• 25:01
  If an AI can make your PowerPoint, what's special about your PowerPoint skills?
• 25:07
  If Grok can write your report, what's unique about your business writing?
• 25:12
  The tools that ship successfully will be the ones that navigate this ego threat, that make people feel empowered rather than replaced.
• 25:21
  The other tools getting traction follow the same pattern.
• 25:25
  Replit's new mobile app deployment—go from project to App Store in three clicks.
• 25:30
  Not revolutionary.
• 25:32
  Not AGI.
• 25:33
  Just removing friction from something people need to do.
• 25:36
  The McDonald's support bot that someone discovered can be tricked into answering general questions?
• 25:43
  That's not a bug.
• 25:44
  That's product-market fit.
• 25:46
  People will use whatever's free and available, regardless of its intended purpose.
• 25:52
  The lesson from today's timeline is clear.
• 25:55
  The winners won't be the most advanced systems.
• 25:58
  They won't be the ones with the best benchmarks or the most sophisticated architectures.
• 26:04
  They'll be the ones that do boring things slightly better than the current way.
• 26:09
  Grok making spreadsheets.
• 26:11
  Kimi fixing real bugs.
• 26:13
  Replit deploying to phones.
• 26:15
  Not the future we imagined.
• 26:16
  But the future that ships.
• 26:18
  Tomorrow there'll be new benchmarks, new architectures, new debates about agent security.
• 26:24
  But Monday morning, someone's going to use Grok to make a PowerPoint.
• 26:29
  And that's what actually matters.
• 26:31
  Lenar Kess.