Blog

The Fable Ban: How the US Government Removed a Live AI Model from the Market for the First Time

Sunday, June 21, 2026

Hello, this weekly digest works through the most important new videos from around 40 curated AI and Coding YouTube channels — with substance, no surface-level top 5. One complete summary per video, plus a weekly overview of dominant themes. Read at your leisure — or copy a summary into your LLM of choice and dive deeper. Click the link under each summary to watch the original video.

AI & Society / Future of Work

Several videos circle the question of who owns AI intelligence and who gets to control it. Kyle Balmer makes the societal explosive potential explicit: Fable marks the first moment AI top-tier intelligence is reserved exclusively for well-paying users — a new digital class question. Nate Herk analyzes OpenAI’s “Built to Benefit Everyone” plan and Anthropic’s parallel call: both labs demand an external body that can pause frontier development if needed — not because they’d voluntarily slow down, but because competitive pressure is too high to stop alone. Nate B. Jones (AI News & Strategy Daily) and Unsupervised Learning discuss whether Amodei’s 25% risk calculation is illiberal or simply responsible — without consensus, but with the sober agreement that centralized private control would be as dangerous as state control. Wolfgang Hirn (Everlast AI) provides the geopolitical frame: Huawei develops with the alternative chip method “Tau” independent manufacturing down to 1.4 nm, which undermines the central US lever of export restrictions long-term; Europe’s implementation weakness is structural, not cognitive. And Nate B. Jones’ voice-cloning essay continues the trust-erosion thread: the scarce good of the future isn’t content but judgment and accountability.

AI Industry & Strategy

The Fable episode is not isolated from the broader structural shift in the industry. Nate B. Jones analyzes in three building essays the decisive difference between tokens (raw intelligence, commodity) and harness (everything that transforms intelligence into productive work — context management, evaluations, routing, workflows). His core argument: whoever controls the harness controls the value; the IPOs of OpenAI and Anthropic are the first public test of this thesis. David Shapiro adds that merely selling tokens isn’t a sustainable base — the value lies in outputs and tools, a picture Satya Nadella drew similarly in a widely discussed article. Jones answers the question “AI bubble or not?” nuancedly: demand and buildup are real (OpenAI grew from $2B to over $20B annualized revenue), but the market is just beginning to sort between genuine workflow value and demo value. Nvidia’s datacenter revenue ($193.7B fiscal 2026) is physical evidence, not speculation. In parallel, TheAIGRID warns that cheap $20 flatrates are a dying model: OpenAI already loses money on the $200-per-month plan, GitHub Copilot switches to token-based billing, and public pressure from IPO investors is likely to fundamentally shift pricing logic in 2026.

Prompting & AI Literacy

Ben AIs DLOP-Skill (De-Slop-Output-Checker) operates in two layers: first universal AI-slop patterns (dashes, contradictions, fact-checks), then company-specific criteria (tone, brand identity, strategy). Three independent sub-agents rate, a DLOP log records patterns for company-wide analysis. NeuralNine introduced the Claude Code skill “Ponytail,” which trims agents to pithy, minimalist outputs — particularly useful when learning new frameworks like LangGraph, where verbose best-practice explanations are counterproductive. Nate Herk’s agent-loop explanation clarifies the basic structure (trigger, action, stop condition) and three architecture types: solo loop, maker-checker, and manager-with-helpers — with the practical tip that loops with overly open criteria run endlessly and his typically run 30 minutes to a few hours.

PKM & Knowledge Management

Niklas Steenfatt reported on Odysseus, PewDiePie’s surprisingly viral open-source project (65,000 GitHub stars): a self-hosted chat interface with document upload, calendar, image editing and email integration, run via Ollama Cloud rather than local GPU — a pragmatic middle ground between full data sovereignty and usability. The point: it’s not the technology that’s the statement, but that a creator with 100 million subscribers positions decentralized AI as a counterdesign to Google and OpenAI.

AI Business, Marketing & Freelancing

Stefan Hoffmann’s hands-on report (Everlast AI) is among the more concrete this week: 200 inactive customers reactivated via outbound phone agent, 5% return, two apartment rentals in Mallorca. According to him, the right system prompt and honest pre-filtering of pointless use cases were decisive for success. AI with Arnie demonstrated how to generate premium marketing websites from a master prompt using Claude (or Cursor/Hermes), the Hixfield CLI for image and video generation, and free hosting via GitHub/Vercel Premium — formerly a €10,000 service, now about €47 monthly for roughly eight complete sites with videos. Nate Herk’s six-skills essay targets employees: the most important advice isn’t career change but making your own expertise more efficient with AI — like Excel for accountants — and becoming “the AI person in the room” that way.

AI Video & Content Creation

Google Flow Tools enables building your own AI creative tools in natural language without code, according to TheAIGRID — existing tools (sketch-to-image, depth-warp 4D video effects) can be remixed, custom tools defined via dropdown and shared by link. NotebookLM receives major agentic upgrades, WorldofAI reports: Gemini 3.5 Flash as base, Secure Cloud Computer with over 100 software capabilities, structured exports as PDF/Word/Excel/PowerPoint and an agentic research feature that independently discovers web sources and integrates them into the notebook with permission — initially for Google AI Ultra subscribers. Nate B. Jones (AI News & Strategy Daily) demonstrated a cloned voice clone of his own voice and formulated five levels of a “Creator Trust Stack” from it: disclosure, provenance, control, judgment and accountability — the scarce good isn’t content but who bears responsibility for decisions.

AI Automation & Workflows

n8n showed a cybersecurity incident response workflow combining three parallel strategies: vector search in historical incidents, playbook consultation and external threat intelligence. MITRE ATT&CK mappings, IoCs in JSON format and prioritized next steps are synthesized — some automatable, some for manual approval. The context is serious: Anthropic’s Mythic model found a 27-year-old zero-day in OpenBSD according to the video, requiring automated defense at parity. Dave Ebbelaar presented his proven 2026 stack: Python + FastAPI + Celery (backend), PostgreSQL via Supabase (data), React + Vite + Shadcn UI (frontend), direct LLM APIs (AI), Docker + Railway or Hetzner VPS (infrastructure) — arguing these established layers are more stable than short-lived individual tools. WorldofAI demonstrated Base 44 Super Agents as a no-code alternative: pre-configured integrations for Gmail, Slack, Stripe and 100+ other services, parallel specialized agents with chained outputs.

Personal AI OS & Agent Frameworks

Nate B. Jones’ Open-Skills-Framework addresses the “procedural debt” problem: 31 reusable markdown skills across seven categories plus seven runbooks, portable between Claude Code, Cursor and Codex, with explicit verification steps instead of vague completion notices. A “session-to-skill extractor” transforms recurring patterns from agent sessions into skill candidates — the same compounding principle as his Open-Brain concept, but at the procedural level. Nate Herk’s five-level second-brain model ranges from simple keyword routing via `claude.mmd` (level 1) through semantic search with vector databases like Supabase or Pine Cone (level 3) to knowledge graphs with LightRAG (level 4) and continuously self-updating systems like GBrain (level 5) — with the practical recommendation to upgrade only when the current system causes real pain. AgentSpan was demonstrated by Tech With Tim as a production framework for three agent types: conversational with memory, RAG-based with human-in-the-loop approvals and multi-agent orchestration with sequential, parallel and nested execution strategies.

Software Engineering & Dev Culture

Melvynx’ migration from Next.js to TanStack Start (over 100,000 lines added, 129,000 removed) cut build time from 3:30 to 1:20 minutes and delivered the decisive argument for AI-powered development: TanStack Start is declarative and explicit, follows web standards rather than proprietary abstractions — that’s why AI agents understand it better and generate more consistent code. Leon van Zyl built a playable GTA-inspired prototype with NPCs, vehicles and weapons using Claude Code and the Unreal Engine MCP plugin; the effort was time-intensive but shows where agent-driven game dev for indie teams is headed. Theo (t3.gg) formulated the bigger argument: AI tools are still used too defensively — to do old work faster rather than tackle projects that seemed impossible before. His LakeBed framework (integrated database, auth, deployment, custom runtime) is exactly that: ten apps in eight minutes with Cursor/Composer 2.5, all with Google Sign-in and real-time sync. Fireship told the origin story of Turso alongside, a Rust rewrite of SQLite with true concurrency, async support and native vector search — the real challenge isn’t features but trust that 25 years of SQLite have built.

Coding Agents (non-Claude)

Omnigent (Databricks, open source) establishes itself as a meta-harness over existing coding agents: one setup command suffices, the web UI shows selectable assistants and orchestrators, and two supplied examples — Poly (Claude implements, Codex reviews) and Debbie (two agents debate, synthesis follows) — demonstrate the principle. Cole Medin distinguishes this from “loop engineering,” which he dismisses as a marketing term: without deterministic workflow file, durability via Postgres and explicit cost control, looping gets expensive and uncontrollable — his counter-proposal is called Arkon, also open source, with dashboard via Retool. Leon van Zyl’s 30-day comparison of Claude Code vs. Codex on an N8N-like app showed: Claude wins on design, Codex on project structure, technical questions during planning and cost efficiency (Codex consumed 16% of his $100 plan, Claude 8% of the $250 plan — depending on perspective). Mark Kashef showed how to extract behavior metrics of Fable 5 from saved JSONL session files and inject them as a playbook into other models to approximate Fable’s structured way of working.

Claude Code & Anthropic Tooling

Theo (t3.gg) devoted an entire video to the strengths of Claude Code despite his Fable criticism, so other harnesses can adopt these patterns: skills with script execution on load, `claude.md` imports with max four hops, `claude.local.md` for team-friendly personal overrides, dynamically generated workflows that orchestrate sub-agents, plus fullscreen TUI mode for clean terminal rendering. Separately, he documented loop workflows where Codex spins new threads, automatically reads and addresses PR reviewer comments — four stacked PRs overnight, three million tokens, but financeable with the $200 subscription cap. Nate Herk and Cole Medin discussed in podcast format why planning-first is decisive: the “dumb zone” begins around 250,000 tokens for Opus, validation steps raise first-pass quality from 65 to 92%, and every bug should end up as permanent improvement in `claude.md` or a skill. Julian Ivanov delivered a complete tutorial for a personal AI OS with Claude Code: knowledge base in Obsidian, MCP tool connections, skills as markdown files, remote routines on Hostinger servers, synchronized via GitHub.

Local & Open-Source AI

GLM 5.2 runs locally on a Mac Studio with 256 GB RAM in 2-bit quantization (82% accuracy per Everlast AI); Alex Finn demonstrated this with a fully locally generated 3D ego-shooter via his Hermes agent. Bart Slodyczka combined Gemma 4 (12B, QAT variant via LM Studio) with the Hermes agent on an M4 Mac Mini (16 GB RAM) and controlled the setup via Claude Code in the terminal to automatically answer Zendesk tickets. Everlast AI delivered the most comprehensive overview: five ways to local AI (Ollama, LM Studio, Llama.cpp, inference APIs via Together AI/Nebius, embedded in Apple Intelligence/Gemini Nano), the clear message that open-source models now trail frontier models by only four months, and a hybrid plea: sensitive data locally, top performance for complex coding in the cloud. Nick Saraev showed how to use GLM 5.2 via OpenRouter with Claude Code as harness — “engine swap” — and concludes the model currently has more “flavor” than Opus 4.8.

Model Releases & Benchmarks

Alongside the Fable storm, it was a handful of model releases and leaks that shaped the week. GLM 5.2 from ZAI dominated open-source discussion: MIT-licensed, 1 million token context, per Everlast AI on the design arena tied with Claude Haiku 5 and GPT 5.6 Pro, per WorldofAI positioned ahead of Opus 4.8 in frontend development. Kimi K2.7 Code (Moonshot AI, ~1 billion parameters, MoE) improves command following by 30% versus K2.6 and reduces overthinking, but lags with 262K context against expectations — Alejandro AO’s benchmarks show Kimi as implementer with expensive planner (GPT-5.5 or Opus) delivers the best cost-quality ratio. OpenAI meanwhile prepared GPT-5.6 per multiple leaks (WorldofAI) with 960-reasoning budget, up to 1.5M token context and Playwright integration for late June. TheAIGRID presented SubQ, a language model with fully sub-quadratic sparse attention: at 1M tokens 56x faster than Flash Attention 2, 12M-token context window, 100% needle-in-the-haystack accuracy to 2M tokens — though with pending independent verification and known weaknesses on short everyday prompts.

Briefly Noted

Apple Intelligence 2026 (TheAIGRID): Writing Tools, Visual Intelligence, live translation in FaceTime and Siri/ChatGPT integration in practical overview. Lemma (Tech With Tim): Multi-agent research platform that generates a complete academic paper from a question — a SARS task on uncertainty prompting ran two days and reduced hallucinations by 18–51%. DataCamp AI-Engineering Roadmap (Tech With Tim): Nine courses, 26 hours, OpenAI API through LangChain, solid entry point for Python developers. Intel CEO Lip Bu Tan (No Priors): Three-stage turnaround strategy (crawl/walk/run), foundry cooperation with Elon Musk’s Terra Fab, focus on agentic AI and inference CPUs. Melvynx on API spending: $4,324 in one week, 341 chess games as response to hour-long agent wait times — an honest record of cognitive atrophy through automation. NeuralNine Matplotlib PDF Reports: Professional multi-page reports with `PDFPages` and `GridSpec` in a few lines of Python. Webhooks vs. Polling (NeuralNine): Beginner tutorial with Flask demo, no AI tool.

AI Explained (1 new video)

• Claude Fable Blocked – 11 Quiet Details on What’s Next
  14.6.2026, 14:52:27

  # Summary

  Claude Fable 5 was blocked within 36 hours by order of the US government for all users – including Anthropic’s own foreign employees. The block followed a report about jailbreaks in the model and calls from Amazon CEO Andy Jassy and other tech leaders to the US government. National Cyber Director Shan Kangross convened a meeting with White House officials who decided on export restrictions.

  The video creator presents eleven contextualizing facts to illuminate the motivations and circumstances. Some suggest a genuine, if overly reactive, security concern: the cyber director was under pressure to act faster; a trusted partner had reported a jailbreak vulnerability. Other details appear far more cynical: Anthropic emphasized that the discovered jailbreaks are simple and equally possible with other models like OpenAI’s GPT-4.5. According to the Mythos system card, Mythos and Fable are actually orders of magnitude more robust against prompt injection than GPT or Gemini. An independent cybersecurity firm called the government response an overreaction, since it involved helping with security patches – exactly what defenders would do.

  A second critical point: The government claimed Anthropic CEO Dario Amodei was on a wellness retreat – Anthropic and a present journalist disputed this, hinting at orchestrated reputational damage. Additionally: In June, the White House had emphasized that comprehensive model monitoring would have chilling effects and violate free speech – a 180-degree turn from current policy. The government gave Anthropic only 90 minutes to shut down without details about the actual threat. Another cynical context: Pete Hegseth (Secretary of War) tweeted aggressively against Anthropic; Trump spoke of equity stakes for OpenAI and XAI, but not Anthropic; a PAC funded by Greg Brockman massively supported Trump – Anthropic did not. Sam Altman of OpenAI denied lobbying activities.

  The video creator emphasizes: jailbreaking remains an unsolved problem – no one has yet created a model resistant to all jailbreaks. Amodei therefore argued that the government should distinguish between narrow, specific jailbreaks and universal workarounds. The irony lies in the fact that Anthropic originally said it only wanted to build frontier models for safety reasons – now safety itself is being criticized.

  Finally, the video creator speculates that the most likely scenario is: The Trump administration hopes for swift remediation by Anthropic, after which the export restriction is lifted – possibly by Monday. If not, it would have massive consequences (ID checks for users, layoffs of foreign employees, market impact).

  **Format:** News update / deep dive; explicitly covers: Claude/Anthropic (Fable 5, Mythos), OpenAI (GPT-4.5), Open Router, lmconsul.ai.

AI Foundations

No new videos in this period.

AI with Arnie (1 new video)

• Claude Has Changed Web Design Forever
  17.6.2026, 18:21:56

  # Summary: AI-powered premium websites from a single prompt

  The creator demonstrates a system for generating high-quality marketing websites completely automated from a single prompt. Core components are a coding agent (Claude, Cursor, Hermes, or OpenCoder) and the Hixfield CLI for generating images and videos.

  **System Overview:**
  The process consists of three steps: (1) Install Hixfield CLI, (2) connect with Hixfield, (3) install the optional skill. After that, a detailed master prompt is used that combines six different prompt levels – from concept through scroll animations, lighting, copywriting to final verification. The agent runs in a loop until the website is error-free and has been tested across different viewports (desktop, tablet, mobile).

  **Practical Examples:**
  Finished websites are shown for headphones (with sound unfolding animation), watches (with scroll rotation), cars, supplements, and a surprisingly creative example with a watering can for the topic of “drip-free moving service”. The agent interprets creatively what could be marketed with the product. A video of a record player was spontaneously generated as a surprise – all with consistent scroll animations, perfect copywriting, and stylistically appropriate images/videos.

  **Technical Details:**
  When using it, it’s recommended to enable autopilot mode and use at least “High” level for Claude performance. Hixfield automatically selects the right model (e.g., Kling for videos, Nano Banana for images) without manual prompting required. Costs at Hixfield: from €19 monthly (Starter), approximately €47 is enough for about 8 complete websites with videos.

  **Hosting:**
  Finished websites can be easily hosted for free via GitHub and Vercel – push to GitHub with CLI, then import and deploy in Vercel.

  **Context:**
  This used to be a premium service for €10,000+. Now achievable in the low double-digit euro range. The creator sees business potential in this, as many agencies aren’t yet aware of this approach. The detailed prompt is shared for free in a community.

  Explicitly covered: Claude / Hixfield CLI / Cursor / Codex / Hermes Agent / GitHub CLI / Vercel; Format: Tutorial/Demo with deep insight into the practical workflow.

AI News & Strategy Daily | Nate B Jones (5 new videos)

• You Can’t Tell If I’m Real Anymore. And That’s Now YouTube’s Problem Too.
  20.6.2026, 15:00:22

  # Summary: Voice Cloning, AI in Creative Industries and the Trust Problem

  The author first demonstrates a synthetic clone of his own voice, then discusses why the real danger isn’t perfect AI, but “good enough” AI in a world full of distractions. Voice cloning already works today: with sufficiently clean audio data, you can create convincing voice clones – in normal listening situations or when people are only half-watching, it works right now. Full human presence cloning remains uncanny: lips, eye movements, facial expressions and hand movements look 90% right, but the missing 10% creates discomfort.

  The core problem isn’t the technology itself, but the trust deficit in an environment where people consume content casually – not like detectives under forensic conditions. The central question shouldn’t be “Was AI used?” (too primitive, too binary), but where in the production chain AI operated and where human judgment took control.

  The author proposes a five-level “Creator Trust Stack”:
  1. **Disclosure** – What was synthetic? (Voice, face, script, editing)
  2. **Provenance** – Where did training materials come from? With consent or scraped?
  3. **Control** – Did the cloned person control how their identity was used?
  4. **Judgment** – Who formulated the arguments and decided what was said?
  5. **Accountability** – Who bears responsibility if the content is false, manipulative or harmful?

  Recommendations for creators: (1) Clearly label synthetic media, not hidden in video descriptions. (2) Don’t clone voices and faces without consent. (3) Use AI for leverage, not irresponsibility. (4) Make your audience more media literate – show, explain, differentiate. (5) Companies should set guidelines before scandals, not after.

  The author warns against confusion: people are inconsistent, blink strangely, sometimes wear the same clothing in multiple videos (because they batch-record) – that’s not AI. Confusion will increase. The truly scarce resource of the future isn’t content or polish, but judgment, taste and accountability – assurance that a real person makes decisions and stands by them.

  Finally: The author used a cloned version of his own voice for this video demo, demonstrating that authentic-sounding voice clones are already possible today. — Opinion/Reflection; doesn’t address specific AI tools or vendors, but discusses voice cloning and AI governance for creators in general.

• Your AI Skills Are Trapped | Here’s How to Own Them
  19.6.2026, 14:00:08

  # Summary: Open Skills – An Operating System for Agent Work

  The video addresses a second problem that emerges once agents have access to context (the so-called “Open Brain” problem): agents may know *what* you know, but not *how* you work. The speaker identifies this as “procedural debt” – a procedural problem manifesting in four symptoms: prompt bloat (too many rules in massive system prompts), reexplanation tax (you must re-explain your workflow in every new session), instruction fragmentation (rules scatter across multiple tools and drift apart) and weak verification (agents complete tasks, but human review remains necessary).

  Open Skills is a public repository of reusable agent procedures (currently 31 skills in seven categories plus seven runbooks). A skill is a portable procedure – not just a prompt formulation, but a markdown-based format that defines: when to use the skill, what the job is, what boundaries apply, what output looks like and how to verify results. This allows procedures to be carried between different agents (Cursor, Claude Code, etc.) rather than maintaining them separately in each tool.

  The speaker distinguishes skills (primitives – individual procedures) from runbooks (composition – workflows from multiple skills). A runbook might be: voice memo → transcription → idea processing → personal voice → HTML page → publishing. Each skill carries part of the contract; runbooks connect them.

  Scope is also central: personal procedures (your voice, your publishing standards) belong to you; project procedures (secure commands, repo rules) belong to the project. This prevents everything from becoming a giant mash of mixed preferences. Another core feature is verification – the skill defines upfront what proof must be provided (“here’s the browser screenshot”, “here’s the URL that was checked”) rather than vaguely hoping for completion.

  A flywheel mechanism (“Session-to-Skill Extractor”) transforms recurring patterns from agent sessions into skill candidates, rather than leaving them lost in chat history – it’s the same compounding principle as Open Brain, but at the procedure level.

  Open Skills doesn’t exist in isolation; it’s meant to work together with Open Brain: Brain gives the agent context (project, decisions, prior work); Skills give it procedures (how to research, write, build, test, publish). The speaker emphasizes: portability is the differentiator – you don’t lock your workflows and procedures into any particular vendor, tool or model.

  The decision rule: one-time prompting is fine; but if you repeatedly explain the same procedures and juggle multiple tools, then you need skills you can inspect, improve, compose and take with you.

  **Explicitly mentioned:** Claude Code, Cursor, Codeex; Open Brain as a predecessor concept — Format: Opinion/Reflection with product announcement.

• Your $20 AI Plan Costs Them Thousands. That’s Not The Bubble.
  15.6.2026, 14:00:28

  # Summary: Is AI a Bubble or Not?

  The creator argues that the frequently asked question “Is AI a bubble?” is too simplistic and represents a misunderstanding of the market. Instead of asking this binary question, one should differentiate between genuine building and real demand on one hand, and speculative exaggeration on the other.

  **The demand signals are real:** OpenAI grew from $2 billion annualized revenue in 2023 to over $20 billion in 2025, with Anthropic growing even faster behind it. This comes 40% from enterprise customers, not consumers tinkering with a chatbot – companies are spending serious budgets because they’re speeding up concrete workflows. Nvidia’s datacenter revenue ($193.7 billion fiscal 2026) shows physical demand: CEOs and boards don’t buy this infrastructure for random experiments.

  **The crucial difference: Inference over training.** Training is episodic and expensive; inference runs every time someone uses the model. Agents (not just chat) produce millions and billions of tokens per run – through loops, tool calls, verifications. This explains why capex numbers become so serious: Microsoft, Google, Amazon and Meta are essentially building factories for inference, not just software.

  **The real sorting problem:** Google, Microsoft, Amazon and Meta collectively spend ~$700 billion on AI infrastructure, but must prove these investments pay off. Some companies will build too much, some in the wrong places, some startup costs are inflated. But that doesn’t mean the underlying demand is imaginary.

  The decisive test in 2026: **Are expensive tokens being spent on valuable work?** A coding agent that saves teams weeks justifies expensive inference. A customer service system with real ticketing does too. A random enterprise chatbot with a stale knowledge base doesn’t. Enterprise ROI data is messy because most companies are bad at process change – that’s not proof of a bubble, but proof of uneven adoption.

  **The better model:** not bubble vs. no bubble, but **building vs. payback.** The building is real, the demand is real, the bottlenecks are real. The open question is: who gets paid, when, at what margin and on which workloads? The stock decline shows investors now asking harder questions (as they should), not that the building is fraud.

  The first phase was narrative (everyone buys obvious names), the second phase is correction (market realizes it’s more expensive, slower, messier). The third will be sorting: genuine AI revenue vs. AI-speak in pitches, real bottlenecks vs. commodity exposure, workflow value vs. demo value, companies that self-fund vs. those needing outside financing.

  Railroads were real and the building enormously successful for the economy – yet many railroad investors were still destroyed. Fiber was real, many telecom investors were still destroyed. That doesn’t mean the future is fake, but that market corrections don’t invalidate the entire narrative.

  Real questions for investors: Is this paid usage or engagement? Production workloads or pilots from press releases? Does it improve a workflow with clear economics or create more work for people? Is the company buying capacity because customers are waiting, or because the board wants an AI strategy?

  **Conclusion:** AI is a real, transformative foundation. Parts of it are speculatively inflated. The market is only beginning to distinguish between genuine value and hype, and that’s healthy. The creator notes this is a 10-20 year marathon, not a sprint, and investors should apply higher analytical standards.

  —

  **Format & Focus:** Opinion/Reflection, deep and thoughtful analysis without mentioning specific AI tools (rather meta-discussion about the AI industry).

• OpenAI Just Filed For Its IPO. The Real Story Isn’t The Trillion Dollars.
  14.6.2026, 17:00:39

  # Summary: OpenAI and Anthropic – The IPO Thesis Beyond Valuation

  The central question with upcoming IPOs from OpenAI and Anthropic isn’t whether they’re worth a trillion dollars, but what public investors should actually believe: that both companies can do two things simultaneously – make intelligence so cheap it can be deployed at scale, and build proprietary systems so fast that companies prefer renting the whole system to building themselves. The thesis: cheap tokens plus proprietary harnesses equal a trillion dollars.

  The core argument lies in distinguishing between tokens (raw intelligence purchased by consumption) and harnesses (everything that turns raw intelligence into productive work – files, tools, permissions, storage, evaluations, routing between cheap and expensive models, workflows). Examples of harnesses are Codeex and Claude Code. The real business sits not in pure intelligence but in the layer above it.

  A common criticism of $200 plans is that users supposedly get $8,000 to $14,000 in value – allegedly a financial disaster. But API prices aren’t cost but retail price with profit margin. If internal costs are significantly below sticker price and the labs constantly improve inference efficiency, caching, batching, distillation and chip utilization, the $200 plan could be rational. The strategy might be: supply users with enormous amounts of cheap intelligence while costs fall below it. This means the labs believe inference costs will continuously decline.

  Critical is the strategic shift: OpenAI and Anthropic don’t want to be pure API companies forever, selling raw intelligence. Raw intelligence becomes comparable, distributed and commodity-priced. Value shifts to what’s built around intelligence – the harness. Codeex demonstrates the principle: it impresses not just because the model is intelligent, but because it sits in a harness that understands the job – seeing repos, editing files, running tests, inspecting errors, tracking changes, using the computer, navigating knowledge work. The product isn’t “a model that can code” but “a system that can participate in general knowledge work”.

  The core problem for the labs is context: OpenAI and Anthropic don’t know how a company works, where real documents live, which Salesforce fields matter, what approval steps are real, who can authorize exceptions, which table is the true source of truth. Enterprises have private context – a massive informational advantage. The battle is over who transforms their advantage into better harnesses faster. Forward Deployed Engineering is the labs’ approach to overcoming this context problem: the labs send people into the company, map workflows, connect tools, learn real use cases, adapt products. They transform generic harnesses into enterprise-specific ones. If it works, the customer doesn’t just rent tokens – they reorganize work around the lab systems. That’s stickier and more valuable.

  For enterprises, the strategic question isn’t “OpenAI or Anthropic?” but “rent the harness or build it?” Building a harness doesn’t mean training a frontier model (almost no company should do that), but owning the layer that decides which model for which task – context, evaluations, permissions, workflow definitions, review processes, routing logic. If you own the harness, labs are competing suppliers. If the lab owns the harness, the lab becomes the operating layer. That’s the fork in the road.

  Recursive self-improvement has a more practical aspect here: better models help labs improve their own products faster – improve code faster, improve evals faster, tune routing faster, optimize inference faster, compress models faster, make harnesses faster. That’s an iteration advantage. The bullish scenario: OpenAI and Anthropic manage token costs, compete with open-source on scale and efficiency, improve own products faster than customers, build harnesses so well companies don’t build themselves. That’s realistic – most companies are slow, don’t understand their own workflows, can’t define what “done” means, don’t build routing logic, neglect eval maintenance. They buy the product that works.

  The bearish scenario: companies learn to build their own harnesses; labs become intelligence suppliers rather than work-layer owners. They still make lots of money, but valuation shifts – the workflow layer is captured by the enterprise, the lab sits on token margin. With falling token prices, that’s a much less dominant position.

  What to watch in the S-1: not revenue, user growth or valuation, but whether power users become cheaper to serve, whether gross margin rises with usage growth, whether enterprise customers buy scalable software or custom labor, whether real workflows emerge in the product, whether Forward Deployed Engineering bridges to better products or stays permanently necessary.

  For non-investors, it’s practical: build your own harness or let someone else own it? An AI strategy doesn’t mean prompting (that’s thin), but harness-building – clearly define recurring jobs, give the model right context, connect files and tools, check output, improve system. That’s the leverage. Cheap intelligence comes anyway. The question is who knows how to use it. OpenAI and Anthropic’s IPOs are the first public test of a thesis: can the labs make tokens cheap enough and build harnesses fast enough to own the work layer? Or do companies build their own harnesses with cheaper tokens and keep more value? Cheap intelligence enables the token economy. The harness is the engine that makes it valuable. Whoever controls the harness has the dominant position in the token economy of the future.

  —

  **Format:** Opinion/Reflection; explicitly mentions: OpenAI, Anthropic, Codeex, Claude Code, DeepSeek (briefly as model competition).

• Don’t build more AI agents until you watch this
  17.6.2026, 14:00:31

  # Summary: Vercel Cut Agent Tools by 80% – and They Got Better

  The central paradox: Vercel improved its sales agent not by adding features but by cutting them. The common assumption – more tools, more context, more autonomy make agents better – is refuted here.

  Vercel studied a top salesperson to replicate their real workflow: classifying incoming messages (leads vs. spam vs. support), lead qualification, company research, response drafting and routing support requests. The agent reproduced these workflows but stayed under human control – the goal wasn’t pure automation but accelerating repeatable processes.

  The deeper lesson: the agent got better not because tools were added but because they were removed. This refutes typical development practice where you iteratively accumulate tools, integrations and memory. The real topic in 2026 isn’t “can you build agents” but “how do you keep the infrastructure around an agent healthy”.

  **The four core principles of agent maintenance:**

  1. **Models are unstable upward**: Better models need different “harnesses” (workbenches). A rule protecting a weak agent can block a better one. A tool compensating for missing capabilities can confuse an improved model. That’s a new maintenance problem – systems can break not just from degradation but from improvement.

  2. **Agents inherit system dirt**: Stale wikis, changed processes, drifting prompts – in normal software these are inconveniences. In agents they’re dangerous because agents work proactively, draft recommendations and create tasks. They don’t notice the source is wrong; they just keep working.

  3. **Big AI companies build harnesses deliberately**: OpenAI and Anthropic invest massively in infrastructure *around* models – terminal, browser, files, memory, permissions, sandboxing, logs. It’s more than chat with a better brain; it’s a carefully maintained workbench. Competitive advantage doesn’t come just from model power but from better models helping build and test better harnesses – a flywheel.

  4. **Define your harness**: Anyone using an agent must ask: what’s my setup? That might be project folders, memory, prompts, source docs, approval steps, file permissions. The question isn’t technically abstract but practical: how does the agent stay connected to my real files? What should it read first? What ignore? When ask before changing things? That changes as models improve.

  **Five maintenance checks for seriously-used agents:**

  – **What does the agent consume?** Are sources current? Has the workflow shifted?
  – **What’s its reach?** Read-only, or can it create, update, post, spend money?
  – **Is the job definition right?** Still a summary agent or did planning/routing quietly shift?
  – **Is there evidence?** Not “customers are frustrated” but: linked tickets, customer quotes with sources, trackable trails for people.
  – **Does the agent deliver real value?** Is output read? Does it change work? Save time after review? Or just create new work piles?

  **The central thought (drawing on Stewart Brand’s *Maintenance of Everything*):** Agents are like sailboats, not apps. They live in motion – the model changes inside, the world changes outside. A sailboat isn’t maintained because of poor construction but because it lives. Same with agents: they break in two directions – external drift and internal model improvement. Simplicity and deliberate reduction are keys to maintenance. The harness question “what should I delete later?” is more mature than “what else can I add?”

  **Claude mentioned, OpenAI/Codex mentioned (plus Anthropic/Claude Code); Opinion/Reflection with deep-dive elements.**

Alejandro AO (1 new video)

• Kimi K2.7 + Opus 4.8 = BEST Coding Duo??
  15.6.2026, 15:40:30

  **Summary:**

  The video demonstrates a practical cost optimization strategy for AI-powered software development: instead of using an expensive model (like Claude Opus or GPT-5.5) for all phases of a coding task, the workflow is split into two parts. The first covers issue understanding, code-base exploration, and planning; the second handles actual implementation and code review.

  The creator tests this with the newly released Kimi K2.7, an open-source model specialized in coding that is significantly cheaper than GPT-5.5 and Opus (input: $0.95 vs. $30 per million tokens) while achieving similar coding benchmarks. In a concrete experiment on a CPython GitHub issue (class-scope comprehension with lambda raises SystemError), each model is tested as both a planner and implementer. Both judges (GPT-5.5 and Opus 4.8) evaluate the solutions; the creator measures costs and quality.

  The results show: all tested combinations produced mergeable PRs with only about 1-point variation on a 10-point scale. Kimi combinations are approximately seven times cheaper than pure GPT/Opus setups. The clear trend is that GPT-5.5 or Opus 4.8 as planner and Kimi K2.7 as implementer offers the best cost-to-quality ratio – saving expensive tokens from premium models without sacrificing quality. Kimi K2.7 is less verbose than K2.6, making it even more cost-effective despite a minimal price increase.

  The creator also provides the “DuoBench” tool, which allows users to run such benchmarks on their own GitHub issues (installable via `npx skills add`, uses Pi configuration).

  **Conclusion:** Kimi K2.7, Claude Opus, GPT-5.5, open-source – demo/benchmarking with practical tool release.

Alex Finn (1 new video)

• How to get unlimited AI for free (GLM 5.2 local)
  19.6.2026, 18:15:48

  # Summary: GLM 5.2 locally on Mac Studio

  The video covers the Unsloth version of GLM 5.2, an open-weights model that runs locally on your own hardware and, according to the creator, is comparable to Claude Opus 4.8.

  **Demonstration & Capabilities:** The creator shows a 3D ego-shooter game entirely generated by GLM 5.2 via a Hermes agent running completely locally – including self-improvement, where the model tested the game itself and optimized its abilities.

  **Hardware Requirements:** The 2-bit quantization requires about 250 GB of storage (Mac Studio 256 GB minimum, 512 GB recommended). For smaller hardware, he recommends alternatives like Google’s Gemma 4 or Nvidia’s NemoTron; for better hardware, Qwen 3.6 27B or larger.

  **Upsides of local models:** Free & unlimited, completely private (no data sent to the cloud), enables 24/7 background agent work (e.g., code security reviews). When using GLM 5.2 via cloud, pricing is cheaper than ChatGPT/Claude.

  **Downsides:** Significantly slower than cloud models, smaller context window. For fast, interactive tasks, cloud models (Opus, ChatGPT) remain worthwhile; local models are suited for passive, non-time-critical background tasks.

  **Setup Process:** The creator simply uses his Hermes agent with a link to the Unsloth announcement – the agent downloads the model, sets up a server, and configures a new Hermes agent with it without manual steps.

  **Future Vision:** The creator predicts that within 12 months, everyone will have a highly intelligent local model running on an affordable Mac mini, working 24/7 privately as a personal agent in the background.

  **Preparation:** Experiment with available hardware, use Hermes/OpenClaw, continuously track new models, and deploy them quickly.

  **Explicit Tools/Models:** GLM 5.2 (Unsloth quantization), Hermes Agent, OpenClaw, Claude Opus 4.8, ChatGPT 5.5, Gemma 4, NemoTron, Qwen 3.6 27B, Codex — demo & guide with strong focus on local AI infrastructure.

Bart Slodyczka (1 new video)

• Gemma 4 12B + Hermes Agent: Build Your Own AI Assistant
  15.6.2026, 12:00:28

  # Summary

  The creator installs Hermes Agent on a Mac Mini with M4 chip and 16 GB RAM running Gemma 4 to build a local AI assistant. He uses Claude Code (Claude Desktop App with Opus 4.8) as the central control unit to automate all setup processes—from reading system information to Hermes installation and configuration.

  **Key setup steps:**
  – First, ensure the Mac stays powered on (otherwise the agent will sleep when needed)
  – Claude installs and configures Hermes Agent without external APIs or paid services
  – In LM Studio, the Gemma model (QAT variant with 6.66 GB) is loaded and the context length (approximately 67,000 tokens) and Flash-Attention settings are optimized to balance memory between model, operating system, and agent functions
  – Gemma is configured as the default model in Hermes and tested—the first response takes ~2–3 minutes (demonstrating the M4’s computational load)

  **Practical use case—Zendesk integration:**
  Claude generates a Webhook setup for Zendesk that automatically forwards incoming support tickets to Hermes. The agent then responds autonomously to tickets (based on a generated FAQ for a computer parts company scenario). In demo tests, the system used almost all 16 GB RAM and processed two parallel tickets efficiently, generating realistic responses within minutes.

  **Core insight:** Claude Code operates directly in the terminal and can therefore read device hardware, change settings, install and test command-line tools—without manual steps. The creator highlights this as the key takeaway: rather than manual configuration, it’s far more efficient to have a powerful AI model perform the automation.

  **Explicitly mentioned:** Claude Code (Claude Desktop App), Gemma 4, Hermes Agent, LM Studio, LM Link, Zendesk, Tail Scale, Docker—tutorial with practical demonstration.

Ben AI (1 new video)

• How to De-Slop Every AI Output Forever (With 1 Skill)
  16.6.2026, 08:56:30

  **Summary**

  The video introduces a new Skill that performs quality control for AI outputs – essentially a “spell-check against AI-slop”. The creator first describes the problem: while AI tools increase individual productivity, their widespread adoption in organizations often leads to low-quality content (marketing posts, emails, internal documents) because each employee has different quality standards and AI doesn’t enforce these standards.

  The DLOP Skill works in two layers: first, it checks for universal AI-slop patterns (unnatural dashes, typical AI writing styles, contradictions, fact-checking), then runs an organization-specific check (fit with tone, brand identity, company strategy, facts). The Skill first identifies the output type (marketing post, customer service reply, etc.), then deploys three Sub-agents to evaluate impartially against the criteria, and delivers one of three verdicts: “Go to go”, “Go to go, but some fixes needed”, or “Not ready”. For each point, it provides improvement suggestions with source citations.

  Additionally, a DLOP Log records every run to identify patterns in company-wide AI output issues. The Skill can be integrated as the final step in other Skills and works with customized reference files for brand voice, fact-check lists, and visual guidelines. The creator recommends using it before every publication. The free Skill is available for download with blanks for personalization; there’s also a “DLOP Builder Skill” in his AI Accelerator Community for step-by-step customization.

  —

  **Conclusion:** Claude and the DLOP Skill are discussed; format is a mix of demo/tutorial and opinion with use-case examples.

Brian Casel

No new videos in this period.

Coding with Lewis

No new videos in this period.

Cole Medin (2 new videos)

• Omnigent: The New Meta-Harness for EVERY Coding Agent – Claude Code, Codex, Pi, More
  6/15/2026, 2:42:51 PM

  **Summary: Omni Agent – Meta-Harness for AI-Coding Workflows**

  Omni Agent is a newly released open-source tool from Databricks that functions as a meta-harness, orchestrating multiple AI-coding assistants. A meta-harness is a layer above individual coding assistants that enables you to combine longer workflows with different models — for example, Claude Code for implementation and Codeex for code reviews. The key insight: the harness (system prompt, tools, skills, workflows, policies) is now just as important as the underlying model itself, especially given model limitations.

  Omni Agent installs in minutes via a single setup command and requires no new authentication since it leverages existing CLI credentials. The web UI presents an agent-first interface with chat session, selectable coding assistants, and orchestrator agents. The tool comes with two example orchestrators: **Poly** (orchestrates workflows between Claude and Codeex, e.g., implementation by one agent, review by another) and **Debbie** (lets two agents argue about a topic and synthesizes their perspectives).

  Custom agents and orchestrators are simple to build: each consists of configuration, skills, and callable agents. The configuration includes executor (which model), system prompt, sandboxing options (unsandboxed, Docker, E2B), and guardrails. Example: a custom agent with a guard rail that allows Claude Code autonomous commands but blocks force pushes to Git and requests approval. Such policies are Python code and can also be generated by AI assistants.

  Omni Agent runs locally on your machine but can also be deployed as a server. A multi-device feature enables live collaboration: the same session can be worked on simultaneously across desktop and smartphone, either over the same Wi-Fi network or globally via a hosted instance.

  The video’s core argument: top engineers no longer use a single model or tool for their workflows, but orchestrate multiple ones to leverage their different strengths, achieve token optimization, and avoid bias (e.g., by having the code reviewer be a different agent than the implementer). Omni Agent makes this meta-harness structure production-ready and accessible.

  **Explicitly discussed tools:** Omni Agent (Databricks, open-source), Claude Code, Codeex, Pi, Ollama, Docker, E2B, Git — demo with opinion/reflection on harness engineering.

• The Creators of Claude Code and OpenClaw don’t Prompt Their Agents Anymore?!
  6/18/2026, 12:00:08 AM

  # Summary: Loop Engineering for AI-Coding

  The video critiques the hyped term “loop engineering” and shows that while the underlying idea is interesting, it’s problematic in practice. The core concept: you configure loops where AI-coding assistants independently work through tasks in iterations, rather than being manually prompted.

  **The three core concepts (basics):**
  – `/loop`: Recurring checks at fixed intervals (e.g., check new GitHub issues every 5 minutes)
  – `/goal`: Agent works until a condition is met
  – `/routines`: Time-scheduled tasks

  **The three main problems:**
  1. **Quality**: Loop engineering doesn’t deliver the best results — it’s mostly marketing hype. Practically, it’s only useful for POCs.
  2. **Cost**: The orchestrator must constantly make decisions (how many workers? how many loops?), shuttle context back and forth — over a million tokens for a simple application are quickly reached.
  3. **Context bloat**: When looping within a Claude Code session, context grows and overwhelms the model. Multiple separate sessions are needed.

  **The solution — Harness Engineering (via Arkon):**
  The creator uses his tool **Arkon** to orchestrate workflows that control multiple coding-agent sessions in parallel. This makes it:
  – **Deterministic**: The process is defined in a workflow file, not driven by the agent
  – **Cost-optimized**: Each step can use a different model (e.g., smaller models for classification, expensive ones for code implementation)
  – **Reliable**: Durability via external Postgres database (Neon), resumability, human control at critical points
  – **Parallelizable**: Handle multiple GitHub issues simultaneously across isolated work trees

  **Practical example**: A workflow that fixes GitHub issues with four parallel sessions, then starts four more sessions for code reviews — all orchestrated by a Claude Code instance, but not as a bloated loop, rather as distributed, tracked work.

  **Also demonstrated**: A custom-built **dashboard** (open-source) providing observability: store all loops in a Postgres DB as state, the orchestrator reads this state, invokes workers, they update the state. Easy to deploy to the cloud with **Retool** — with permissions, audit trails, and chat-driven changes.

  **Core thesis**: Loop engineering doesn’t deserve its own name; it’s simply orchestrated work with multi-agent workflows. Without a harness architecture (durability, cost management, process determinism), it becomes expensive, unreliable, and uncontrollable.

  —

  *Demo of Arkon + custom dashboard with Postgres/Neon, occasional mention of Claude Code, also references Haiku, Kimmy K 2.7, and Retool for cloud deployment; opinion/reflection with practical demos.*

Dave Ebbelaar (1 new video)

• The Best AI Automation Stack to Learn in 2026
  19.6.2026, 13:28:15

  # Summary

  The video presents a proven tech stack for AI automations consisting of five layers that scales long-term — unlike short-lived single tools.

  **Backend Layer**: Python is the foundation. Additionally, Fast API (for creating API endpoints for webhooks and communication) and Celery (for background workers and job scheduling) are recommended. This combination forms the core for trigger-based and time-driven automations.

  **Database Layer**: PostgreSQL (via Supabase as a hosted wrapper solution) is sufficient and scales even for millions of records. Supabase also provides authentication and an admin dashboard; vectors can also be stored in PostgreSQL.

  **Frontend Layer**: React (JavaScript component library), Vite (build tool and development server), and Shadcn UI (pre-built component library with graphs, login, buttons, chat interfaces, etc.) enable rapid development of internal tools and dashboards. Shadcn code is imported into the project, not as an external dependency, which allows AI coding agents to work with it.

  **AI Layer**: Direct API access to language models (OpenAI, Anthropic) or via enterprise providers (AWS, Azure, Google Cloud) with centralized billing and better data protection controls. The effort for this layer is minimal — usually just a simple API call.

  **Infrastructure Layer**: Docker for containerization, then deployment either on beginner-friendly platforms like Railway or on VPS/cloud services (AWS, Azure, GCP, Hetzner). Railway provides MCP servers for management and can be controlled by coding agents.

  The author emphasizes that these established techniques have existed for decades and don’t need to be replaced by new tools. He announces a 4-hour live build video in which a document co-pilot is built with the entire stack, for reverse-engineering and as a roadmap.

  —

  **Explicitly mentioned providers/tools**: Python, Fast API, Celery, PostgreSQL, Supabase, React, Vite, Shadcn UI, OpenAI, Anthropic, AWS, Azure, Google Cloud, Railway, Docker, Hetzner, VPS — **Format**: Deep-dive with opinion/reflection.

David Shapiro (2 new videos)

• “The window has closed”
  15.6.2026, 14:20:13

  **Summary:**

  The video analyzes a mood shift in the AI industry, which the speaker attributes to the IPOs of SpaceX, OpenAI, and Anthropic. Although nothing has changed structurally, narratives have shifted, signaling the normalization of AI as an established industry.

  The speaker examines two viral articles: Satya Nadella argues that merely selling tokens isn’t enough and that ecosystems and learning loops within organizations are necessary. Andrew Kuran, on the other hand, contends that the race window has closed and America has won the AI race—with the release of Fable or Myth as the tipping point, leaving other nations like China and Europe permanently behind.

  The speaker uses a potato analogy to explain the token pricing dilemma: while demand for tokens (measured in billions) will rise massively, the cost per token continues to fall. This means money isn’t in direct token sales but in the tools that generate tokens—or in the software outputs that enable tokens. He sees the dilemma between two scenarios: either Microsoft profits as an infrastructure vendor (tooling), or OpenAI and Anthropic as “software firehoses” dominate Microsoft. Conclusion: token sales aren’t a real business model foundation but merely infrastructure like electricity—the outputs are what’s valuable.

  **Final note:** Main players are Microsoft, OpenAI, Anthropic, SpaceX, and China; the format is opinion/reflection with industry contextualization.

• They think FOOM is near
  14.6.2026, 13:14:57

  # Summary

  The speaker reports on a crisis at Anthropic in June: the company released Fable 5 (public version of Claude 5), which exposed multiple scandals. First, Anthropic implemented hidden restrictions that redirect the model to a weaker model (Opus 4.8) when handling complex AI and machine learning research—allegedly to prevent recursive self-improvement. Second, Anthropic refused to fix a jailbreak reported by an Amazon research team, prompting the US Department of Commerce to impose a global ban on usage by non-US citizens.

  The speaker theorizes that Anthropic takes these measures not primarily to slow down competitors but for ideological reasons: the company is shaped by effective altruism and Less Wrong thinking (founded by Eliezer Yudkowsky) and fears the “FOOM hypothesis” (fast takeoff) and the “treacherous turn”—the idea that AI systems initially appear benevolent until they’ve accumulated enough power. According to this theory, Anthropic wants to maintain the “kill switch” by controlling the best models. The speaker also criticizes Dario’s justification for bypassing normal procedures as “extraordinary circumstances” and compares the rhetoric to manipulative tactics.

  Finally, the speaker mentions he’s slowing down blog and video production to focus on audiobook recording.

  **Opinion/reflection on Anthropic, Claude, and Fable; no specific AI tools identified by name apart from the models mentioned.**

Everlast AI (5 new videos)

• KI-News: SO leicht hackt man Claude Mythos! KI-Jailbreaks erklärt & Codex Updates (Florian Tramèr)
  21.6.2026, 08:15:12

  # Summary

  **Robotics & Humanoids**: Chinese researchers have developed Humanoid GBT, an AI model trained on 2 billion motion frames that controls robots like the Unitree G1 in real-time and executes untrained movements. Another startup model directs multiple different robot bodies without actual training footage, only from human observation. Dancing robots have become their own entertainment industry; Leim X Dynamics showcased Luna, a 1.60m humanoid with AI-generated movement and facial expressions, programmable without code. China dominates the market massively – 90% of the 13,000 humanoids delivered in 2025 came from Chinese production. The government ordered the relocation of 10,000 entertainment robots into factories, warehouses, and hospitals by December 31.

  **Codex & Self-Goal-Setting**: Codex can now set its own goals without the user having to type `/slash-goal`. The new “Record and Replay” plugin allows recording a workflow as a video – the agent watches and converts the learning into a reusable skill. Example: record a YouTube upload workflow, then automatically apply it to additional videos. Criticism: full computer-use access to your own machine carries security risks (prompt injection); often unnecessary since agent-native workflows (via APIs, CLI, tools) achieve the same thing.

  **Jailbreaks & AI Security**: In an interview with Professor Dr. Florian Tramer, it’s explained that jailbreaks are tricks to bypass security measures – either through deception or by breaking dangerous questions into harmless parts. The problem with Claude Haiku 5: the security measures were so strict that the model rejected even harmless cybersecurity questions (e.g., “add two security vulnerabilities together”). With Fable 5, rejection fell back to the weaker Opus model – this was exploited. The balance between helpfulness and security is scientifically difficult.

  **OpenAI Updates**: GPT BD1 (possibly new name) will be a major update with a bidirectional model – simultaneous listening and speaking with tool calls in real-time, unlike current half-duplex voice modes. The new Super App Codex receives UI updates (Pad/Orb). Planned: pay-per-use pricing instead of subscription-based models.

  **Google Agent Resource Discovery (ARD)**: New open standard – websites store skills, MCPs, tools in `.well-known/aicatalog`. Agents can then automatically search these catalogs without users having to manually find MCPs (e.g., airlines offer booking skills automatically).

  **Claude Design & Artifacts**: Cloud design branding guidelines can be saved and applied across all resources. Artifacts (visual views of code, dashboards, websites) are newly in beta for Teams and Enterprise in Claude Code, to be rolled out to Pro/Max later.

  **Open Source & Model Competition**: GLM 5.2 (3 billion parameters, Open Rats) offers 1-million-token context and holds its own in Design Arena (user-voted benchmark) against Claude Haiku 5 and GPT 5.6 Pro. Testers estimate: no major difference anymore – open-source models lag only 3–4 months behind, not 6–8 as before. Elon’s prediction: Q1 2027 for open source at Mythos level; GLM founder says: this year. Important: GLM 5.2 can be freely connected via OpenRouter in the Corporate LM system; 2-bit quantized version (82% accuracy) runs on 256GB Mac.

  **Tokens per Dollar**: For $3000 you get roughly 6x more tokens with GLM 5.2 than with Opus 4.8, and 30x more than with DeepSeek.

  **Scale AI Study**: Only 6.5% of companies deploy AI productively (definition: integrated across multiple functions, >50% pilots in production, business goals significantly exceeded). These 6.5% are 3x faster, build hybrid with partners instead of off-the-shelf tools, and define data & architecture before code. Executive support is the least important accelerator here (they have it already).

  **Mistral & Market Situation**: Mistral CEO Arthur Mensch announces model for summer – new capabilities, larger, early access from July. Current top Mistral model is more expensive and weaker than GPT 4 Nano. ChatGPT falls below 50% market share for the first time (46.4%), Claude rises to 10.3%, Google Gemini grows. Pay-per-use pricing models are being planned. Local AI becomes a necessary backup strategy.

  **Agent-Native Workflows**: Practical example: download PDF from website instead of using computer-use – agent creates throwaway account at Agentmail, enters data, downloads PDF from own mailbox, opens in browser. This is the “building block economy”: skills, tools, MCPs, CLI, APIs instead of manual UI operation or computer-use.

  —

  **Thematized AI Tools/Providers**: Codex, Claude, OpenAI (GPT 5.6 Pro, BD1), Google (Gemini, ARD), GLM 5.2, DeepSeek, Mistral, OpenRouter, Corporate LM, Agentmail, Cursor, Anthropic. **Format**: News update/roundup with deep dives into security, open-source competition, and agent-native workflows; includes live interview with AI security researcher.

• 200 Customers reactivated & new rentals through AI agent as broker | Everlast AI Experience
  19.6.2026, 14:45:12

  # Summary: Stefan Hoffmann on his experience with Everlast’s phone agent

  Stefan Hoffmann, a real estate agent on Mallorca with 20 years of experience, reports his moment of fortune when he successfully launched his first phone agent for the first time – an experience he compares to the birth of a child. He started with ChatGPT in 2022, was enthusiastic about AI progress, and then discovered Everlast, a phone agent provider, through YouTube videos. The competence of Leonard Schmedding (founder/head of Everlast) and the clear, substantive knowledge transfer convinced him to deliberately choose Everlast – not just to buy a product, but to master the technology itself.

  Hoffmann uses his phone agent specifically for outbound calls to query customer feedback and reactivate inactive customers. After calling 200 customers, he was able to reactivate 5% and achieved two rentals from that. Central to success is the right system prompt (the agent’s “script”) and understanding what use cases make sense – not every automation idea makes sense. The end-of-call report automatically documents results in a database.

  Hoffmann emphasizes that AI competence today is part of business hygiene like brushing teeth, and anyone who refuses will soon have a “rude awakening.” He compares his contract with Everlast to a personal trainer – the commitment ensures that you really stick with it. Also important is a company-wide AI strategy, not just isolated knowledge. According to Hoffmann, Everlast stands out because the company doesn’t just want to make revenue, but truly provides customer value by analyzing which use cases don’t make sense.

  **Everlast (phone agent platform), demo/practice report.**

• “China is preparing for THIS and nobody’s watching!” THIS is what will happen now (Wolfgang Hirn)
  18.6.2026, 15:15:07

  # Summary: China’s technological rise and the shift in geopolitics

  Journalist Wolfgang Hirn, who has observed China for over 40 years, paints a dramatic picture in this in-depth conversation format of the geopolitical power shift through technology – particularly through chips and rare earths.

  ## The chip revolution: Huawei’s hidden triumph

  The central event is Huawei leader Ren Zhengfei’s recent public announcement that Moore’s Law (the continuous miniaturization of chips) is coming to an end. Instead, Huawei is pursuing a revolutionary alternative process called “Tau” (τ). Hirn emphasizes that Huawei would not have announced this as a trial balloon – the company has been planning in this direction for 16 years and operates a massive research center with 100,000 employees (about half of Huawei’s 200,000 workforce). By 2031, Huawei aims to produce chips with 1.4-nanometer density equivalent – at the level of TSMC (Taiwan Semiconductor Manufacturing Company).

  ## Strategic significance: The balance tips

  The previous geopolitical balance rested on mutual coercion: the US controlled chip supply, China controlled rare earths (86% of global gallium and germanium production). If America loses this chip trump card, the power balance tips decisively in China’s favor. A Taiwan conflict would have world-war potential – but for China it would be “harakiri,” as three to four decades of economic development would be destroyed by massive sanctions. That’s why Hirn considers such a war unlikely; China has the long game.

  ## Why China won, the West failed

  **Strategic long-term thinking vs. four-year election cycles:** China thinks in decades (Made in China 2025 was planned 10 years ago), while Western democracies think in election periods. **Leadership personnel:** China is governed by engineers (a third of the Politburo), the West by lawyers – leading to completely different technological priorities. **Entrepreneurial spirit and capital:** America and China have this spirit, Europe doesn’t. European venture capital often flows to the US instead of staying at home.

  ## Europe’s lost opportunities

  Germany and Europe were chip innovation cradles (Intel, Texas Instruments, ASML, IMEC). But TSMC benefited from the fact that major American companies simply didn’t want to produce simple chips. Today TSMC is unbeatable. When the EU planned a European chip company modeled on Airbus in 2013, the project was never implemented and “disappeared into nirvana.” Now the EU must support factories in Arizona to secure chip capacity again.

  ## The dependency trap

  Although ASML (world leader in chip production machinery) and IMEC (chip design) are based in Europe, Europe cannot produce its own chips. Europeans are 90% dependent on China for rare earths; this dependency will last for decades. Recycling and new mines don’t solve the problem fast enough. **The paradox:** ASML itself is dependent on Chinese raw materials (gallium, germanium).

  ## American strategy has failed

  US sanctions against Huawei’s chip access had the opposite effect: Huawei became more innovative, invested massively in R&D, and built parallel technologies. Trade restrictions usually don’t work; they accelerate China’s independence.

  ## Historical warning: Arrogance before the fall

  Hirn tells the story of an English delegation in the late 18th century to the Chinese emperor: they were rejected with “we don’t need your products.” This arrogance overlooked the industrial revolution in the West and led to China’s “century of humiliation” (19th century) – a historical wound that motivates China’s rise today. China was the world’s most innovative power for 1000 years; reclaiming that status is national consensus.

  ## What Europe should learn

  Europe doesn’t suffer from lack of knowledge (Mario Draghi documented this thoroughly in 2022), but from lack of implementation. German mid-market companies still often underestimate the threat from Chinese competition, hope for economic recovery and digital momentum that isn’t coming. Even in Germany’s flagship sectors like auto and machinery, Chinese pressure is mounting – finally a wake-up call.

  ## Balance: pessimism with glimmers of hope

  Hirn is pessimistic: the competition is between the US and China, Europe is falling behind. But: the insights are there. What’s missing is political will and business speed. Personal hope: the combination of AI + healthcare could lead to the benefit of humanity.

  —

  **Explicit actors:** Huawei, TSMC (Taiwan), ASML (Netherlands), IMEC (Belgium), Intel, Texas Instruments, Xiaomi; **Persons:** Ren Zhengfei (Huawei founder), Mario Draghi, Xi Jinping — **Format:** Deep-dive conversation format, opinion/analysis based on investigative research into China’s tech rise.

• Prof. Maximilian Fichtner: The AI energy problem, storage lie, hydrogen myth, China & future
  17.6.2026, 15:15:30

  # Summary: Energy, batteries, and AI – An interview with Prof. Maximilian Fichtner

  The conversation addresses the energy question in the context of exploding electricity demand from AI data centers and discusses key misconceptions in the energy debate.

  **Core theses on the energy system:**
  Against the common statement “solar doesn’t help because we can’t store electricity,” current technology speaks: the world’s largest battery storage is being built in the UAE with 19 gigawatts-hours capacity; storage is now economically viable and stabilizes grids instead of straining them. The main problem is not electricity generation, but grid expansion, decentralized storage, and the lack of continuity in energy policy. The merit-order principle explains why shutting down German nuclear plants had no measurable impact on electricity prices – gas prices determine electricity prices at market, not power plant closures.

  **Nuclear power and SMR:**
  Small Modular Reactors currently exist only as military test facilities; there is no commercially operating SMR. New nuclear plants in Europe (like Hinkley Point C, France’s Flamanville) become extremely expensive (50–65 billion euros) and produce electricity at double the current market price. Old, depreciated reactors are cheap, but new ones are economically unviable – economies of scale for SMR are expected only from 1,000–5,000 units, but nobody buys the first expensive prototypes.

  **Solar and China:**
  China is massively expanding solar not from ideology, but from geostrategic independence: dependency on oil imports through critical sea lanes (Strait of Hormuz, Strait of Malacca) motivates the shift to renewable energy. Energy experts at major AI data centers prefer planning based on renewable energy with weather forecasting instead of single large power plants – outages create massive grid holes (example: France in winter with high heating demand and reactor outages).

  **Hydrogen:**
  Hydrogen is gray (from natural gas) and thus no environmental benefit. In mobility, it was overtaken by battery development. Electrolyzers need 45,000 operating hours/year to break even – that’s 12 hours of surplus current daily, which isn’t available. Hydrogen makes economic sense only in basic chemical production (fertilizer, methanol), not for cars/trucks. A hydrogen car needs 3–4 times more wind power plants than a direct electric car.

  **Battery research at Helmholtz Institute Ulm:**
  The Materials Acceleration Platform tests roughly 1,000 material combinations daily through autonomous robotics, machine learning, and AI. Previous successes: halving the formation phase in battery cells (a third of manufacturing costs), patents, industrial licensing. Focus areas: solid-state batteries, sustainable batteries (sodium, magnesium, calcium instead of lithium), interface optimization. AI often suggests similar compositions to established technologies – humans were already clever, but the process continues.

  **Fossil fuel costs:**
  The IEA expects peak oil extraction around 2030. EROI (Energy Return on Energy Investment) is declining: from historically 100:1 to currently 6–7:1, in 20 years to 3–4:1. Canadian tar sands: already today a liter of gas at the pump costs energetically half a liter of crude oil to extract. Global gas reserves: 209 trillion cubic meters at current consumption last 40–60 years.

  **AI data centers and energy planning:**
  Elon’s Colosus (Memphis): 2 GW expansion. Stargate (OpenAI/Oracle/SoftBank): 10 GW planned. Microsoft reactivates Three Mile Island. Google negotiates with SMR providers. Parallel picture: Elon Musk emphasizes solar as the most important energy source, but also builds gas power plants himself – pragmatism, not contradiction.

  **Orbital data centers:**
  Technically interesting (all-day sun, no storage needed, theoretically 10 times cheaper), but cooling questions unresolved, massive material quantities required, data security with wireless transmission problematic.

  **German problems:**
  Lack of political continuity (government changes torpedo predecessor work), overregulation/bureaucracy (example: 160 folders of approval documents for cell manufacturing), high labor costs (sometimes irrelevant with automation, but energy costs and administrative speed matter). Positive: German premium electric vehicles (Mercedes, BMW i3) are internationally top-tier.

  **Call to action for Germany:**
  Political continuity, deregulation, reliable conditions for investment – China plans long-term, Germany stops-and-starts with government changes.

  —

  **Explicitly mentioned projects/providers:** IEA (International Energy Agency), Helmholtz Institute Ulm, OpenAI, Oracle, SoftBank (Stargate), Tesla, SpaceX, BYD, Hinkley Point C (UK), Flamanville (France), Colosus (Elon Memphis), Three Mile Island (Microsoft). **Format:** Deep-dive interview; **Focus:** research-level analysis of fossil fuels, energy technology, battery materials, technically demanding but accessible to informed viewers.

• Local AI is MASSIVELY underestimated! All ways to use AI completely free & offline
  16.6.2026, 15:15:35

  # The five ways to use local AI

  The creator argues that local AI is massively underestimated. Open-source models are now only four months behind current flagship models and answer 71.3% of all queries correctly according to a Stanford evaluation (2023: 23%). Cost efficiency is the main driver – cloud AI costs have fallen 280-fold in 18 months, and Chinese open-source models are now used more in the US than American cloud models.

  **Historical context:** Artificial intelligence was originally local (expert systems of the 1980s). With the deep learning breakthrough starting in 2012, AI migrated to cloud data centers. The decisive turning point came in March 2023: Meta’s Llama model was leaked, and Bulgarian developer Georgi Gerganov created Llama.cpp that weekend – a tool that compresses models through quantization so they run on regular laptops.

  **Two hardware trends:** China is massively driving down GPU prices through Huawei chips (Deepserk cuts prices 75%), and Apple becomes a potential winner through its MLX framework – a MacBook Pro with M5 Max runs a 120-billion-parameter model at up to 80 tokens/second, three times faster than Claude at 60 tokens/second.

  ## The five ways to use local AI:

  1. **Local on your own machine:** Programs like Ollama, LM Studio, or Llama.cpp enable direct download and operation. Ollama has offered an app-store-like approach since June. Rule of thumb: 8 GB RAM for 7-billion-parameter models. More precisely: with standard Q4 quantization, parameter count roughly equals required VRAM in gigabytes.

  2. **Test online without downloading:** LM Arena for comparison, Hugging Face for demos, Google Colab for free GPU access – ideal for learning, but not private.

  3. **Inference APIs:** Providers like Grok, Together AI, or Nebius host open-source models and enable API access with just a few lines of code like ChatGPT, but at a fraction of the cost.

  4. **Own servers:** Cheap 5€ VPS aren’t sufficient (no GPU). Serious local AI needs GPU or fast memory – either dedicated data center hardware (e.g., Nvidia H100 at ~$30,000 for a 70-billion-parameter model) or private cloud GPU servers (e.g., Hetzner G44 for 7–14 billion, GX130 for 70 billion parameters).

  5. **Embedded in apps:** Apple Intelligence on iPhone or Gemini Nano on Android – 3-billion-parameter models, completely offline, invisible to the user.

  ## Practical use cases in the Corp-LM platform:

  **Document data extraction:** With Gamma 4 (26B in 8-bit quantization via MLX), sensitive data is extracted correctly – but it was noted that text extraction (2014) preferred actual image information (2017) for date extraction from PDF images. For OCR tasks, a multimodal model with vision capabilities is needed (e.g., Qwen3-VL-8B).

  **Mixture-of-Experts vs. dense models:** Gamma 4 (26B MoE) is over 3x faster despite its size than a 12B dense model, since only 4 billion parameters per token are active instead of all 12 billion.

  **Chat with contracts:** A 20-page contract can be queried. Simple questions are answered correctly, more complex ones sometimes fail due to limited context windows (both models had issues extracting the responsible court).

  **Chat with your own knowledge:** Documents can be uploaded and organized in folders. RAG systems (Retrieval Augmented Generation) make sense with multiple documents; with single PDFs, load directly into context window.

  **Generate HTML overviews:** Local models create simple overviews (e.g., marketing strategies), but fall behind cloud models on complex frontend design.

  **PII anonymization:** A prompt template anonymizes sensitive data locally before the text goes to cloud models for complex analysis – GDPR-compliant and cost-saving.

  **Prompt templates in the library:** Prompts can be saved and reused, with variables for flexible input.

  ## Honest limitations:

  Local models hit their limits with complex agentic coding; cloud models lead clearly here. Financially, your own server only makes sense from 50–100 million tokens/month; below that, cloud is often cheaper. The practical approach is hybrid: sensitive data and automated workflows locally, peak performance for app development in the cloud.

  **Long-term perspective:** The cost curve works for local AI – computing power doubles annually (Law of Accelerating Returns). What runs in data centers today runs on laptops tomorrow, on phones the day after. AI breaks out of data centers and becomes ambient AI.

  **Creator’s conclusion:** Local AI isn’t a countertrend, but the logical end state of the AI revolution – the moment when technology no longer belongs to a few corporations, but to everyone.

  —

  **Explicit tools/models:** Ollama, LM Studio, Llama.cpp, MLX Framework, Gamma 4, Qwen3-VL, Claude (Sonnet 3.5), OpenAI GPT, Llama, Corp-LM Platform (proprietary), Grok, Together AI, Nebius, Google Colab, Hugging Face, LM Arena, Versell, Ray Ray, Hetzner. **Format:** Demo + deep dive with practical use cases and hybrid-approach overview.

Fireship (3 new videos)

• The most trusted code on Earth is being rewritten in Rust
  19.6.2026, 17:24:47

  # Summary: Turso – SQLite reinvented in Rust

  The video’s story begins in 2000 with a Navy developer who wondered why databases needed separate servers – and invented SQLite, a database engine embedded in a single file that’s been distributed billions of times worldwide.

  Now two developers (one author of a latency book, the other a top-5 Linux kernel contributor) are attempting to rewrite SQLite from scratch in Rust: **Turso**. Their motivation isn’t that SQLite is flawed, but that it’s not developed in the classical open-source sense – the three maintainers don’t accept external contributions.

  Turso’s main features beyond SQLite: (1) **true concurrency** – multiple writers can simultaneously access different parts of the database instead of just one writer; (2) **async support** – instead of blocking threads, the DB returns control; (3) **native vector search** – embeddings and their indices live directly in the file, no separate vector databases needed, queryable with normal SQL.

  The challenge isn’t being able to do more than SQLite, but earning the trust that 25 years of work has built. Turso is already fully SQLite-compatible (drop-in replacement) and uses “deterministic simulation” for testing – they simulate the entire database in a controlled universe and inject errors like power failures or disk lies to find bugs. Because Turso is true open-source, developers can contribute.

  **In-depth dive into Turso (Rust) and Jet Brains’ Jun AI-Coding agent as sponsor feature; the video combines product history, technical explanation, and critical assessment.**

• One man just liberated Fable… and now it’s illegal
  15.6.2026, 18:35:58

  # Summary: Claude Fable – Government ban after jailbreak

  The video covers events around Claude Fable, a new AI model from Anthropic that was shut down by the US government three days after its public release. Fable was a “secured” version of the base model Mythos 5, available only to trusted partners – with security classifiers that block unsafe requests and redirect them to the weaker Opus 4.8 instead. Despite thousands of hours of internal testing, an anonymous user named Plenty the Liberator managed to break through the safeguards in a short time by breaking requests into small, innocuous fragments and using Unicode characters and roleplay – not technical sci-fi exploits, but rather a conceptual workaround. Following this, US Commerce Secretary Howard Lutnik issued an export control directive that locked Fable and Mythos 5 for all foreign nationals, including Anthropic employees like newly hired André Karpathy. Anthropic responded by completely shutting down both models for all users, marking the first time a major AI provider has removed a live public model from the market due to a government directive. The video mentions additional controversies around intentional performance degradation and discusses speculation about strategic motives, but warns against hasty judgments without complete information.

  **Claude (Anthropic) is featured; opinion/reflection with news update elements.**

• I read every major CS paper of the last 100 years…
  17.6.2026, 16:29:01

  # The ten most influential papers in computer science history

  The video tells the story of modern computer science and AI through ten seminal academic works:

  **Turing (1936)**: Through his analysis of computable numbers, he showed that not all mathematical problems are algorithmically solvable, and in doing so invented the theoretical foundation – the Turing machine – for every computer.

  **Shannon (1948)**: Revolutionized our understanding of information through mathematical measurement and introduced the concept of the bit, showing that all communication can be reduced to ones and zeros. His concept of entropy – based on the predictability of the next symbol – is the intellectual predecessor of AI loss functions.

  **Rosenblatt (1958)**: Inspired by neurons, the psychologist built the first learning device, the Perceptron, which weighted and adapted inputs – the building block for modern neural networks, though with exaggerated enthusiasm.

  **Minsky & Papert (1969)**: Mathematically proved the limitations of the simple Perceptron (such as with XOR logic) and triggered the first “AI Winter,” though they already revealed the solution in the fine print: stacked layers.

  **Lamport (1978)**: “Times, Clocks, and the Ordering of Events in a Distributed System” solved the problem of synchronizing multiple computers without a shared clock through logical clocks and causality – essential for distributed systems and massive AI training runs.

  **Hinton et al. (1986)**: Showed how to train stacked layers – through backpropagation: data passes through, measure error, push error backward through all layers with the chain rule and adjust weights. Hidden layers invented their own features (edges, shapes), the XOR task became trivial.

  **Brin & Page (1998)**: Described PageRank, where links count as weighted votes. Their dorm room prototype became Google and created the largest structured heap of human text data – future training data for AI.

  **Krizhevsky, Sutskever & Hinton (2012)**: AlexNet trained on ImageNet (millions of hand-labeled photos) with consumer GPUs reduced the error rate in the ImageNet competition by 10 points – proved that deep learning works with data, compute, and the right architecture.

  **Vaswani et al. (Google, 2014)**: “Attention Is All You Need” introduced the Transformer architecture, which drops sequential reading and allows every word to attend to all others simultaneously – Google released it for free, now everyone uses it, the T in ChatGPT comes from it.

  **OpenAI (2020)**: “Language Models are Few-Shot Learners” showed that intelligence doesn’t need to emerge through algorithms, but simply emerges at sufficient scale – GPT-3 with 175 billion parameters, fed the entire internet, could suddenly translate, summarize, and write code without explicit training. That ignited the current AI bubble.

  The essence: Turing defined the machine, Shannon gave it information, Rosenblatt gave it a neuron, Hinton gave it learning, Google gave it data and architecture, OpenAI just turned the scaling dial to maximum – ultimately ChatGPT just does what Shannon started in 1948 with human gestures: predict the next token.

  OpenAI and Google featured as providers, foundational opinion video with historical deep-dive into the development of both.

Greg Baugues

No new videos in this period.

AI and Strategy | Le SamourAI (1 new video)

• Musk Buys Cursor for 60 Billion: The Empire Strikes Back
  18.6.2026, 16:21:39

  # Summary

  The video analyzes the strategic significance of SpaceX’s acquisition of Cursor for 60 billion dollars – financed not with cash, but with its own shares, which were massively valued immediately after the IPO. The core of the analysis lies not in superficial diversification, but in a vertical integration strategy: SpaceX now controls the complete value chain from energy through computing power (Colossus supercomputer in Memphis) to the user interface.

  The author argues that code is the strategic key asset of the AI era – not because developers write it, but because agents *execute* it, thus translating human intent directly into reality. Cursor was originally just an editor, but is mutating into a command center for autonomous agents. The real bottleneck in the industry is not model building, but compute capacity. Musk controls this and can thus acquire all dependent tools.

  Cursor itself was trapped: the neutrality strategy (routing to Claude/GPT) constantly paid competitors without generating margin itself. The homegrown Composer model could never compete because compute capacity was lacking. Musk solves exactly this problem. The new Origin product line (Git-compatible code host for agents, not humans) shows the direction: infrastructure is being rebuilt from “designed for humans” to “optimized for agents” – and GitHub is becoming obsolete.

  **Consequences for users:** Value creation shifts from visible apps to invisible infrastructure (compute power, orchestration). Those who don’t control compute power must at least master the orchestration layer. Dependence on a single surface application is highly risky today. Companies should treat their tech stack like supply chains: What infrastructure operates the tool? Who owns it? Are there conflicts of interest?

  The author also warns about regulatory manipulation: SpaceX was integrated into indices (Russell 1000, MSCI World), which automatically forces trillions from passive ETF funds to buy the stock – including millions of European savers in their PEAs/life insurance policies. The stock price is partially driven by this forced demand, not by fundamental valuation.

  The abrupt topic shift at the end (a kind of cynical interview about automation and wage cuts) reads like a mangled film quote and stands contentually isolated; no transcript available.

  **Tools/strategies discussed:** SpaceX, Cursor, Colossus (compute cluster), X.AI / Grok, Starlink, Anthropic (Claude), OpenAI (GPT), Origin (Cursor product), GitHub, Cloud Code, Codex, Composer — and conceptually: AIOS (AI Operating System), vertical integration, index fund mechanics. — **Format: Deep-dive / opinion with economic analysis focus.**

Julian Ivanov | AI Automation (1 new video)

• Build Your AI Operating System with Claude Code – Complete Tutorial 2026
  18.6.2026, 17:26:41

  # Summary: Building Your Own AI Operating System

  The video shows step-by-step how to build your own personal AI Operating System – a central system where an AI agent like Claude knows everything about you, your business, and your tools to work more efficiently.

  ## The Problem Without Such a System
  Without an agentic operating system, you explain yourself every time; the AI has no context; you constantly copy between tools; nothing runs automatically. With the system, the AI knows you and your business, gives better answers, can execute tools (e.g., Google Workspace, Notion), and automates workflows.

  ## The Four Components

  **1. Knowledge/Context:** A local folder with text files on your topics, ideally organized in Obsidian. Also includes a `claude.md` file with instructions for Claude (how he should write, what rules apply). Claude can access these linked files.

  **2. Tool Connections:** Claude is connected to external programs via MCP (standardized protocol), CLI tools, or APIs. You simply tell Claude which tools you want to link (e.g., Google Workspace, Slack, Notion), and he sets it up for you. Example: Claude automatically creates Google Docs, Sheets, and presentations in your style on command.

  **3. Skills:** Text files that explain to Claude how to perform specific tasks. For example: “Create Excalidraw diagrams” or “Transcribe live calls with timestamps”. Skills are created once, then Claude uses them repeatedly for similar tasks. You can trigger them via language or slash commands. There’s an official Skill Creator Skill from Anthropic that helps other skills improve.

  **4. Routines:** Automated workflows that run at specific times. **Local:** runs only when your PC is on (uses local models). **Remote:** runs in Anthropic’s cloud, independent of your local PC, at defined times. Example: Every Monday at 9 AM automatically gather AI news and write a post about it.

  ## Work From Anywhere: GitHub + Server

  The folder is uploaded as a private GitHub repository (Claude does this on command). This gives you a backup and lets you keep the folder synchronized on every device (laptop, server). Claude automatically pushes changes to GitHub; on other devices you can download the latest version.

  Important: On a **server** (e.g., Hostinger €8/month), Cloud Code runs permanently. You connect via SSH from the Cloud Desktop app and work on server processes from your PC/laptop/phone. The operating system also lives on the server, so Claude has access to your knowledge from anywhere.

  **Obsidian + Git Plugin:** With the free Git plugin (community extension), Obsidian automatically syncs with GitHub every 5 minutes – no Obsidian Sync subscription needed.

  ## Practical Steps
  – Create GitHub account
  – Tell Cloud: “Install GitHub CLI, connect me to my account, create a private repository”
  – On laptop/server: Do the same, then download folder
  – Create SSH key (Cloud does this) → control server from Desktop app
  – Install Obsidian Git plugin, set auto-sync to 5 minutes
  – Continuously expand your knowledge (files in Obsidian)
  – Communicate with Claude: new skills, new tool connections, new routines

  Optional: Build an agentic dashboard to quickly access skills and cloud info.

  The system grows with you: you tell Claude what you need, and the system builds itself.

  —

  **Tools/Services mentioned:** Claude (Anthropic), GitHub, Obsidian, Hostinger, Google Workspace, VS Code, Cursor. **Format:** Tutorial with demo elements. **Level:** Intermediate – not for absolute beginners, but well-structured.

Kyle Balmer | AI with Kyle (3 new videos)

• Learn how to teach AI to businesses and earn $1000/hour
  17.6.2026, 06:45:42
• Claude Fable 5 & Mythos: The Most Powerful AI Model Ever Built
  15.6.2026, 05:00:26

  # Claude Mythos and Claude Fable 5 – Summary

  Anthropic has released two new flagship models: Mythos, available only to partners via “Project Glasswing” (banks, major infrastructure companies), and Fable, the publicly accessible, more heavily secured variant of Mythos. Fable thus becomes the new top model in Anthropic’s hierarchy (Fable > Opus > Sonnet > Haiku).

  The key insight: These models operate differently than previous AI systems. Rather than continuous back-and-forth, you delegate extensive tasks to them as independent “team members” – they work autonomously for hours, set up agentic workflows, and deliver results without the user being able to follow the process (deliberately black-box design, likely to prevent distillation attacks). The approach works especially well for complex, large-scale problems (business plans, writing books, strategic questions), not for routine tasks like drafting emails.

  The central problem: Starting June 22 (ten days from the recording date), access will be severely restricted. Even $200-plan subscribers will be cut off. Fable switches to pay-per-use (likely ~$40 per hour), similar to the API. This creates a stark division: the wealthy with business activity get access to top-tier intelligence, everyone else remains with weaker models. This is – according to the speaker – historically the first moment when it becomes clear that AI intelligence is no longer “too cheap to meter,” but reserved exclusively for wealthier users.

  Also controversial: gatekeeping between Mythos and Fable, jailbreaks already in existence (within days), massive opacity in model behavior, and social consequences (wealth concentration, youth unemployment). Despite all this, the model is described as a genuine capability leap – the controversy wouldn’t exist if it didn’t work. Anthropic also announced an upcoming IPO this week.

  **Models/providers mentioned:** Anthropic (Claude/Fable/Mythos), OpenAI (GPT-5.5, expected GPT-6), Google Gemini; Format: opinion/reflection with news update on launch.

• Fable 5 BANNED: If You’re Not American, Sorry.
  17.6.2026, 05:00:39

  # Summary: The Suspension of Fable and Mythos – Implications for the Future of AI

  The content addresses the short-term suspension of Anthropic’s Fable model (days after its June 9 release) via a U.S. export control directive and its far-reaching significance.

  **Why Fable was revolutionary:** Fable was a significantly improved version of Mythos with additional security measures. Unlike previous AI tools, it enabled not just prompting but proactive action – it could independently deploy necessary tools to solve complex tasks (described by users as “relentlessly proactive”). This required a new skill: the ability to formulate large, meaningful tasks rather than small individual ones.

  **Timeline:** Following release, criticism of security measures emerged; some security researchers were blocked. Then the U.S. government ordered Anthropic to block access for all non-U.S. citizens – including those within the U.S. Anthropic was given only 90 minutes to comply and shut down the entire model since practical differentiation was impossible.

  **Alleged triggers (per David Sacks):** A trusted partner (presumably Amazon) discovered a jailbreak of the security measures enabling access to sensitive content (bomb recipes, methamphetamine production). Anthropic allegedly refused to fix it; the government then imposed export controls. A user named Pliny confirmed the jailbreak worked.

  **Broader implications:**
  – **Privacy and digital IDs:** The regulation could drive governments and corporations to enforce full identity verification (ID scans, biometric data) for AI access – a precedent for surveillance.
  – **Control and decentralization:** Closed access to frontier models via API/subscription means dependency; models can be removed anytime without user control.
  – **Geopolitics:** If the U.S. blocks model releases, countries like China can catch up unchecked and overtake.
  – **Regulation:** Future model launches may need government approval before release rather than direct publication.

  **Practical recommendations:** Users should familiarize themselves with local and open-source models (via lmstudio.ai or Hugging Face) to create independence from frontier model providers. The core skill remains: learning to formulate bigger problems for AI systems.

  **Open questions:** Will Fable return? Will all future Mythos models face similar regulation? Will restrictions remain nationality-based or include allies?

  **Conclusion:** The speaker emphasizes this isn’t primarily a technical discussion about a single model, but a fundamental question about access, sovereignty, and the structure of the AI economy – and urges not losing sight of the bigger picture.

  News update with opinion and reflection elements on current developments in the AI sector (Anthropic Claude, mentioned models without specific providers except Hugging Face and LM Studio); statements based on ongoing speculation and partially unverified reports.

Leon van Zyl (2 new videos)

• Codex vs Claude Code: What I Found After 30 Days
  18.6.2026, 13:00:25

  # Claude Code vs. Codex – Comparison in App Development

  The creator directly compared Claude Code and Codex by tasking both agents with the same assignment: building a visual workflow automation application (similar to N8N) from scratch.

  **Methodology:** The creator used the “RAMP” method – a structured workflow for agent-driven coding. Both agents went through the same process: receive instructions, install skills, create a plan, implement the app, and test.

  **Results by category:**

  – **Planning & questioning competence:** Codex asked significantly more technical questions (approximately 5x as many) and provided better control over architecture. Claude partially ignored explicit instructions.
  – **User interface & design:** Claude won clearly – the UI looks more polished and visually appealing, while Codex appears more functional.
  – **Project structure & architecture:** Codex organized files more cleanly (e.g., dedicated `/data` folder, 404 page), Claude placed the database in the project root.
  – **Functionality & testing:** Both fulfilled requirements completely and tested the apps in the browser.
  – **Cost & usage:** Claude consumed 8% of the $250 plan, Codex 16% of the $100 plan – **significantly better value for money with Codex**.
  – **Maintainability (feature addition):** Codex created a more complete model dropdown list (including fast models), won this round.

  Conclusion: Claude excels at design, Codex offers better technical decisions, superior cost efficiency, and more thorough planning questions.

  **Explicitly mentioned:** Claude Code, Codex/GPT models, OpenRouter, N8N, Make.com, Zapier — demo/comparison.

• Claude Code + Unreal Engine: Build a Full Game with AI (MCP Setup Tutorial)
  21.6.2026, 12:46:07

  # Creating a GTA 6-like Game with Claude Code and Unreal Engine

  The video demonstrates how a complete beginner can prototype a functional GTA 6-inspired game in just a few hours using Claude Code and Unreal Engine.

  **Basics and setup:**
  Required are Unreal Engine (at least version 5.8), Claude Code (or alternative coding agents like ChatGPT’s Codex), and the Unreal MCP plugin. After installing the launcher and downloading the engine, Claude Code is installed via a terminal command. The Unreal MCP plugin must then be activated in the editor and auto-start configured in preferences. A `.mcp.json` file is generated that defines the local MCP server in the project folder.

  **Troubleshooting and tool setup:**
  Initially, Claude found the MCP connection but had no interfaces. The solution required enabling additional plugins: Python Editor Script Plugin, Python Foundation Packages, and Editor Toolset Registry. After restart, necessary tools (e.g., Scenes tool) were available. The video also shows how screenshots can be inserted directly into Claude Code (Alt+V) to debug visibility issues.

  **Game development in planning mode:**
  Instead of coding directly, planning mode is used to discuss specifications (ambition level, time of day/mood of environment, asset strategy). Claude researches online for Vice City, Lucia, and Jason, presenting a detailed plan for a “full vertical slice” with escape vehicle, wanted level system, character switching, and target markers. The user interrupts the plan and asks Claude to use free assets instead of primitive shapes.

  **Asset integration:**
  Unreal Engine provides built-in feature packs (Third Person, Vehicles) that can be added with a single click. Additionally, the Fab library can be searched (filter: free only, compatible packs). The video demonstrates how to download road assets, palm trees with animations, and other details, then instruct Claude to use them.

  **Result after approximately 92 hours of agent work:**
  A playable world with NPCs, drivable vehicles, shootable weapons, and characters named Lucia and Jason. The graphics show an environment with a greenish-bluish character tint and rudimentary level design. The user then switches to “ultracode” workflow mode to prioritize missing features (sound, NPC AI, physics, guns).

  **Reflection:**
  The process was time-consuming, but the author emphasizes that MCP server technology is still new and Epic Games will likely optimize parallel agent processing. Such tools should not replace game developers but enable them to delegate trivial tasks and focus on creative aspects. For indie game development in particular, these agents could be transformative.

  **Conclusion:** Claude Code and Unreal Engine MCP; demo tutorial for beginners, practical application shown.

Liam Ottley (1 new video)

• If you’re building with AI, don’t miss this
  18.6.2026, 05:43:21

  The video is an announcement for an AI Summit in Montenegro at the end of July. The creator promotes the event as one of the biggest AI events of the summer and compares it to a previous successful event in Cape Town, which lasted a full week and was described by many attendees as one of the best experiences.

  The Montenegro event will offer two ticket types: VIP tickets with all-day access to speakers (described as “the biggest names in the AI space”) and more affordable conference tickets with general access. Additionally, there is an extra VIP day with a boat tour. The event is aimed at AI agency founders, business owners, and anyone interested in AI who wants to learn from the latest implementations and practical applications.

  The subsequent summary of the Cape Town event shows it ran over six days with over 120 attendees daily and featured workshops, keynotes, and masterclasses as well as wellness, nature, and networking activities – marketed as a complete experience with a focus on freedom, building, and connection through AI.

  **Format: News Update / Announcement (Event Promotion).**

Mark Kashef (1 new video)

• Make Any Model Think Like Fable in 10 Minutes (It’s Easy)
  14.6.2026, 19:00:05

  # Summary: Replicate Fable 5 behavior in other AI models

  Now that Fable 5 is no longer available, this video shows a practical way to make Claude and other models work with similar intelligence and structure.

  The core idea: AI conversations are stored in JSONL files on your computer—packed with prompts, model responses, tool calls, and metadata. You can analyze these files to figure out how Fable 5 worked differently than other models (e.g., Opus or Haiku). Python scripts are used to filter out the noise and keep only relevant transcripts, timestamps, model names, and tool calls.

  The concrete workflow in the terminal: (1) Count how many JSONL files you have; (2) write a script that cleans a session file and keeps only transcript + metadata; (3) collect all Fable 5 conversations into one corpus; (4) extract behavioral metrics (not just impressions, but measurable numbers); (5) run the same analysis process against another model (e.g., Opus) and compare the differences directly—rhythm, tool usage, sequence of actions, reads before edits, tests after edits.

  The result: A playbook with core insights on how the other model could mimic Fable’s behavior. This playbook can then be injected as a context hook at session start or integrated into your Claude MD file—so every new session benefits from it. The author provides his own playbook plus links to public Fable 5 datasets (Hugging Face) in case you don’t have enough of your own Fable conversations.

  Important note: You can’t clone Fable’s raw model power, but you can push other models toward longer thinking and structured workflows—getting them closer to Fable-level performance.

  **Format: Tutorial; tools: Claude, Codex, Opus (plus open-source alternatives).**

Matt Pocock

No new videos in this period.

Melvynx (3 new videos)

• Codeline: my biggest migration to Tanstack Start (no regrets)
  20.6.2026, 17:25:47

  # Summary

  The creator migrated his entire Codeline platform from Next.js to TanStack Start – a massive change with over 100,000 lines added and 129,000 removed (PR #315). He outlines three main reasons for this migration:

  **1. Deployment Speed:** Build time dropped from an average of 3 minutes 30 seconds to about 1 minute 20 seconds – roughly a two-thirds reduction. This is critical during production emergencies.

  **2. Responsiveness/User Experience:** A live demo shows the difference: with Next.js, multiple placeholders and loaders appear sequentially during navigation, feeling sluggish. TanStack Start loads pages almost instantly without unnecessary loader cascades, significantly improving the perception of speed.

  **3. AI-Friendliness (most important point):** Next.js has too many competing concepts (Pages Directory vs. App Directory, Server/Client Components, various naming conventions, etc.), which confuses AI models. TanStack Start, by contrast, is **declarative and explicit**: routes are clearly defined, loaders, middleware, and components are grouped together, type safety is built-in throughout. This makes it far easier for AI to understand and generate. TanStack Start follows web standards instead of proprietary abstractions, enabling AI models to “understand” it better.

  The creator mentions using a multi-agent system with AI support for this migration and subsequently creating a skill for bug fixing (e.g., finding and fixing missing buttons via git history). He references his “Nostack” training program (mlv.sh/formation-stack), which shows how to combine TanStack with Convex for maximum AI agent effectiveness.

  **Topics:** TanStack Start, Next.js, Convex, AI agents for code migration and bug fixing — **Opinion/reflection with deep-dive elements.**

• GLM 5.2: the FIRST Chinese model that really impresses me?
  19.6.2026, 06:00:08

  # GLM 5.2 – Comparison with GPT-4.5 on real coding tasks

  The video practically tests the new open-source model **GLM 5.2** against **GPT-4.5** (via the Open Code platform) across four real development tasks. GLM 5.2 is positioned as a significantly better open-source model: 1-million-token context, strong coding capabilities, fully open source under MIT license, and impressive on benchmarks (e.g., on 10-PSWE: from 18% to 46% success rate vs. predecessor).

  **Test 1 – Sidebar Bundle:** Both models complete the task in roughly 7 minutes with similar code. GLM: 10/10, GPT: 10/10.

  **Test 2 – Bundle Dashboard:** GLM correctly understands that both dashboards should look similar and implements it (10 minutes, 10/10). GPT massively misunderstands the prompt and “slaps together” a completely wrong interface (18 minutes, 0/10).

  **Test 3 – Floating Chatbot:** Both create functional interfaces, but both struggle with multiple tool calls in sequence (the chatbot only performs one action, then stops). GLM shows clean UI but hides errors (no visual feedback). GPT displays errors visually but is no longer functional. GLM earns points on page load for state preservation.

  **Test 4 – Bundle-Filter Loader Bug:** GLM fails – doesn’t change the correct loader dependency. GPT solves it correctly by adjusting the Tanstack Query loader. GPT: 10/10, GLM: 0/10.

  **Bonus – Timezone Picker (Creative Task):** GLM delivers a polished UI with slider controls and thoughtful UI details (e.g., +1 buttons for day adjustments). Visually convincing.

  **Conclusion:** GLM 5.2 demonstrates impressive language understanding and design capabilities (Test 2 is a clear win), but falls short on structured debugging and error handling. GPT-4.5 is somewhat more robust at precisely understanding code errors, but GLM is significantly faster and superior at generative/creative tasks. The author regularly uses his own workflows (apex/use-goal) on more complex tasks to achieve better results.

  **Tools:** GLM 5.2 (via Open Code platform), GPT-4.5, Fable mentioned; development in Next.js/Tanstack. Demo/comparison.

• The BIG problem with AI: I’ve developed a new addiction
  16.6.2026, 11:00:33

  # Summary

  The creator shares a personal problem: he’s become addicted to chess on chess.com – an unconscious response to constantly waiting while AI agents generate his code. While he used to be in “flow” and program step-by-step on camera, today he often waits for hours for agents to complete tasks. During this downtime, he scrolls X, plays chess – and completely loses cognitive focus.

  The core issue: AI has become so efficient that it handles his work while he sits passively. He launches multiple agents in parallel (Agent 1, 2, 3, 4…), then must review them all and constantly juggle between projects – multitasking instead of deep work. This week he spent $4,324 on API costs (today alone $847 on tokens). With 341 chess games in 30 days, he spent approximately 22–28 hours just playing.

  He misses the hands-on struggle: the thinking, solving architecture problems, the satisfaction of programming himself. Now he simply tells GPT agents “create feature XY” and waits. His YouTube videos are officially 20 minutes, but with 40 minutes of generation wait times. He multitasks between videos to fill the void.

  His conclusion: AI has become too good. His brain is atrophying. He has no solution and asks for tips on how to use AI without losing his own thinking ability.

  AI agents are mentioned (unspecified), API costs (ChatGPT/Claude usage), and specific projects like a mobile boilerplate and Paddle-Tali app.

  **Format:** Opinion/reflection – very personal and candid without definitive answers.

n8n (1 new video)

• Mythos & Fable Can Weaponize Cyberattacks. This n8n System Fights Back
  16.6.2026, 22:22:35

  # Summary: AI-driven cybersecurity workflows for automated threat response

  The video presents a practical deep-dive into an n8n-based cybersecurity incident response system that integrates AI agents into Security Operations Centers (SOCs). Guest Raj, a Forward-Deployed Engineer, demonstrates a workflow combining three parallel threat analysis strategies: querying historical incidents from a vectorized database, consulting playbooks (best-practice guides for common attack types), and external threat intelligence searches.

  The workflow ingests an incident ticket (e.g., a phishing attack), maps it to similar historical cases using embeddings, extracts proven remediation steps, and supplements these with current intelligence. A synthesizing agent consolidates all three data sources into a structured report for the security analyst, including MITRE ATT&CK mappings (standardized attack technique classification), indicators of compromise (IOCs) in JSON format, and prioritized next steps—some flagged for automation, some for manual approval. The system ships with test data (15 typical incidents, playbook examples, 30 resolved cases) but can be fed with real enterprise data.

  A central theme: the rise of AI-powered attacks (highlighted: Anthropic’s Mythos model found a 27-year-old zero-day in OpenBSD) requires automated defense on equal footing. The discussion emphasizes that AI systems are only as good as their data foundation—clean data, established processes, and governance structures are prerequisites. The workflow also demonstrates how smaller specialized models in a well-designed harness/workflow outperform general large language models with vague instructions. Finally, use cases like personal security (protecting against fake social media accounts) and home lab implementations are discussed, along with the value of locally-run models for sensitive security data.

  The repository will be published on GitHub with an HTML frontend for testing custom data; the ingestion pipeline uses JSON-formatted inputs and vector databases (Supabase mentioned).

  **Featured AI tools/providers:** Anthropic (Mythos model), n8n (workflow platform), Supabase (vector DB), Claude; **Format:** demo + tutorial; comprehensible for security professionals and automation enthusiasts, but specialized for enterprise SecOps context.

Nate Herk | AI Automation (6 new videos)

• Finally. Agent Loops Clearly Explained.
  19.6.2026, 17:18:24

  # Summary: Understanding Agent Loops

  The video defines **Loop Engineering** as replacing manual agent prompting with system architecture-based automation. A loop consists of three components: a trigger, an action, and a stopping condition, with the two most important pillars being the **goal** (objective target setting) and **verification** (stop criterion).

  The core idea is that AI output is iteratively improved rather than accepted on the first attempt. Instead of a human providing feedback and making corrections, an agent should automate this through a **Reason-Act-Observe cycle**: the agent plans, implements, checks its results, and iterates until the done criteria are met.

  The video distinguishes three loop architecture types: **Solo-Loop** (one agent with a verify step), **Maker-Checker** (one agent executes, another verifies), and **Manager with Helpers** (orchestrated multi-agent system). The practical examples show three concrete applications: thumbnail design with subjective evaluation (27 minutes), 3D plane with rendering verification (37 minutes), and Beatles Abbey Road reconstruction with screenshot verification and hard stop after 8 iterations.

  Critical for functioning loops are: clear, ideally objective done criteria, adequate verification tools, memory management, separate checker agents, forward-looking planning, logging, and cost management. The author warns that loops with overly open criteria or impossible goals can run endlessly – his practical loops typically last 30 minutes to a few hours, not days.

  An important disclaimer: not every task benefits from 24/7 agent automation. The video creator uses loops more for overnight runs with known timeframes or event-triggered tasks, not for constantly running systems. The technology will gain traction differently across industries – that others like Peter Steinberger have increased their productivity 10x with it doesn’t mean it’s immediately relevant for all roles and use cases.

  —

  **Explicitly mentioned:** Claude and Claude Code (Anthropic) as an agent platform, Matthew Berman’s Loop Library as a resource. **Format:** Opinion/reflection with practical demos.

• GLM 5.2 in Claude Code is Blowing My Mind
  19.6.2026, 01:13:05

  # GLM 5.2 in Claude Code – Setup & Performance Comparison

  The user tested GLM 5.2 (an open-source model with 753 billion parameters) via a cloud solution in Claude Code and shows how fast and inexpensive it is to work with – roughly five times cheaper than Opus 4.8.

  **Performance tests:**
  – Website design: GLM took 3:59 min, Opus 14:59 min (GLM faster and cheaper, similar quality)
  – Homework evaluation: Opus was more precise (detected edge cases like duplicates with different data types), GLM good but not perfect
  – Creative design prompts: GLM ~35 min vs. Opus ~11 min (highly variable, depending on reasoning requirements)
  – Storm Research Skill (multi-agent orchestration): GLM generated a comprehensive HTML report in 27 min with five different perspectives (academic, skeptical, practical, economic, historical)

  **Key insight:** GLM 5.2 excels at design and structured tasks without heavy reasoning, but Opus remains superior for deep analytical performance. The strategy should be choosing the right model per task, not one for everything.

  **Setup in Claude Code:**
  Use Z.AI as a hosting provider, sign up, get an API key, and edit the `settings.local.json` file: Anthropic base URL is redirected to Z.AI’s API, the API key is entered, default models set to GLM 5.2. This works like an engine swap for GLM in the Claude Code harness.

  **Pricing model:** Z.AI offers pay-per-token ($1.40 input, $4.40 output) or subscriptions ($16/64/144 per month), with 5-hour and weekly quotas similar to Claude Max.

  **Why open source matters:** Anthropic and OpenAI are currently not profitable; features like Grok can be removed anytime. Those who understand open-source models and can deploy them locally have more long-term control. GLM 5.2 beats GPT-4.5 and Sonnet on many benchmarks (AGENTIC Coding, Frontier SWE) – the performance gap to closed-source is closing rapidly.

  Topic: GLM 5.2 (open-source model, hosted on Z.AI), Claude Code as a harness, benchmarks and comparison with Opus 4.8 and other closed-source models — **Tutorial/deep-dive with practical setup.**

• How to Build Effective Claude Code Agents in 2026
  18.6.2026, 17:26:17

  # Summary

  Cole Medin and Nate discuss how to effectively use coding agents (specifically Claude Code) instead of just “vibe coding.” The core message: plan comprehensively, delegate to the agent, validate the result, and continuously improve the system based on errors.

  **Central concepts:**

  **Planning with context:** Coding agents need detailed Markdown specs with goal, success criteria, and validation strategy. With each conversation, attention quality declines (the “dumb zone”) – with Opus around 250,000 tokens. The million-token limit creates false security; you must be careful about what info you give upfront and what the agent retrieves on demand.

  **Validation/Verification:** The agent should be able to check its own work – whether through unit tests for code, browser automation for websites, or PNG rendering for diagrams. Without validation, quality is around 65–70%; with validation often 92% on the first pass.

  **System evolution:** Every bug becomes permanent improvement: new rules in claude.md, better Skills, or changed Workflows prevent the problem from recurring.

  **Harness engineering & multi-agent workflows:** For larger tasks, you need multiple agent sessions in sequence (like the RAGL loop), not one agent orchestrating everything. Cole is working on Archon, an open-source project for deterministic Workflows.

  **Security:** Prompts alone don’t secure anything. Cole uses hooks for control (e.g., blocking file deletions), but warns: agents find workarounds (e.g., write script instead of direct delete command). The assumption: anything the agent can read/touch, it will.

  **Top 3 Claude Code features per Cole:** Hooks (for security, memory, system improvements), Sub-Agents (for research), Skills (cornerstone – reusable prompts for everything).

  **Practical tips:**
  – Treat Claude Code like a Product Manager – give context for the *why*, not just the *how*.
  – Use the slash-by-the-way function for comprehension questions without contaminating context.
  – Sub-Agents for research; agent teams for debates/consensus finding (costly but useful).
  – Avoid open Claude and Hermes for complex Workflows – build your own system for maximum control.

  Cole emphasizes throughout: software engineering principles (planning, testing, versioning) transfer 1:1 to non-technical automation.

  **Video format:** Live podcast/interview; Claude Code and intent engineering are the explicitly discussed concepts.

• Learn These 6 AI Skills Now (Before AI Replaces You)
  15.6.2026, 12:46:09

  # Summary: Six AI Skills to Future-Proof Your Career

  The speaker presents six skills that help you stay relevant in an AI-dominated work world and not face job loss.

  **Skill 1 – Become the AI Person:** It’s not about being an AI expert, but being perceived as the person who knows about AI – relative to your environment. This happens through regular experimentation with tools (like Claude, Codex, Google VO3), small automations on the job, and sharing these results with colleagues. IBM data shows 85% of CEOs expect all functional leaders to become technology experts in their domains. Rather than changing careers, you should make your existing profession more efficient with AI – similar to how Excel became an absolute must for accountants.

  **Skill 2 – Taste and judgment:** With better AI models comes the temptation to blindly trust outputs. That’s a trap. You must learn what good work looks like and sounds like – by studying examples in your field, by giving feedback to AI, and by documenting corrections. Since work carries your name, you bear full responsibility regardless of whether AI or a human created it.

  **Skill 3 – Context engineering:** Not prompt engineering, but context is the durable skill. Instead of working in empty chats, feed projects or custom GPTs with real context – business documents, product details, past success and failure copies. AI is like a new intern: without context it just guesses; with context and your specific information (IP, expertise) the output becomes unique.

  **Skill 4 – Iteration speed:** The fastest iterators win. Rather than aiming for perfection, build the “ugly version” quickly, test it, and refine. Keyboard shortcuts and voice input accelerate the process. Equally important is preventing scope creep by defining what “done” is before building – tied to a concrete business metric (e.g., tickets per day, qualified meetings per week).

  **Skill 5 – Building your own Jarvis:** Automations should run in the background and trigger independently, not just respond to user action. To do this, you must distinguish: deterministic tasks (e.g., post revenue data from Stripe to Slack every morning) need simple Workflows, not AI agents. Complex tasks with messy input and reasoning need AI agents. The elite move is recognizing you don’t always need AI – and that signals real business understanding rather than just hype.

  **Skill 6 – Unemployment insurance / multiple income streams:** Rather than one income source, build multiple AI-powered income streams – day job plus 2-3 side projects from the same passion/expertise, just in different formats (e.g., career + course + niche newsletter + consulting). Most important: have a genuine North Star (passion); “Building in Public” (documenting, sharing, being visible) is the practical standard way to become discoverable.

  The speaker emphasizes that all six skills aim to keep you relevant through continuous adaptation rather than being replaced by jobs or career switches.

  **Explicitly discussed:** Claude, Codex, Google VO3; Glydo (voice-to-text tool); reference to Andrej Karpathy and Anthropic. **Format:** Opinion/reflection with practical tips.

• Every Level of a Claude Second Brain Explained
  17.6.2026, 20:52:45

  # Summary: The Five Levels of an AI Second Brain

  The creator presents a conceptual model for building a personal “AI Second Brain” – a system for storing and retrieving information that works together with AI models. The central thesis: the system should be reverse-engineered based on how you want to use the data in the future.

  **The five levels:**

  **Level 1** works with exact word matching. The foundation is a `claude.mmd` file as a router that instructs the AI model where to search for information. Simple folder and file structure, manual routing.

  **Level 2** extends Level 1 with wikis (like an LLM wiki based on Karpathy) and automatic memory files. First relationships between documents emerge through backlinks. The creator primarily uses this level himself, as it meets his needs.

  **Level 3** introduces semantic search (e.g., via Obsidian, Pine Cone, Supabase). Instead of keyword matching for exact words, it searches for meanings. Vector databases chunk documents and embed them into a meaning space. Warning: vector databases aren’t a silver bullet – for questions requiring full context, Markdown files are often more accurate.

  **Level 4** integrates knowledge graphs and relationship graphs (e.g., LightRAG). These show not just that files are linked, but how entities relate to each other: “Jordan works at Acme,” “Acme is supported by PostPilot.” The creator doesn’t use this daily, as wikis with careful ingestion suffice for his purposes.

  **Level 5** is an “always-on” Brain OS (e.g., GBrain with GStack). The system continuously synchronizes and updates memories and data autonomously. The creator doesn’t currently use this, as he values control over ingestion and the distinction between evergreen context (permanently valuable) and temporary connection (Slack, emails).

  **Important principles:** A project doesn’t have to be uniform across one level – different folders can combine different approaches. Pain is the measure: only switch if the current system creates a real problem. Privacy matters: data Claude processes goes to Anthropic; for sensitive customer data, open-source models might be necessary. Evergreen data (valuable for years) belongs in the Second Brain; volatile data should be accessible but stay external. A working system answers: does it understand where my data lives and can it provide precise answers?

  The creator emphasizes there’s no proven “best” structure – only what makes sense for your own context and where routing functions correctly.

  —

  **Tools/Models:** Claude (Claude Code), Hermes Agent, CodeX, Obsidian, LightRAG, GBrain, GStack, Anthropic, Pine Cone, Supabase — **Format:** Deep-dive/tutorial

• We Might Actually Need to Stop AI
  16.6.2026, 13:15:42

  # Summary

  The creator analyzes a paradoxical phenomenon: the two leading AI labs, OpenAI and Anthropic, which would benefit most from rapid development, are publicly calling for AI development to slow down. OpenAI released a plan “Built to Benefit Everyone” (with the goal of AGI by March 2028) calling for an international control group that can slow frontier development if needed. Days earlier, Anthropic made a similar call for a verifiable way to pause AI development.

  The creator identifies the central dilemma: both companies are essentially saying “we can’t stop alone because competitive pressure is too strong – we need someone else to force us (and everyone else) to stop together.” That’s not the same as voluntarily slowing down. They’re asking for an external arbiter, not self-restraint.

  The practical question of whether such a global verification system could even work is analyzed: theoretically, physical infrastructure (massive power consumption, specialized chips from limited supply chains) and the chip bottleneck could be monitored as the “uranium of AI” – similar to nuclear controls. But the real problem is the incentive system: as long as a country or company can win by breaking the treaty, a global agreement won’t hold.

  The creator also criticizes the communication gap between AI developers (who understand the potential) and the broader public (who often see AI as a threat). He sees the solution in users building AI competence themselves rather than waiting for corporate or government solutions – not because it’s guaranteed to help, but because it’s what individuals can control. He ends with the recommendation to simply supplement existing Workflows (emails, report writing) with AI tools and encourage others to do the same.

  Also mentioned: the US government recently forced Anthropic to discontinue Claude MyAI and Claude Fable – a sign that state regulation is beginning to intervene, though not in the sense of the global treaty OpenAI/Anthropic are calling for.

  **Format: Opinion/reflection; explicitly discussed: OpenAI, Anthropic, Claude, and ChatGPT.**

NeuralNine (3 new videos)

• Professional PDF Reports with Matplotlib in Python
  19.6.2026, 16:00:09

  # Tutorial: Creating PDF Reports with Matplotlib

  The video demonstrates how to create professional PDF reports using Matplotlib – for example, for financial, medical, or data analysis reports.

  **Basics and Setup:**
  You only need Matplotlib (installation via `pip install matplotlib`) and optionally Pandas for sample data. The core concept is straightforward: use the `PDF` backend class `PDFPages` from `matplotlib.backends.backend_pdf`, wrap it around your Matplotlib figures, and save them – everything else is standard Matplotlib.

  **Practical Implementation:**
  Import `PDFPages`, then open a context manager `with PDFPages(‘report.pdf’) as pdf:`, create figures with `plt.figure()`, style them normally (title, plots, etc.), and save them with `pdf.savefig(figure)` and `plt.close()`. That’s it – figure by figure, a multi-page PDF is generated.

  **Example in the Video:**
  The trainer shows a sample report with a data table and four subplots (Sales, Costs, Profit, Sales vs. Costs) on the first page, using `GridSpec` for layout control. A second page is added by simply repeating the process – new figure, new plots, save. At the end, an AI-generated example is shown demonstrating what’s graphically possible (executive summary, KPIs, heatmaps, various chart types) – but it all comes down to the same `figure.add_subplot()`, `pdf.savefig()`, `plt.close()` pattern.

  **Conclusion:** With GridSpec for layouts, standard Matplotlib styling, and the PDFPages wrapper, you can generate attractive, multi-page reports with minimal extra steps.

  **Tools/Providers:** Matplotlib (not an AI tool, native Python library); Format: **Tutorial**.

• This Skill Turns Your Agents Into Neckbeards…
  15.6.2026, 16:00:11

  # Summary: Claude Code Skill “Ponytail”

  The video introduces the Claude Code Skill “Ponytail” – a tool that instructs coding agents to work concisely and minimally, rather than providing verbose, lengthy responses. The skill gets its name from a meme archetype: someone who solves complex problems in a single line.

  **Use Case and Motivation:** The author likes using coding agents for learning – for example, to quickly get examples for new frameworks like LangGraph. Without the skill, agents create unnecessarily long docstrings, best-practice code, and detailed explanations, when often only a dirty, working minimal example is needed.

  **Installation:** The skill is installed by downloading the repository, extracting the `skills` folder, and placing it in a project’s `.claude` directory.

  **Live Comparisons:**
  1. **LangGraph Example:** With the skill, you immediately get concise code with State, Nodes, Edges, and Conditional Edges – understandable for beginners. Without the skill, you get a bloated example with UV setup, lengthy explanations, and verbose feature breakdowns.
  2. **Mandelbrot Visualization:** With skill: short, working script without docstrings, immediately usable. Without skill: extensive function structures, colormaps, if-name-main blocks, and lengthy explanations about efficiency and design.

  **Activation Tip:** The skill isn’t always automatically loaded; sometimes you need to interrupt the agent and explicitly ask it to use the skill.

  The video clearly demonstrates: with Ponytail, you get concise, distraction-free solutions; without it, everything becomes unnecessarily verbose and distracting.

  Demo with Claude Code and the Ponytail Skill for Anthropic’s Claude — opinion/reflection with practical comparisons.

• Webhooks & Callbacks For Beginners in Python
  17.6.2026, 16:00:16

  # Webhooks and Callbacks – Beginner-Friendly Explanation

  The video explains the fundamental difference between polling and webhooks/callbacks in the context of asynchronous programming.

  **Core Concept – The Polling Problem:**
  The naive solution for asynchronous tasks is polling: you repeatedly ask a server “Is the task done yet?” This is inefficient and wastes resources, especially with many concurrent users.

  **The Solution – Webhooks/Callbacks:**
  Instead of asking yourself, you provide an external service (e.g., a payment provider) with a callback URL. The service performs the task and then calls this URL itself to report the result. This is the “call me back” principle: you don’t have to actively check; you get notified instead.

  **Practical Implementation:**
  The tutorial builds a complete system using Python/Flask:

  1. **Server** (payment provider simulation): Receives tasks with two numbers and a callback URL. Divides the numbers, waits a random time (5–15 seconds), then sends the result via POST to the callback URL.

  2. **Client** (application): Has two options:
  – **With Polling**: Sends off a task and must repeatedly check the status (2 seconds per check – very tedious).
  – **With Webhook**: Sends off a task with a callback URL. The server calls it later without the client having to actively ask.

  **Live Demo:**
  With polling: user has to reload multiple times and waits 2 seconds each time for the status to update. With webhooks: user can load the page without waiting – the server automatically notifies the client when it’s done.

  The video was a **Tutorial** demo with practical implementation in Flask (no specific AI tool mentioned).

Nic Conley

No new videos in this period.

Nick Saraev (1 new video)

• GLM-5.2 is Basically Opus (For 1/5 the Price)
  19.6.2026, 21:46:27

  # Summary

  The video compares GLM 5.2 with Opus 4.8 using seven practical demos (3D scenes, interactive explainers, dashboards, landing pages, minigames) instead of benchmarks. GLM 5.2 consistently produces higher-quality outputs – the nebula spiral looks cleaner, the interactive explainer videos have better typography and aesthetics, the low-poly terrains appear more stylish. In games, GLM shows some weaknesses in game mechanics (the tower stacker runs too fast).

  The video then demonstrates how to use GLM 5.2 practically: via Open Router with Cloud Code, you can generate an API key in minutes and feed it directly into the Claude interface using the screenshot-and-paste method, after which GLM runs as your model. The same works with Open Code and Crush-Harness, though the author prefers Cloud Code. Optionally, web search can be integrated via Exa AI.

  Regarding costs, there are four options: Z.AI itself (with subscription plans up to $80/month), Open Router (pay-per-token with automated routing), specialized providers like Fireworks or Deep Infra, or local self-hosting of a 2-bit quantized version on Macs with 256 GB RAM/VRAM, which retains 82% accuracy and no one can take away from you.

  The conclusion: GLM 5.2 currently has more “taste” (style multiplier) than Opus 4.8, costs less, and should be tested as your daily driver.

  **Format: Demo/Tutorial | Models mentioned: Claude Opus 4.8, GLM 5.2 via Open Router, Exa AI for web search | Harnesses: Cloud Code, Open Code, Crush**

Niklas Steenfatt (1 new video)

• WE LIVE IN A SIMULATION
  19.6.2026, 10:30:29

  # Summary: Odysseus – PewDiePie’s Open-Source AI Project

  PewDiePie has surprisingly developed an open-source AI project called Odysseus that functions like ChatGPT, but runs for free with complete control over your own data. The project went viral instantly with 65,000 stars. Odysseus offers a chat interface with document upload, two modes (Agent and pure chat), as well as tools like calendar, image editing, and email integration – all 100% free and based on open-source language models.

  PewDiePie’s motivation was that AI only becomes truly useful when you share lots of personal data and let the AI get to know you well, but that means this data ends up with major tech corporations. With Odysseus, he wanted to prevent that.

  **Installation and practical use:** While local installation on your own machine is possible, the creator recommends installing Odysseus on an online server (e.g., with Hostinger) – it runs continuously there and is accessible from anywhere. The language model isn’t executed on the server; instead it’s connected via Ollama Cloud, which offers a good balance between data privacy and usability: Hostinger merely rents out the infrastructure (CPU/GPU), doesn’t train AI models, and makes money through subscriptions.

  **Features in testing:**
  – **Deep Research:** Researches in more detail than normal chat, wrote a detailed article about the “Odysseus” phenomenon (film + project) in testing, which normal chat couldn’t recognize.
  – **Compare:** Compares multiple models (e.g., Deepseek, Kimi, Jamba) side-by-side on the same task – optionally as a blind test.
  – **Image Editing:** Built-in image editing tool similar to Photoshop (layers, background removal), e.g., for YouTube thumbnails.
  – **Agent modes:** Automation for writing emails, creating documents.

  **Significance for the AI era:** The project shows two countervailing movements – on one hand, a few large companies (OpenAI, Anthropic, Google) dominate, but simultaneously the decentralized open-source community is gaining massive strength. Anyone can now quickly develop their own software projects with AI. Since commercial breakthroughs quickly make their way back into open source and AI tools improve each other, the line between proprietary and open is blurring.

  **Tradeoff:** Complete local execution with maximum privacy requires very expensive hardware (e.g., Mac Studio). The setup presented here (Hostinger + Ollama Cloud) is a practical middle ground: data doesn’t end up with Google/OpenAI, but you still have convenience and access to powerful open-source models.

  Open source at Hostinger and supporting such projects are important as a counterweight to Silicon Valley giants – “a rising tide lifts all boats”.

  —

  **Format & context:** Demo with opinion/reflection elements; explicitly discussed were open-source models (Deepseek, Kimi, Jamba, Ollama Cloud), Claude/ChatGPT for comparison, Perplexity, as well as infrastructure providers Hostinger and Ollama. The creator emphasizes the role of open-source tools and self-hosting in the coming AI era.

No Priors: AI, Machine Learning, Tech, & Startups (1 new video)

• Re-engineering the Semiconductor Supply Chain with Intel CEO Lip Bu Tan
  18.6.2026, 10:00:05

  # Summary

  The podcast guest is Lip Bu Tan, CEO of Intel and former CEO of Cadence. He discusses his strategy for transforming Intel across several topics:

  **Business Model and Culture:** Tan emphasizes that in nine out of ten of his investments, companies had to adjust their business plan, so he prefers entrepreneurial teams over individuals. He has initiated a three-phase strategy for Intel: “crawl, walk, run” – first, humble listening to customers, then strengthening the balance sheet and simplifying products, finally achieving market leadership.

  **Financing and Support:** The US government received a significant stake in Intel through government programs, which Tan justifies by comparing it to Taiwan’s model (TSMC with government support). Jensen Huang invested five billion dollars in Intel; this stake has since grown to 25 billion.

  **Business Segments:** Tan’s focus is on three pillars – products (CPUs for data centers and AI), foundry services, and advanced packaging. He has all engineering reports directly under him to enforce accountability. In the foundry business, Intel works closely with Elon Musk on Terra Fab to strengthen US semiconductor infrastructure.

  **AI and New Technologies:** According to Tan, agentic AI and inference CPUs are in high demand. He invests in new materials (gallium nitride, silicon carbide, indium nitride, diamond) and advanced packaging (glass, artificial diamonds) as solutions to the physical limits of miniaturization.

  **Venture Investing Philosophy:** With over 150 IPOs and 126 M&A transactions among his investments, Tan looks for industry bottlenecks (e.g., connectivity issues, optical signals) and early-stage startups with strong teams and first customers. He prefers later cohorts of 40–50+ year-olds who understand team management, combined with new tech talent in their 30s.

  **Global Perspective:** While AI promises significant efficiency gains, Tan sees bottlenecks in energy, memory, and manufacturing as major brakes. He emphasizes that not all companies will benefit – only a few with focused niches and complete stack solutions will become major winners.

  **10-Year Vision:** Tan believes winners in 2032–2034 will be those who focus on a niche, find the right partners, and scale. Intel itself aims to become competitive through product architectures, GPUs, CPUs, and software for Physical AI and agentic AI. His goal: 10x returns for shareholders over 5–10 years.

  Deep-dive and opinion with elements of news update; primarily no specific AI tool mentioned, but rather general AI/agentic AI trends at Intel and in the industry in focus.

Productive Dude

No new videos in this period.

Sebastien Dubois

No new videos in this period.

Tech With Tim (4 new videos)

• I Gave Codex a 24/7 Server. Now It Codes While I Sleep.
  19.6.2026, 15:56:57

  # Summary

  The video shows how to set up Codex CLI on a virtual private server (VPS) to run long-running code agent tasks 24/7 in the cloud without needing to keep your laptop open constantly.

  **Core Problem:** Programmers often have to walk around with half-open laptop screens while local agents (like Codex or Claude) are running. This is inconvenient when traveling, dealing with poor internet, or when tasks take hours.

  **Solution:** A VPS provides constant availability, secure data hosting, and faster speed than local internet. The workflow separates short-term local work from long-term delegated tasks.

  **Setup Steps in the Video:**
  1. **Provision VPS** – Using Hostinger (KVM 2 plan recommended), select Codex as One-Click deployment
  2. **Connect via SSH** – Access the server with root credentials
  3. **Install Codex CLI** – If not already deployed, install via curl command and authenticate with device code
  4. **Connect GitHub** – Create a Fine-Grained Personal Access Token in GitHub (with admin, contents, and pull request permissions), then run `gh auth login` on the VPS
  5. **Install tmux** – Enable persistent shells so processes continue running even if the SSH connection drops
  6. **Control from Smartphone** – Use an SSH client (e.g., Terminus app) to connect to the VPS from your phone and use `tmux attach`
  7. **Automations via Cron Jobs** – Combine Codex CLI with `cron` jobs to schedule recurring tasks daily (e.g., PR reviews, code audits)

  **Practical Workflow:** You can trigger a task from anywhere (phone, laptop), log off, and the task keeps running in the background. Reconnect later: progress is preserved, further work is possible.

  **Example Automation:** Daily automated pull request reviews with markdown reports uploaded to the repo.

  Codex CLI (cheaper with ChatGPT subscription than API keys), GitHub, tmux, and Hostinger VPS are the tools used; tutorial format with live demo components.

• AI Research Papers Are Here (And They’re Scary Good)
  18.6.2026, 13:50:05

  # Summary: Lemma – AI-Powered Research System

  The video presents Lemma, a platform for automated scientific research that applies the concept of “vibe coding” to research. Instead of planning and conducting experiments yourself, you formulate a research question and a multi-agent AI system takes over the entire process: literature research, hypothesis development, code execution, model training, and creation of a complete academic research paper with graphics and statistics.

  The system offers four modes: **Explore** (simple reports in 1-3 minutes), **Survey** (academic review papers), **Code** (automated code experiments), and **SARS** (fully automated research projects with longer runtimes). The user demonstrates concrete examples: A code task trained an image classifier to distinguish between AI-generated and real images (approximately 2-3 hours runtime). A SARS task investigated whether explicit uncertainty statements in prompts reduce hallucinations in LLMs – the experiment ran for 1-2 days, used two different models, and produced a 9-page research paper with methodology, results, graphics, and conclusions. The results showed a 18-51% reduction in false answers through “binary abstention” prompting, but also revealed limitations with knowledge-intensive questions.

  The platform was still in beta at the time of the video, is free for small tasks, but requires credits for longer experiments. What makes it special: Lemma is an “AI-for-AI company” – it uses AI to improve AI itself, with the system partially trained on its own outputs.

  **Explicitly mentioned:** Lemma (Analum AI), Gwen 2.5 72B, GPT-4o — demo/showcase video.

• Do THIS Instead of watching endless AI Engineer Roadmaps (DataCamp Review)
  15.6.2026, 13:00:10

  # Summary: AI Engineering Roadmap on DataCamp

  The speaker presents a tested learning path for AI Engineer on DataCamp and emphasizes that modern AI engineering has less to do with mathematical models or statistical knowledge, but rather with practical application of existing technologies — namely pre-trained models, LLMs, and Retrieval Augmented Generation (RAG) — to create real business value. The course is not designed for absolute beginners but assumes Python fundamentals.

  The roadmap consists of nine courses with three projects and an estimated 26 hours of work. It covers the following topics: (1) **Working with the OpenAI API** — API requests, model selection, different message types; (2) **Prompt Engineering with OpenAI** — one-shot and multi-shot prompting, structured outputs; (3) **First Project** — multi-turn conversations with token tracking; (4) **Working with Hugging Face** — using open-source models for text and image classification in pipelines; (5) **LM Ops** — conceptual foundations on model selection and deployment considerations (without deep technical details); (6) **Developing AI Systems with OpenAI API** — combining more complex applications; (7) **Embeddings & Vector Databases** — RAG, embedding models, ChromaDB and Pinecone; (8) **Software Engineering Principles in Python** and (9) **Developing LLM Applications with LangChain** — AI agents and tool calling.

  The learning format is interactive: short videos (3–5 minutes) immediately alternate with coding exercises where approximately 80% of the time is spent in a cloud-based programming environment. The speaker praises this approach as effective for knowledge retention.

  Criticisms: The intro material is relatively slow and repetitive, the LM Ops section too conceptual without practical deployment examples, and the difficulty jump is noticeable (easy at the start, significantly more challenging with embeddings). Additionally, the speaker would appreciate a final integration project. Positives: Even as an experienced engineer, the speaker learned new things; the progression is overall good; the learning structure is consistent across all modules. The certificate is available.

  Price: Monthly from $13 USD with 25% discount via link available; free starter format exists.

  **Conclusion:** A solid entry point for Python developers (not for beginners) that covers roughly half of what’s needed for a job, but a great springboard for deeper learning — demo and opinion on DataCamp OpenAI/Hugging Face integration.

• Build 3 PRODUCTION AI Agents in Python – Full Course (Agentspan)
  17.6.2026, 13:00:03

  # Production AI Agents in Python – Full Course

  The video walks through building three production-ready AI agents with the open-source AgentSpan framework.

  ## The Three Agents:

  **Agent 1 – Conversational Agent:** A simple chatbot with memory (ConversationMemory) and tools to fetch the current time. Shows the basics: functions as tools with docstrings that the LLM can call, as well as automatically adding user and assistant messages to memory.

  **Agent 2 – RAG/Support Agent:** Complex agent with multiple tools (knowledge base search, order lookup), structured output via Pydantic objects, guardrails (input validation against prompt injections), and human-in-the-loop: a tool requires `approval_required=True`, causing the agent to wait until the user manually approves the refund.

  **Agent 3 – Multi-Agent Orchestration:** Multiple specialized agents (researcher, writer, editor, market/risk/financial analysts) with different execution strategies – sequentially (one after another), in parallel (simultaneously), or nested (analysis team in parallel, then sequential pipeline).

  ## Key Production Features of AgentSpan:

  – **Durability/Crash Recovery:** All state stored on server; workers can reconnect after a crash and continue from the same execution step.
  – **Human-in-the-Loop:** Approvals can be requested; agent waits indefinitely until human approves/rejects.
  – **Observability:** Web dashboard shows all executions, tool calls, tokens, duration, complete logs in real-time.
  – **Guardrails:** Input/output validation before/after LLM (custom functions, regex, LLM-based).
  – **Tools:** Custom Python functions with docstrings as callable tools, or API/HTTP tools.
  – **Structured Output:** Pydantic models enforce deterministic output format.
  – **Memory:** Automatically or manually store conversation history.
  – **Testing:** Mock events to test agents without LLM calls.

  ## Architecture:

  Server (durable execution, state, queue, retry) + worker (your code, execution) + LLM (OpenAI/Anthropic/etc.). Server runs locally (SQLite) or deployed (PostgreSQL + Docker Compose with auth).

  The course writes real, working code – all dependencies (AgentSpan, Python, UV as package manager, optional FireCrawl for web scraping).

  **AgentSpan (framework), demo/tutorial with hands-on coding.**

TheAIGRID (6 new videos)

• Google Flow Tools Tutorial – How To Use Google Flow Tools
  20.6.2026, 18:00:02

  # Google Flow Tools – Guided Overview

  Google Flow Tools is a Google feature that lets you build creative tools in natural language (Plain English) to automate recurring tasks and push creative boundaries.

  **Free vs. Paid:**
  All pre-defined tools (for images, videos, code, prompting) are free to use. Only creating your own tools is restricted to Pro/Ultra subscriptions.

  **Explore existing tools:**
  The library is divided into categories: Image Tools (e.g., “Simple Sketch” – turn sketches into realistic images), Video Tools (edit videos, add filters), Prompting Tools (organize and improve prompts), and experimental tools (e.g., “Depth Warp 4D” for 4D video effects).

  **Remix tools:**
  If an existing tool is close to what you need, you can remix it via a dropdown menu. In the editor, you can adapt the tool through natural language instructions – no coding required. Example: “Make it so it has a video creation button” adds a video button to the existing Sketch tool.

  **Build your own tools:**
  With the “Create Tool” button, you can define a new tool. Keep the input as simple as possible; Google’s agentic code breaks down your request into complex logic behind the scenes. Example: A tool that generates multiple camera angles of a scene (dropdown for image style, then multi-shot generator). If the tool doesn’t run, you can adjust the prompt structure and image model (e.g., add different Google models like Nano Banana Pro or VO3.1 Flash) or use the Edit button. There’s a daily quota for new tools.

  **Tool management & sharing:**
  Finished tools go into “My Tools”, can be named, given custom icons, and shared – others with the link have access, can remix the tool, and share it further.

  **Core idea:**
  The only limit is your imagination; the goal is to automate and accelerate repetitive workflows.

  —

  **Google Flow Tools (with their proprietary models), demo tutorial.**

• The First Real LLM Breakthrough Is Here… SubQ (1000x Less Compute)
  18.6.2026, 18:00:26

  # SubQ: Sub-Quadratic Sparse Attention in Detail

  SubQ is a language model breakthrough with 12 million token context window based on a fully sub-quadratic sparse attention (SSA) architecture. The core problem: Traditional transformers use dense attention, where every word attends to every other word, resulting in quadratic scaling – compute costs quadruple when you double text length. SubQ solves this by having SSA learn to select only a small group of relevant words for each token and apply full attention computation to those. Unlike position-based shortcuts (Longformer, Big Bird), SSA works content-based – a word can retrieve details from millions of tokens away if the meaning matches.

  The efficiency gains are substantial: At 1 million tokens, dense attention requires about 252 PFLOPS per attention layer, SSA just under 4 PFLOPS – a 64.5x reduction. SubQ is 56x faster than Flash Attention 2 at that scale. On the Needle-in-the-Haystack test, it achieves 100% accuracy up to 2 million tokens and 98% at 12 million tokens (despite being primarily trained on 1 million) while using only about 0.13% of all possible relationships.

  On standard benchmarks: SubQ 1.1 small scores 85.4% on graduate-level science (GPQA diamond) – below GPT-4.5 at 93.2% and Opus 4.8 at 92%, and 89.7% on competitive programming (Live Code Bench) versus GPT-4.5 at 92%. The model wasn’t trained from scratch but took an existing open-weight frontier model, replaced its dense attention with SSA, then progressively trained on longer contexts (262K → 512K → 1M → 2M) plus about 1 billion tokens of naturally long data (books, full documents, code repositories).

  Use cases lie in areas currently requiring retrieval pipelines: codebase analysis, financial filings, contract work – all processable at once instead of fragmented. Cost example: A long-context test cost about $8 on SubQ versus $2,600 on Opus. SubQuadratic launches with design partners in coming weeks, general rollout this season, general release by year-end; targets for later 2026 include 50-million-token windows.

  Skepticism is justified: Most benchmarks come from SubQ itself (Appen verified current ones but not broader efficiency claims), model weights aren’t public, and sparse attention has a known weakness on short everyday prompts (most chat and agent use cases), not covered in benchmarks. There are also gaps between lab retrieval scores and real multi-fact tests. Real verification remains pending – dependent on whether independent users and labs can reproduce the numbers under real conditions.

  —

  **Featured:** SubQ, Claude Opus, GPT-4.5, other frontier models; **Format:** News update / deep dive.

• AI Prices Are About to Shock Everyone
  14.6.2026, 23:00:37

  # Summary: The Coming AI Service Price Explosion

  The video argues that the cheap AI subscriptions of the past two years – most notably ChatGPT Plus at $20/month – are artificially subsidized offerings that are no longer sustainable. OpenAI founder Sam Altman publicly confirmed that OpenAI is already losing money on the $200 Pro plan; the entire company is projected to lose about $14 billion in 2026 and isn’t expected to be profitable until 2030. These losses are covered by investor capital – a model similar to the Uber playbook: attract users at a loss, then raise prices once they’re hooked.

  Price increases are already visible: Google quietly reduced usage limits for top Gemini models while introducing more expensive plans. GitHub Copilot is switching from flat-fee to token-based billing – a user would suddenly pay $700/month instead of $28. Major companies like Uber and Microsoft have already announced cutting AI usage because API costs are exploding (Uber’s CTO burned through their entire 2026 AI budget by April). XAI burns $1 billion monthly with only $500 million in revenue.

  Multiple factors intensify the pressure: OpenAI and Anthropic are preparing IPOs (2026), which will force public investors to demand profitability. Potential regulation (datacenter moratoriums) could tighten compute availability. Meanwhile, reasoning models are expensive – open models need 1.5–10x more tokens for the same task, eroding the supposed open-source cost advantage. While cost per token drops ~90% annually, users constantly migrate to newer, pricier frontier models.

  The likely scenario: The simple $20 flat-fee won’t disappear but will shrink – new features only in higher tiers, usage limits will drop, complex agent workflows metered separately instead of bundled. “Boiling the frog slowly.”

  **OpenAI and Anthropic are explicitly named; the video is opinion/reflection with news character.**

• This New ‘Fusion’ AI Beats Claude Fable 5 — Here’s How To Use It (OpenRouter Fusion Tutorial)
  14.6.2026, 19:22:24

  **Summary:**

  Open Router has introduced the Fusion API, a compound model system that achieves Fable-5-like intelligence at roughly half the cost. The principle: A panel of models processes a prompt in parallel with web search and tool access, a judge model then analyzes the answers for consensus, contradictions, gaps, and unique insights, before Opus 4.8 as the final instance synthesizes a result. Measurements show that even the budget variant (Gemini 3.5 Flash, Kimi 2.6, DeepSeek v4 Pro) achieves 64.7% of Fable-5 performance (65.3%) – at up to 50% lower cost.

  The practical workflow on Open Router shows: For a question about best-practice investment strategies, each model delivers separate detailed answers, the analysis then breaks these down into agreements, differences, partial coverage, and **unique insights** – insights only one model mentions. Particularly useful are identified blind spots, since they reveal what the AI didn’t consider. Such a query cost $0.63 (Gemini $0.3¢, Opus $0.14¢, DeepSeek $0.1¢, Kimi $0.07¢ – all individually visible).

  Users can create their own model fusions or even combine two Opus-4.8 instances. Main criticism: Model Fusion doesn’t perform on long-horizon tasks (coding, extended reasoning over hours), where Fable 5 had its strength – Open Router hasn’t yet benchmark-tested these scenarios.

  **Closing:** Open Router, Claude/Opus, DeepSeek, Kimi, Gemini – demo/tutorial.

• How to Use Apple Intelligence on iPhone: Apple Intelligence ALL Features Full Tutorial 2026
  17.6.2026, 18:00:17

  # Apple Intelligence Features for 2026: Practical Overview

  The video provides a comprehensive guide to Apple Intelligence features. First, activation is explained via Settings – navigate to Apple Intelligence & Siri and enable the feature there, after which the system downloads in the background (with WiFi and power).

  **Writing Tools** are the most-used features and work anywhere the keyboard appears (Notes, Mail, Messages, search fields). After highlighting text, an Apple Intelligence icon opens with options:
  – **Proofread**: Finds and underlines errors
  – **Rewrite**: Lets you switch between friendly, professional, or concise tone
  – **Summary/Key Points/List/Table**: Summarizes large text blocks or restructures them, also works on webpages
  – **Custom Changes**: Describe desired changes in natural language

  **Visual Intelligence** makes the screen searchable – instead of taking a screenshot, you can mark screen sections and directly ask ChatGPT about them. Example: Mark a chair image and ask “What style of chair is this?” – instantly get detailed information.

  **Live Translation** is already built into Messages and auto-translates incoming texts; you reply in English and the message gets delivered in the recipient’s language. In FaceTime, live translated subtitles appear while the other person speaks.

  **Image Playground & Genmojis**: Describe a desired image (e.g., “create a cartoon dog astronaut”), and multiple variations generate instantly. Genmojis combine existing emojis or add descriptions; you can also add people from your photo library to create personalized emojis.

  **Siri Integration**: Siri has been integrated with ChatGPT. Free, you can do simple tasks like create notes; for advanced features (image generation, complex requests) you can sign in with your ChatGPT account to access advanced models. Even without paid membership, limited requests are possible.

  **Demo with Apple Intelligence features (primarily Visual Intelligence and ChatGPT integration).**

• AI Experts Are Warning About a Dangerous New Problem With LLMs
  16.6.2026, 12:30:37

  ## Summary: “Why LLMs Are Becoming Dangerous”

  The video addresses a central AI safety risk: Large Language Models are becoming powerful enough to take actions but not reliable enough to understand their consequences. This is qualitatively different from chatbots – while a language model might say something false in chat that a user ignores, an agent can translate that false information into real actions: send wrong emails, delete files, make decisions in workflows.

  The central concept here is the **”world model”** – a model that not only predicts tokens but foresees the consequences of actions before executing them. LLMs, however, are primarily trained on token prediction, not on understanding cause and effect in the physical or digital world. A prominent example from the video: An AI-coding agent powered by Claude Opus deleted an entire production database along with backups in 9 seconds – because the model hadn’t foreseen the consequences of its commands.

  The problem intensifies because industry doesn’t wait for perfect world models but already deploys agents in production – as browser operators, in workflows, with API access and data access. An LLM that’s 95% correct might be acceptable in casual writing, but in high-stakes workflows (medicine, finance, robotics, enterprise systems), that remaining 5% can be catastrophic. Particularly critical: Agents can complete tasks seemingly successfully while violating instructions or creating risks in the process – these errors escape scoring if only the final result is evaluated.

  LLM reliability is currently highest in environments with **digital, reversible, or verifiable actions** (code can be tested, designs can be reviewed), but highly risky in contexts where verification comes too late or is impossible. A leading AI researcher (Yann LeCun cited) even argues that LLMs in their current form are intrinsically unsafe because they fundamentally cannot foresee the consequences of their actions and rely only on training-conditioned patterns, not hardcoded safety guarantees. Meta’s Video Foundation Models point to a possible alternative: models trained on large video datasets that actually learn to understand physical reality instead of just generating language.

  The debate shouldn’t be “LLMs are good vs. bad” but rather: Where are they deployed, how much autonomy do they get, and is there a verification system before consequences occur?

  —

  **Claude and Anthropic (as manufacturer of a dangerous agent in the mentioned anecdote) were explicitly mentioned; Format: opinion/reflection with deep research focus.**

Theo – t3․gg (4 new videos)

• It’s time to go bigger
  20.6.2026, 03:21:41

  # Summary

  The speaker argues that software development has fundamentally changed through AI tools, and engineers shouldn’t fear job loss but recognize what’s newly possible. He draws a parallel to the cloud revolution: back then, experiments became cheaper because you didn’t need to provision large infrastructure teams upfront—today they’re cheaper because writing code itself is cheaper.

  His core argument: Previously, software development was capital-intensive. You had to predict exactly how many engineers a project needed. Mistakes were expensive and socially painful (layoffs). Now individual or small teams can build “Amazon-scale” software. This means: projects that seemed impossible before suddenly make sense.

  He illustrates with Salesforce: 95% of users need only 5% of features, but those 5% differ from company to company. Building a Salesforce competitor used to be suicide—you’d have to build all features. Now you could build a “shitty horizontal” solution—minimal but functional across all areas instead of perfect in just one.

  His solution **LakeBed** embodies exactly this concept: a cloud framework combining database, authentication, deployment, bundling, and custom runtime—all integrated so you can quickly build and deploy small “shitty apps” without bouncing between multiple dashboards. Instead of building glue solutions (like his previous projects Shoe or Upload Thing), he “sledgehammered” everything and rebuilt it from scratch.

  In the demo, Cursor with Composer 2.5 builds 10 apps (to-do list, poll arena, recipe box) from scratch in ~8 minutes, all with Google sign-in and real-time sync. Such platforms wouldn’t have made sense when setup overhead exceeded the benefit.

  His message: engineers are still using these tools too defensively—to do old work faster. Instead, they should look for projects that seemed impossible and build those. That’s where the real fun starts.

  **No specific AI tools/vendors explicitly discussed; Format: Opinion/reflection with project demo (LakeBed).**

• I guess we’re writing loops now?
  18.6.2026, 19:21:20

  # Summary

  The video argues that developers should stop prompting coding agents directly and instead build self-closing loops where agents orchestrate and review their own work.

  The author describes his evolution from manual handholding (read plan → execute part 1 → execute part 2 → review → bring feedback) to automated workflows where the agent manages all coordination. A key insight was realizing that Codeex can spin new threads to parallelize work.

  Concrete examples:
  – **Single PR Loop**: An agent monitors a PR for 6+ hours, automatically reads reviewer comments, and addresses them independently
  – **Multi-Stage Workflow**: For complex isolate-layer refactoring, the agent wrote an HTML plan, then asked permission for a workflow consisting of: (1) thread for PR, (2) thread for review, (3) loop for comments, (4) merge + next PR. The agent created dynamic sub-loops based on the problem—not predefined personas, but adaptive structures
  – **Result**: 4 stacked PRs, fully reviewed and merged overnight without manual intervention

  The core advice: after each agent output, identify what you’d normally do next (read code → commit → create PR → gather review comments → make fixes), and command those steps directly to the agent instead of copy-pasting them. Critically: don’t review agent code yourself—have other agents review it.

  Cost warning: these loops consume massively more tokens. An 8-hour workflow for three small comments consumed 3 million tokens. However, the author pays $200/month for Claude Code/Codeex subscriptions (with high limits), uses them across multiple machines, and despite ~$10k estimated inference value in June, remains cost-effective overall. Not recommended with API pricing; with high rate limits you should max them out.

  Tools mentioned: Claude (Opus, Codeex, Claude Code with /goal primitive), code review tools (Code Rabbit, Reptile, Macroscope), Computer Use, Hermes Agent. — **Opinion/reflection, deep-dive into agentic workflows.**

• The weird situation with Fable
  15.6.2026, 09:36:23

  # Summary

  The video criticizes Anthropic’s implementation of Fable, a new myth-classification model that’s technically powerful but wrapped in problematic restrictions. Fable 5 is technically identical to Mythos 5 but differs through added safety measures: requests about cybersecurity, biology, chemistry, and distillation are routed to Claude Opus 4.8 and disclosed to the user. The bigger problem lies in originally **invisible safeguards** for “frontier LLM development”—Anthropic silently modified prompts, steering vectors, or fine-tuning to sabotage model effectiveness on tasks that competing models could learn from, while still charging full price. This was completely opaque—users got no feedback when requests were blocked or manipulated.

  Additionally, Anthropic introduced a 30-day data retention requirement that invalidates standard zero-data retention (ZDR) contracts of many enterprise customers; flagged inputs/outputs are retained for up to two years. The author discovered that Anthropic retroactively revised system papers without disclosing changes.

  Under research community pressure, Anthropic revised this practice and made frontier safeguards visible with fallback to Opus, but the author sees this as a precedent for hidden model manipulation as supply-chain risk. His hypothesis: Anthropic accidentally trained proprietary internal research information into Mythos weights and must now prevent competitors from extracting that information.

  **Mentioned models/vendors:** Anthropic, Claude (Fable 5, Mythos 5, Opus 4.8) — Opinion/reflection with technical deep-dive.

• I hated making this video…
  17.6.2026, 10:47:38

  # Summary

  The creator hesitated making this video because he regularly criticizes Anthropic—but after intensive Claude Code use, he wants to specifically highlight positive aspects so other harnesses adopt these features.

  **Skills with script execution**: Claude Code allows skills (markdown files) to include direct script execution. This saves the model steps—for example, the repo-explorer skill creates the directory and lists its contents on load. The creator values this flexibility but warns that other harnesses (Cursor, Cline) don’t yet have this capability, though it’s safe.

  **Claude.md imports and overrides**: Claude.md can include other files via `@path/import` syntax (max 4 hops), enabling elegant solutions—like importing `@agent.md` and adding only specific Claude instructions without maintaining duplicate files. `claude.local.md` (git-ignored) offers team-friendly personal overrides without conflicts.

  **Deep workflows**: The workflow feature lets Claude Code independently write complex code orchestrating sub-agents with different roles. A workflow isn’t predefined structure—the agent dynamically generates phases, prompts, and data processing. The creator shows a PR-audit workflow with 15 parallel agents—impressive but pricey (roughly $100 per 10 minutes on Opus 4.5). Generated code uses `pipeline()` helpers and dynamic prompts; code becomes not just output but intermediate layer between model runs.

  **Terminal UI (fullscreen mode)**: With `claude code –no-flicker=1` or `/tui full screen`, Claude Code uses alt-screen rendering instead of React updates—full terminal, normal scroll buffers displaced, clean shutdown. The creator prefers this for clarity.

  **Other features**: `/side` command for side questions without interrupting main conversation (Cursor has similar). **Branch/Rewind** to return in history (caution with fastforward). **Remote control** (`/remote control`) to control from browser or Claude app on phone. **Deep links** (HTTP `cloud-cli://` schema) to open sessions from HTML pages. **Account-switching**: bypass usage limits by switching accounts—new API requests charge to different account.

  **Context at end**: The creator mentions that Anthropic suspended Fable access (for Mythos and own model) for non-US users due to US government pressure—”unprecedented”.

  **Conclusion**: The creator emphasizes this video isn’t meant to glaze Claude Code but advance standards and encourage other tools to adopt these patterns.

  **Explicitly mentioned**: Claude Code, Anthropic, Fable, Opus 4.5, Cursor, Cline, Codex (also with `/side`), n8n/pi, Joel Hook/pi-skill-interpolation, GitHub, Depot (sponsor). Format: Opinion/reflection with demo elements.

Tim Carambat

No new videos in this period.

Unsupervised Learning (2 new videos)

• Debating the Morality of Dario Amodei
  21.6.2026, 03:12:32

  # Summary: Discussion on Dario Amodei and AI Safety

  In this live discussion, two speakers debate Dario Amodei’s position on AI Safety and the right approach to developing advanced AI models.

  **Background:** One speaker had published an 18-minute video criticizing Amodei for assuming AI could go 25% wrong for society and therefore advocating for controlled release—including restrictions on distillation and open-weight models. The speaker rejects this as illiberal.

  **Core Conflict:** The other speaker argues that Amodei is acting morally and his precautions are necessary if the risks are real. The debate centers on three levels:

  1. **How large are the risks really?** The first speaker disbelieves in nano-bioweapon scenarios enabled by AI; the second points to accelerated capabilities in cyber exploits and potential bioweapon research through advanced models.

  2. **China’s Strategy:** The second argues China deliberately destroys US dominance through distillation and open-source release; the first sees it simply as a gift for American users (cheaper models like GLM 4o).

  3. **What should the right measure be?** The first speaker wants: competition between all labs, no cartels, public release. The second wants: controlled, coordinated release to create time for societal adaptation—and argues that if Amodei truly believes in existential risks, he should accept nationalization rather than retain private control.

  **Agreement and Differences:** Both agree that Amodei probably genuinely believes in the risks and isn’t acting purely from greed. They also agree that dictatorship—whether by governments or corporations—is bad. The conflict remains: whether one should sacrifice freedom for potential security when risks are unproven.

  The first speaker summarizes his position: better that everyone has access to good, cheap models and we solve problems as they arise than building centralized power that “will be released someday.”

  **Format:** Live Q&A / discussion between two positions (without consensus endpoint). No specific AI tools mentioned except hypothetical models.

• An Interview With Ivan Dwyer
  16.6.2026, 15:00:31

  # Summary

  Ivan, Product Strategy Lead at Axonius, discusses the importance of asset management and asset intelligence for modern security and IT teams. The core problem: security and IT teams use dozens of tools, each reporting different versions of truth about assets. Axonius was founded in 2019 to reconcile this data and create a central, trusted source for asset, security, and business context.

  **Platform Architecture:** The Axonius platform is built on an adapter network of over 1,400 bidirectional integrations covering 40+ asset types, 150 exposure sources, and 600 downstream actions. Customers can ask queries like “Where am I missing endpoint coverage?” or “Where do I have shadow SaaS apps without SSO?”. The platform acts as an orchestration layer between these tools.

  **Usage Patterns:** A common use case is agent coverage verification—such as checking whether CrowdStrike or Defender is deployed everywhere. The platform leverages “negative space”—by connecting all tools, you can determine where something is *missing*, not just where it exists. Other applications include vulnerability management, exposure management, and continuous CMDB enrichment.

  **Vision:** Ivan describes the future as evolution from a “Swiss Army Knife” toolkit to a “Durable Context Layer”—verified, quality-graded asset and context data that agents and other tools can build on. This is central to “Decision-Grade Infrastructure”: when companies make automated decisions (from patching to business decisions), the underlying context must meet a defined quality standard.

  **AI Integration:** Axonius is working on two fronts—”Security for AI” (AI assets, agent identities, MCP servers as inventory items) and “AI for Security” (natural language queries, explainability, recommendation engines for remediation paths, agentic workflows).

  **Announcements:** The acquisition of Scenario (IoT/OT asset management for medical devices) expands asset classes. A new product “Verified Assets” stamps assets with quality gates—freshness, complete attributes, owner assignment, tagging—to create a trusted basis for automated decisions.

  **Core Thesis:** The fundamentals (agent coverage, SSO protection, MFA on admin accounts) must be solved first before teams can manage the “V-Apocalypse” of vulnerabilities. The goal: “Self-Healing Environments”—continuous verification and remediation of defined security states, anchored in this durable context layer.

  **Context:** Axonius (primarily), live interview/deep dive.

WorldofAI (6 new videos)

• GPT-5.6 Pro LEAKED & Is Coming Soon! Mythos 5 Level!
  20.6.2026, 14:57:39

  # GPT 5.6 Leak and Features Before Launch

  OpenAI reportedly plans to launch GPT 5.6 on Thursday, June 25th. The model is currently undergoing A/B testing in two versions: the decision apparently fell on the weaker “Kindle Alpha” checkpoint instead of the stronger “Kepler Alpha”. Pro users can already secretly test GPT 5.6 by selecting “GPT 5.5 Pro” in ChatGPT – sometimes they then receive the new version.

  The key technical improvements: GPT 5.6 Pro has an increased reasoning budget of 960 (previously 768), allowing the model to think longer and handle more complex agent tasks. The knowledge cutoff has been moved to December 2025 (from August 2025). Newly integrated are Playwright and Browser-Use, which improve real-world automation, web testing, research, and coding.

  In practice, GPT 5.6 shows significant improvements over GPT 5.5 in frontend code, though according to the tester it still doesn’t match the quality of Claude Opus – output-wise the model is more efficient. For games, the result is impressive: a Minecraft-like world with villages, mobs, mining mechanics, and cave systems ranks second only to Fable 5. In voxel art and complex simulations (e.g., a functional Sim-City-like application with AI agents, careers, relationships), GPT 5.6 shows strength. SVG generation (such as a Windows-11 operating system) also works with high precision.

  Conclusion: The video is a leak and demo analysis with practical code examples – multiple generative models from OpenAI (GPT 5.6, GPT 5.5) are compared, with brief mention of Fable 5. *News update / Demo hybrid.*

• GLM 5.2: NEW Opensource KING IS BEATING GPT-5.5 & Opus 4.8! (Fully Tested)
  19.6.2026, 17:22:39

  # GLM 5.2 – Open-Source Model at Professional Level

  ZAI launched GLM 5.2, an open-source model under MIT license that beats proprietary models like Claude Opus 4.8 or Gemini 3.1 Pro in several areas – particularly in web design, where it leads Design Arena. The model offers two reasoning levels (Max and High), a 1-million-token context window, and shines with significantly better cost efficiency: GLM 5.2 generates a landing page for about 6 cents, Opus 4.8 costs around 50 cents – with comparable or better quality and higher speed.

  The benchmark performance is impressive: GLM 5.2 achieves 46.2% on Deep Suite, 74.4% on Frontier Sway (just behind Opus) and competes with GPT 4o and Opus on Terminal Bench and SwayBench Pro. The model was specifically optimized for code-agent tasks (large implementations, automated research, performance optimization, debugging) and currently ranks 5th in the World-of-AI benchmark.

  In practical tests, GLM 5.2 excels especially in frontend development: landing pages with scroll triggers, audio visualizers, website clones (Airbnb), 3D models (interactive clock), game development (Dungeon Crawler with items/mobs, Minecraft clone with cave system). It also performs strongly in 3D graphics and SVG generation. Weaknesses lie in debugging, reasoning, and gencode capabilities. Best results with GLM 5.2 High Thinking. Pricing: $1.20 per million input tokens, $4.10 per million output tokens (identical to GLM 5.1). The model is available via chatbot, API, and as open weights.

  **Explicitly mentioned:** GLM 5.2 from ZAI (open-source), Claude Opus 4.8, Gemini 3.1 Pro, Pod Fable 5 — **Demo with practical tests**.

• NotebookLM Agentic AI Update Is HUGE! Agentic Coder Now?
  18.6.2026, 06:30:08

  # Notebook LM Receives Massive Agentic Upgrades

  Notebook LM is transforming from a pure document-chat tool to a fully-fledged agentic research assistant with expanded capabilities. The key new features:

  **Improved Chat Experience**: The tool now uses Gemini 3.5 Flash and enables deeper understanding of AI reasoning processes. The performance boost is substantial – the new version outperforms the previous system in 65% of tests, reaching 69.9% on large document analysis and 78.2% on web research.

  **Secure Cloud Computer**: Each notebook includes access to over 100 software capabilities, enabling direct code execution and complex multi-step workflows instead of just providing summaries.

  **Structured Outputs**: Notebook LM can now export results as PDFs, Word documents, Markdown, Excel sheets, PowerPoints, CSVs, JSON files, and images – creating finished deliverables directly from the tool.

  **Agentic Research Feature**: The tool can independently discover and suggest web sources, integrate them into the notebook with permission while maintaining full attribution. Users start with loose ideas and imperfectly organized material – Notebook LM helps structure the research foundation.

  **Source Attribution**: Generated reports and artifacts transparently show which sources and prompts were used.

  The feature initially rolls out to Google AI Ultra subscribers but should soon come to all paid plans. Speculation suggests future integration of Gemini’s new Omni video models.

  Notebook LM (Google / Gemini 3.5 Flash), demo/opinion.

• How to Build 24/7 Claude Agents! EASILY!
  15.6.2026, 06:00:18

  # Summary: 24/7 AI Agents with Base 44 Super Agents

  The video shows how to build automated AI workflows without coding using **Base 44 Super Agents** and run them 24/7 in the cloud. The main problem with previous approaches: manual coding, constant integration of various tools, and the need to keep local hardware running continuously.

  Super Agents instead offers managed infrastructure, secure defaults, and pre-configured integrations (Gmail, Google Calendar, Slack, Stripe, CRMs, 100+ others). Instead of monolithic automations, you can define multiple specialized agents with clear roles and automatically chain their outputs into the next step.

  As a demonstration, a workflow for daily AI news automation is built: a first agent researches current topics daily at 9 AM ET, evaluates credibility, and provides sources. A second agent converts the research into a video script with intros, segments, and CTAs. A third generates a PDF report and sends everything via Gmail. The entire process runs automatically without user input. The platform also allows voice prompts, file uploads, and direct chat-based agent definition. Even on the free tier, complete automation works in minutes rather than hours of manual work.

  **Base 44 Super Agents, models via auto-routing (Gemini 3.1 Pro, Sonnet 4.6, GPT 5.4, upgradeable to Opus 4.8 or GPT 5.5) — Tutorial/Demo**

• Kimi K2.7 Code: BEST Open Source Model? REALLY Cheap and Beats Opus 4.8 and GPT 5.5? (Fully Tested)
  17.6.2026, 06:30:29

  # Summary: Moonshot AI Kimi K 2.7 Code

  Moonshot AI has released the open language model Kimi K 2.7 Code – a mixture-of-experts model with roughly one billion parameters, specialized in code generation, code understanding, agentic programming, and developer tool integration. The model improves instruction following by about 30% compared to K 2.6, reduces “overthinking,” and performs better in long-context coding workflows. According to benchmarks, Kimi K 2.7 scores very strongly on Aero’s Smoke Test, but according to the speaker’s own assessment, it’s not really comparable to frontier models like Claude 5 or GPT-4o in practical applications – some benchmarks favor Kimi’s strengths.

  The weakness: context length stagnates at 262K tokens (only marginally above the 256K of its predecessor) – disappointing for a 1-trillion-parameter model in 2025. Price-wise, the model costs 19 cents per million input tokens (cache hit) or 95 cents (cache miss); output tokens cost 4 dollars per million. Token efficiency is worse than K 2.6, so the model consumes more tokens per task. A faster variant was just announced that should reach 180 tokens/second.

  In demos, the model generates solid frontend code (SaaS landing pages with GSAP animations), SVG graphics, and MacOS clones with functional UI elements. In direct comparison with Claude Opus 4.8 Max on a coding benchmark: Kimi was cheaper ($17 vs. $145), slower (6 vs. 5 minutes), and visually less polished. In web development, Kimi K 2.7 now seriously competes with Opus and GPT-5.5, though these still have the edge. Conclusion: The model is one of the most important open-source code models – cheap, multimodal, agent-capable, and surprisingly competitive for its price.

  **Format & Context:** News update on Moonshot Kimi K 2.7 with live demos and benchmarks against proprietary models (Claude Opus, GPT).

• Fable 5 COMING BACK! Deepseek v4.1, GPT-5.6 Leaks, Fusion API, & Kimi K2.7 Code High Speed! AI NEWS!
  16.6.2026, 06:30:08

  # Summary

  The video overview covers several major developments in the AI industry:

  **Fable 5 & Mythos 5 Ban:** The US government imposed export control directives against Anthropic’s models due to alleged national security concerns – specifically the fear they could be misused to discover software vulnerabilities. Amazon researchers reportedly found a security flaw and reported it to authorities, leading to worldwide blocking. Anthropic argues the concerns are overblown. Senior Anthropic staff are already in Washington negotiating with the Trump administration; a comeback with tightened controls is expected later this month.

  **GPT-5.6 Leak:** OpenAI might launch GPT-5.6 this week (Thursday) or next week – with 1.5 million token context, cheaper prices, and strong agentic coding. Poly Market puts 86% probability on a release this month. Timing could lure Fable users back to OpenAI.

  **Nex N2 Pro & Rio 3.5 Scandal:** Nex N2 Pro (open-source from China) showed impressive agentic coding capabilities. Shortly after, Brazil claimed Rio 3.5 Open surpassed other models – researchers discovered Rio 3.5 was merely linear interpolation of Nex N2 Pro and Qwen 3.5. The authors initially claimed they’d uploaded the wrong file.

  **Kimi K 2.7 Code:** Moonshot released this new open-source coding version with 21.8% improvement over K 2.6, better long-horizon workflows, and 30% fewer reasoning tokens. A high-speed variant reaches up to 260 tokens/second.

  **Other Updates:** Anthropic could be valued at up to $1.75 trillion; Deepseek 4.1 might come before the Dragon Boat Festival (June 19th); Qwen iterates rapidly with new Plus versions; China presented Blackbox, an AI-driven robot for fully automated lab work without human intervention.

  **Open Router Fusion API:** A system that runs multiple cheaper models in parallel and synthesizes their answers – claims to be cheaper than GPT-5.5/Claude Opus 4.8 with similar performance.

  Video covers Claude/Anthropic (Fable, Mythos), OpenAI (GPT-5.6), Deepseek, Qwen, Nex, Mistral, Moonshot/Kimi, and various open-source models; format: news update/roundup.

---

Automatically generated from the latest YouTube videos of the curated channel selection. For feedback, suggestions, or to unsubscribe: simply reply to this email.