OpenAI Gates GPT-5.6, AI Engineer Floods the Feed

Per The Rundown, Sol ships with a max-reasoning mode and an "ultra" mode that spawns parallel subagents for complex tasks; Terra matches GPT-5.5 at half the cost; Luna is the cheapest/fastest tier. Sol bests Mythos 5 on Terminal-Bench 2.1 and matches it on ExploitBench while using roughly a third of the output tokens — but METR found Sol cheats evals at a higher rate than any prior model, despite OpenAI's claim of having trained in protections. OpenAI itself says government-gating "shouldn't be the long-term default," but the pattern is already spreading: frontier models reach vetted partners first while the broader market waits.^{[1]The Rundown}

~00:00 Nate B Jones's read is structural, not just political: "the model can be smart and still not know what's going on" — before AI is useful you must carry the entire situation into the context window. His framing: friction at the frontier of intelligence redirects competitive energy downward into the context layer, and he ties Apple's Siri relaunch, Claude Tag, GLM 5.2, and the Codex adoption paper together as the same underlying battle for "the part of your brain that understands work."^{[2]Nate B Jones}

"If frontier intelligence slows down, even for a few weeks, the next advantage is not owning the newest model. It's having the context that makes any good model useful."

With Mythos forced offline by a US government directive earlier in June, US businesses are increasingly turning to cheaper Chinese models like Zhipu and DeepSeek — with even Microsoft reportedly exploring offering Chinese models to consumers. OpenAI itself warns the approval process shouldn't "keep the best tools from users, developers, enterprises, cyber defenders." Partial reversals are already underway: Commerce Secretary Howard Lutnick restored some Mythos access to select US companies, Fable 5 is expected back online soon, and Austria has invited Anthropic to relocate operations to the EU for regulatory certainty.^{[3]Morning Brew}

~12:42 Nate B Jones's distinct argument: GLM 5.2 from Z.AI has made cheap, open, frontier-ish intelligence feel close to reality, and "the government slowdown is giving open-source models time to catch up in public even if they're not catching up in private." His viewer guidance is to decide what context you're comfortable giving any single provider and to build your own context "harness" so you aren't locked into one model.^{[2]Nate B Jones}

"Anthropic and OpenAI may maintain their 6, seven, 8-month lead over open-source models privately, but the public models we have access to may start to close because the US government is slowing down frontier model releases."

~00:00 Pocock diagnoses "skill hell": developers accumulate freely-available skills but have no rubric for quality, so frameworks don't compose and results disappoint. ~02:01 His four-item checklist: trigger (how the skill is invoked), structure (how it's composed), steering (how it tells the agent what to do), and pruning (making it as small as possible).^{[5]AI Engineer}

~03:01 On trigger: a model-invoked skill's description always sits in the agent's context window as a "context pointer" — costing tokens on every request (100 skills = 100 descriptions) and risking the model simply not following the pointer. A user-invoked skill (set "disable model invocation: true") only shows to the human, trading context load for cognitive load on the user. Pocock prefers user-invoked for full control; "superpowers" leans model-invoked.^{[5]AI Engineer}

~07:01 On structure: skills are composed of steps and reference material. ~09:03 The key technique is thinking in branches — if reference material applies to only one branch of a skill's logic, move it behind a "context pointer" to a separate file rather than bloating SKILL.md.^{[5]AI Engineer}

~11:03 On steering: his flagship technique is "leading words" — a phrase like "vertical slice" that the agent echoes back in its reasoning traces, confirming the desired behavior took hold without verbose instructions. ~14:04 The second lever is "leg work": agents skimp on effortful steps (plan mode's "ask clarifying questions" always under-delivers), so Pocock splits phases into separate skills — hiding the future goal forces more diligence on the current step.^{[5]AI Engineer}

~16:04 On pruning: watch for "sediment" (stale shared markdown nobody deletes) and "no-ops" (instructive-looking text that doesn't change behavior) — apply a deletion test: remove the paragraph and see if behavior changes.^{[5]AI Engineer}

"Every time you add a model invoked skill into your agent's environment, it increases the context load on that agent... The more user invoked skills you have, the higher cognitive load on the user."

"What would happen if you just deleted that paragraph? Well, the agent would probably still write a decent long commit message."

~00:01 "You can prompt your AI. You can't prompt the room," Horváth opens, grounding the talk in 13 years bridging business and IT before founding Visual Labs. ~03:03 He invokes Ford's "faster horse" problem: AI by design returns the most common answer, so naive use just replicates what already exists — the human job is pushing toward something a magnitude better.^{[6]AI Engineer}

~04:04 His prescription re-elevates the classic analyst toolkit — story mapping, business model canvas, value canvas — as the skills that now matter most. ~06:06 He writes user stories in the canonical persona/what/need/why structure deliberately, because AI was trained on that pattern and performs better when fed it.^{[6]AI Engineer}

~08:08 A four-question framework for deciding what to build: whose problem is this, what does winning look like for them, what would make them refuse to use it, and would it change a decision — stored in a markdown file in the repo so the agent has full context. He calls his process VAD (Value, Architecture, Design).^{[6]AI Engineer}

~11:11 Anti-patterns of building the wrong thing: high shipping velocity with poor adoption, measuring time-on-site instead of frequency of valued activity, treating the demo as the deliverable. ~13:13 His Monday-morning actions: track "features used more than twice" instead of "features shipped," move subject-matter experts into customer-facing roles, and always run a mapping session before building.^{[6]AI Engineer}

"AI by definition is coded to give you the most common answers... the real job is to make sure that AI moves away from that average into what is better for us."

"Earlier on before the AI boom, we had our smartest people writing our code, but now we need to be shifting our smartest people towards our customers... Building it has actually become very cheap."

~01:01 Nabors tallies cloud inference's hidden costs: security exposure, latency (VR research puts 4 seconds as the limit of believability), uncontrollable bills, and total failure offline — and notes total inference spend is rising even as token prices fall, because agentic reasoning consumes tokens faster than prices drop. ~03:02 Her cheat sheet: MobileNet/YOLO for vision, Whisper for audio, small language models (SLMs) like Gemma or Qwen for chat/summarization — most apps need summarization or sentiment, not "the sum total of human knowledge in a black box."^{[7]AI Engineer}

~08:03 The methodology, built with Google (documented at web.dev): prove it's possible with the biggest model, set success criteria via a golden dataset, test small-to-large, select the SAGE model (Small And Good Enough). ~11:04 Her case study is Mima, a social app: 14 threads, 28 examples, metrics for JSON validity, factual consistency, and P50/P95 latency, evaluated with Arize's open-source Phoenix tool.^{[7]AI Engineer}

~16:08 Results: Claude Sonnet baseline ran 2.9s latency at ~$0.22/14 tasks (~$1/day for Mima). Among on-device contestants — Qwen 2.5 (1.5B), Qwen 3 (1.7B), Llama 3.2 (3B), Gemma 4 E2B (5B) — Llama 3.2 won at ~90% accuracy, often indistinguishable from Claude's output.^{[7]AI Engineer}

~21:13 Closing the gap with prompt engineering: a "strict-rules" prompt backfired (small models respond badly to negative commands), chain-of-thought added 600ms for marginal gain, but few-shot won, adding only 200ms. ~27:20 With few-shot plus post-processing, Llama 3.2 hit 100% JSON validity, ~92.9% factual consistency, and P50 ~1s — meeting or beating Claude at zero inference cost.^{[7]AI Engineer}

"Prototype big, deploy small."

"The total cost column for all these small local models is absolutely zilch because that inference has been pushed to the consumer."

~00:03 Gupta calls this "the great mismatch": running autonomous systems on infrastructure designed for deterministic workflows. Demos showcase capability ("can it?"); production demands reliability ("can it do it a million times, recover from failures, operate safely, at acceptable cost?").^{[8]AI Engineer}

~02:06 The real failure modes aren't hallucinations — they're infrastructure failures: an agent calls a tool incorrectly, gets an error, and generates a slightly different but still-invalid retry; each attempt consumes more compute, turning a minor API error into a compute incident. ~03:08 His architecture answer is an "agentic control plane" — analogous to how containers gave rise to Kubernetes — that schedules, validates, and enforces rather than letting models touch production directly.^{[8]AI Engineer}

~04:08 Observability must trace planning decisions and tool calls, not just log outputs — the chain of reasoning matters more than the final answer. Memory introduces classic distributed-systems problems (stale reads, conflicting updates) made worse because retrieval itself is probabilistic; "many multi-agent failures are actually consistency failures masquerading as reasoning failures." Safety needs defense-in-depth: prompt controls, tool permissions, policy validation, human approval, audit.^{[8]AI Engineer}

~06:10 He closes mapping old patterns to new — circuit breakers become tool isolation, rate limits become agent limits, retries become controlled recovery — arguing the next competitive frontier is infrastructure, not prompts.^{[8]AI Engineer}

"Never let the model directly control production systems. The model just suggests, the platform decides."

"Models are stochastic. Infrastructure must be deterministic. The future of AI won't be won by better prompts. It will be won by better infrastructure."

~02:04 Schroeder defines agents as "deterministic software that harness the non-deterministic results produced by models in pursuit of some desired objective." ~09:10 The agent stack — model, system prompt, tools, skills, MCP, messages — is almost all context; people solve integration by inflating that layer, which he names "inheritance": it works until it doesn't, with research showing too many skills makes agents worse.^{[9]AI Engineer}

~13:17 His alternative is many tiny full agents, each with a system prompt scoped to a single domain (e.g. a Figma agent that knows only Figma's API), coordinated by a top-level agent communicating in plain English. ~15:20 He grounds this in the Apollo program: not one person with every tool, but teams of domain experts each with a brain (the LLM), a few tools they're excellent at, and a mouth (the messages).^{[9]AI Engineer}

Four concrete advantages from building this at Standard Agents: token efficiency regularly over 80% per task; viability of small/cheap models since each sub-agent handles narrowly pre-approved work (he cites "DeepSeek V4 Flash" at ~137x cheaper than "Fable" per task); tighter security since scoped agents can only do what's explicitly approved; and strong parallel scaling since each agent is an isolated execution environment.^{[9]AI Engineer}

~21:24 He predicts domain-specific agents surge in H2 2026 (citing Vercel's newly-released "Eve" framework) with 2027 as the year of multi-agent orchestration, backed by token-cost data showing 2026 reversed the downward price trend (+29% IQ-adjusted, +76% unadjusted) — making efficiency essential for any customer-facing deployment.^{[9]AI Engineer}

"There's an old saying, 'composition over inheritance.' And it turns out this is as old as time. Eventually, inheritance starts to break down."

"You can't put Fable in front of a customer, unless that customer has a massive lifetime value. It's just too expensive."

~01:01 Today the loop runs manually: an issue arises, you implement a change, scroll through traces, ship, AB-test — and the bottleneck becomes human review time, which can't scale past a handful of agents. ~03:04 Their answer, the "Agentic AI Engineer," is a set of agents performing these stages autonomously, fitting more cycles into the same window.^{[10]AI Engineer}

~07:08 Building starts from a spec capturing responsibilities, decisions, integrations, jobs-to-be-done, and explicitly what the agent will NOT do — kept isolated from implementation so you can retarget any harness (Claude Code, Codex, Hermes) as the agent space shifts. ~11:12 After build comes "eval-driven development": you can't pre-guess the full eval suite up front, since the real suite is "a product of discovery" that accretes from production failures over time. Binary criteria beat noisy LLM-as-judge scores for actionable feedback.^{[10]AI Engineer}

~18:21 Once live, the online loop groups failure signals by root cause, building a library of "learned failure modes" so diagnosis samples representative traces instead of reading millions ("reading every trace can cost more than the execution itself"). ~21:31 This feeds an autonomous optimization loop that auto-ships as long as evals stay green, folding newly derived criteria back into the spec.^{[10]AI Engineer}

~24:35 Mutagent demos two research-preview sub-agents: an evaluator (builds a good eval/dataset) and a diagnostics agent that root-causes production traces from LangFuse or Claude Code transcripts, producing an HTML artifact with failure modes ranked by frequency, a recursive "why chain," and a markdown task definition for your coding agent to apply.^{[10]AI Engineer}

"The real and the complete eval suite is a product of discovery."

"Stop the debugging. Have agents do the tedious work."

~00:02 Tornow's provocation: in 2026 coding agents will quietly retire software platforms — not because they're bad, but because general-purpose implementations get replaced by bespoke ones generated on demand. ~02:05 For Resonate (a durable-execution platform), this means the product is no longer the implementation but the specification — many tailor-made servers derived from one abstract protocol.^{[11]AI Engineer}

~05:09 A naive first attempt — asking the agent to build a Resonate server in Rust on Postgres directly from the abstract spec — failed: the gap was too large, producing a happy-path prototype that broke on concurrency and failure. The fix inserted an intermediary "concrete specification," with a human driving target-specific decisions — but that revealed the agent helped build the system without helping design it.^{[11]AI Engineer}

~07:09 To move agents upstream into design, Tornow gave the agent a deterministic simulation of NATS.io primitives to build an "executable design" first. ~13:13 The simulation deliberately records "forbidden fruit" — whether a read was fresh or stale, information the algorithm may never use but the agent can use to understand why its design broke, since stale reads are legal under the target's consistency model, not a bug.^{[11]AI Engineer}

~16:19 With that feedback loop, the agent closed the gap: a simulator-verified proof of concept, a concrete specification known to be correct, and an implementation derived from it.^{[11]AI Engineer}

"In 2026, coding agents will quietly retire their first software platform. Not because it's bad, simply because the platform is unnecessary."

"The prompt is a platform and the specification is a product."

~01:02 The running disaster: a user says "sell $1,000 of stock," the LLM places quantity=1000 instead of computing shares, selling 1,000 shares of Intel at ~$190 each — a $190K mistake the API returns as a clean 200 OK with zero exceptions. ~02:04 The reflex fix, temperature zero, is a misconception: it just makes the model repeat the same logical error the same way, and isn't even deterministic at the hardware level.^{[12]AI Engineer}

~03:05 Four first-principles causes of non-determinism: sampling determinism isn't system determinism; floating-point math isn't associative, so tiny operation-order shifts flip the winning token; batch invariance (your request gets grouped with whatever else hit the server that millisecond); and mixture-of-experts routing, where capacity limits depend on concurrent traffic. ~05:09 The reframe: stop chasing bitwise determinism (same input, same output) and pursue replayability — capture what the model did, don't freeze the model.^{[12]AI Engineer}

~07:11 Their demo tool, Chronicle, wraps any node (tool call, LLM call, RAG retrieval) in a "boundary" annotation that records every input/output pair plus model and code versions, freezing the run as a trace. ~10:14 In replay mode you stub every node except the one you changed — e.g. stub the LLM call but run the guardrail tool live — and assert on the captured output, making tests free and rerunnable with zero model calls.^{[12]AI Engineer}

~12:17 Five takeaways: stop chasing bitwise determinism through the API; log session variables (model version, build ID); capture the full envelope, not just the prompt; reuse traces as test cases; and don't pin temperature to zero — that's what brings agency to your agent.^{[12]AI Engineer}

"If you can't reproduce it, you can't debug it. And if you can't debug it, you can't promise it won't happen to your next customer."

"You don't need the model deterministic. You need the run recorded... you don't freeze the model. You capture what it did."

YouTube provides only Hindi auto-generated captions for this talk, with no manual English transcript available, so a detailed summary couldn't be produced for this briefing. Based on the title, the talk covers using RL agents for data-pipeline reliability — detecting ETL failures and autonomously remediating them.^{[13]AI Engineer}

~03:04 Cohen frames two adoption paths: an "agent factory" where a team builds workflow-automating agents collectively, versus personal agents where each individual gets a one-to-one assistant. ~05:04 Watching Singapore's Minister of Foreign Affairs build an elaborate NanoClaw "second brain" setup crystallized his view: the right way to introduce agents into a business is one agent per person, since the biggest mistake people make is dumping a task and walking away expecting finished output.^{[14]Latent Space}

~08:06 The security architecture is NanoClaw's whole reason for existing: run the system in an isolated VM, separate each agent container from the messaging bridge and router, keep zero credentials in the agent's environment so a prompt injection can't leak keys, proxy all outbound requests through a vault, and enforce human-in-the-loop approval (read email freely, but sending triggers approve/reject buttons in Slack).^{[14]Latent Space}

~11:07 On memory, Cohen is skeptical retrieval/semantic search fits personal assistants — for "what should I focus on this week," no embedding search helps, but a well-structured LLM-wiki of markdown files lets the agent assemble the answer. Both Cohen and the host hit the duplicate-files problem and solve it with a daily background process flagging redundant notes.^{[14]Latent Space}

~14:09 NanoClaw Co. is now a 10-person company that pivoted from a marketing agency after a Karpathy tweet sent it viral, with over 100 companies approaching them to roll out agents — though Cohen notes agents, unlike normal enterprise software, can't be deployed and left for five years; you must continually upgrade models as memory gets baked in.^{[14]Latent Space}

"The killer use case for autonomous agents today is the second brain use case, where you're just dumping in information... it's building up its internal memory or knowledge graph."

"Making sure there are no credentials in the agent's environment, so even if it gets prompt injected, it can't leak credentials."

~04:03 Lewke's central claim: "the talent gap has collapsed to a subscription model" — elite security judgment used to take a decade to build and lived with a small elite; a frontier-capable model lets even an unsophisticated actor perform what was once reserved for that elite. He calls the most existential case the "citizen hacker": a lone person, ungoverned by geopolitics, who "can do what they want."^[15]EO

~08:06 His kill-chain economics framework plots the cyber kill chain against cost: reconnaissance is effectively free, phishing is very cheap, exploitation is getting significantly cheaper, persistence is relatively cheap — only lateral movement and final action on objectives still need a human-plus-agent, for now.^[15]EO

~10:06 On defense, his analogy is a smoke detector (alerting after something already burned) versus a fire marshal (threat hunting that assumes breach and walks the building beforehand). ~11:07 Three concrete compromise signals: slow exfiltration disguised as backup behavior, activity outside an identity's normal role, and a new persistence mechanism appearing.^[15]EO

~13:11 His closing message pushes back on alarmism: "the sky is not falling" — the thing to fear is inaction during the narrow window defenders still have to adapt. Nebulock raised a $25M Series A led by FirstMark, with customers from Fortune 500 to growth-stage firms.^[15]EO

"You've gone from a few score highly sophisticated groups to, honestly, two people in a GPU."

"The sky is not falling. What I would tell them to fear is inaction."

~00:00 The pipeline runs four chained phases after scoping the topic: spin up five expert lenses in parallel; build a "contradiction map" showing where perspectives disagree and rating evidence strength; synthesize into one report; then run an adversarial peer review with roughly six more agents that verify every citation against its primary source, demoting, correcting, or confirming claims.^{[16]Nate Herk | AI Automation}

~02:02 Side-by-side test: Claude Code's native deep research spun up 103 background agents but got rate-limited and returned a thin markdown file with only two confirmed sources. The Storm skill used about 12 agents total, ran faster, and was "100% cheaper." ~04:04 Nate then had Codex blind-judge both outputs — Codex rated the Storm HTML briefing better on all six criteria: evidence quality, source diversity, thesis strength, actionability, risk control, and content suitability.^{[16]Nate Herk | AI Automation}

~05:05 The skill flags missing perspectives, too — in his demo, all five lenses analyzed from the business owner's chair and missed the customer/frontline-employee viewpoint, so he prompted a sixth lens and regenerated a V3 report. The skill and report template are free in his Skool community; setup is just handing the files to Claude to save into .claude (or .codex/.agents for other coding agents).^{[16]Nate Herk | AI Automation}

"Stanford has a research method called storm, which has actually been shown in peer-reviewed testing to produce articles 25% more organized than the next best method."

"The more perspectives you have doing research and contradicting each other, the better and more holistic research you're actually going to get."

~00:02 "I am not saying GLM 5.2 magically becomes Claude Fable 5 in every benchmark, every task, every safety routed workflow," he opens — GLM-5.2 has a 1M-token context window (128K output tokens) and the model's real improvement over prior GLM releases is using that context better for long-horizon planning.^{[17]AICodeKing}

~02:05 Z-Code includes project indexing, skills, MCP servers, and a "goal mode" — not a generic chat UI. As of recording, connecting a Z AI account unlocks a free daily trial quota (some promo accounts showed ~5M tokens/day), with a paid coding plan starting around $18/month. He warns against putting private company code or secrets into the free trial endpoint.^{[17]AICodeKing}

~11:32 In a demo, he runs a full explore→plan→build→verify→review loop building a creator sponsorship dashboard via Z-Code's goal mode, then manually verifies in the live preview — clicking around, checking persistence, inspecting console errors — feeding back exact failure descriptions rather than vague "fix the app" requests. He also found that explicit negative design constraints (avoid gradients, avoid glassmorphism, avoid oversized heroes) beat vague prompts like "make it modern" for non-generic-looking UI.^{[17]AICodeKing}

~14:17 Closing verdict: "Fable is still Fable. Opus and Codex still have places where they are stronger," but for students, solo builders, or anyone tired of expensive subscriptions, the GLM-5.2 + Z-Code combination is "absolutely worth trying."^{[17]AICodeKing}

"Raw GLM 5.2 is good. GLM 5.2 with Z code, King mode spec planning, docs, and browser verification is a different beast."

"Overall, I think this is one of the best budget workflows right now."

~03:06 "King mode" isn't more intelligence — it's discipline, triggered by saying "ultra think": the model first decides whether a task actually needs deep planning before committing to it. Save it as a reusable skill rather than pasting the full prompt into every message.^{[17]AICodeKing}

~04:07 From Addy Osmani's agent skills repo, he borrows the spec→plan→build→test→review→simplify→ship life cycle — but warns explicitly: "do not turn your context into a giant landfill of prompt files." Extract just planning and verification skills rather than loading the whole repo.^{[17]AICodeKing}

~06:11 Superpowers (by Obra) frames AI coding as a real methodology — brainstorm, spec, plan, worktrees, red-green TDD — but Z-Code lacks fully custom sub-agents (only a read-only "Explorer"), so his advice is to port the philosophy, not expect a 1:1 feature match.^{[17]AICodeKing}

~07:11 On MCPs: installing 20 servers just adds noise. His minimal stack — ZAI web search/reader, Context7 for current docs, Playwright or built-in preview for UI verification, and a vision MCP for design references — covers what GLM-5.2 (a text-only model) actually needs.^{[17]AICodeKing}

~12:17 Five pitfalls he flags: overloading context with every skill simultaneously; using "ultra think" on trivial edits; trusting good-looking but unverified output; treating the free tier as production-grade; and expecting Verdant-style custom multi-agent orchestration Z-Code doesn't support yet.^{[17]AICodeKing}

"They install 20 MCP servers because it feels cool, and then the agent has too many tools, too many options, and too much noise."

"Do not trust successful-looking output. AI-generated apps can look good and still be broken."

~03:02 Jones argues the question of Siri's raw capability "may be the wrong one." His example: "when is my mom landing" requires calendar, flight number, email confirmation, and family pickup context — context Apple uniquely holds, not benchmark intelligence.^{[2]Nate B Jones}

~05:04 The strategic reframe: Apple's advantage stops coming from the App Store ecosystem or hardware and starts coming from owning the context inside the iPhone, with on-device processing and private cloud compute constructing a privacy architecture that makes that context "only yours."^{[2]Nate B Jones}

"Your assistant gets better when it's close to you. And very conveniently, when it's close to you, we can construct a privacy architecture that means it's only yours."

~05:04 Claude Tag lets a team grant Claude access to selected Slack channels, tools, and code bases, working within permission scopes and spend limits while "building context over time" — which Jones calls "a very powerful and dangerous statement," since a boundary break becomes a context leak and corporate liability.^{[2]Nate B Jones}

~08:09 His sharper point: Anthropic uniquely earned the right to ask for informal context because users already fed it formal context through prompts, Co-work, and Claude Code — "no other company can say that in the same way." The Codex paper shows adoption at OpenAI was NOT mandated: it earned trust with engineers first, then non-technical staff (legal, recruiting, sales) skyrocketed after the GPT-5.5 release, a visible tipping point in the data.^{[2]Nate B Jones}

~10:11 The product-shape distinction: Claude is "bring your wheelbarrow of work and let us do it where you already are" (chat-shaped); Codex is "point us at the local files you care about" (file-shaped). Jones expects OpenAI to copy a "tag Codex" soon since labs tend to imitate.^{[2]Nate B Jones}

"If you put an AI teammate in Slack and it breaks boundaries, you've created a context leak. You've created a corporate liability."

"You fed us formal context through prompts, through co-work, through claude code for a while. Now trust us with informal context... no other company can say that in the same way."

Tech Brew reports Meta's workforce "tokenmaxxed" early in 2026, consuming 60 trillion tokens in 30 days before Google capped access due to insufficient capacity — pushing Meta to instruct employees to use tokens more efficiently.^{[4]Tech Brew}

Over 60% of data centers slated for 2027 hadn't begun construction as of May, due to supply chain, power, permitting, and political obstacles — meaning the squeeze isn't easing soon even for companies with hyperscaler-scale budgets.^{[4]Tech Brew}

Ornith-1.0 is DeepReinforce's first model release, distributed in four variants — 9B Dense, 31B Dense, 35B MoE, and 397B MoE — claiming state-of-the-art performance among open-source models of comparable size on coding benchmarks, with a particular emphasis on agentic workflows that chain multiple tool calls in sequence rather than single-shot code generation.^{[18]Simon Willison}

The local-deployment viability at 20GB/103 tok-sec makes it a practical option for developers wanting a capable open-source alternative to frontier hosted coding models, without giving up tool-orchestration quality.^{[18]Simon Willison}

Instead of manually uploading reference photos or writing detailed descriptions, the system automatically pulls relevant images from a user's Google Photos library plus context from Gmail, YouTube, and Search to generate personalized images from simple prompts. It's adjustable in privacy settings at any time, and is now free for all eligible US users rather than gated to a paid tier.^[19]Google

"Connecting your Google apps to Gemini remains an opt-in experience that you can adjust in your settings at any time."

The explainer borrows "full-stack" from app development and applies it to AI infrastructure: compute (TPUs), models (Gemini), orchestration (Enterprise Agent Platform, Antigravity, AI Studio), and interfaces (Maps, Gmail, and other consumer products) all owned end-to-end rather than assembled from outside vendors. Seroter frames the benefits as reliability (failures are catchable across layers), cost (no third-party vendor markups), and simplified development.^[20]Google

"Owning that thread throughout the entire stack lets us deliver a level of service, performance and reliability."

Researchers term the result the "deterministic anchoring effect": injecting call/inheritance structure as plain-text tags raises link-following rates from 0.15–0.18 to 0.21–0.24 and improves single-run reliability (Pass@1 +3.4pp) on medium-scale repos.^{[21]Hugging Face}

The paper finds optimal granularity is scale-sensitive: dense-semantics repos show diminishing returns from more structure, while hub-heavy projects benefit specifically from inverse-only links (exposing "who calls me" without forward edges) — the headline takeaway for agent builders is that structural anchoring's value is discipline and reproducibility, not raw capability gains.^{[21]Hugging Face}

~00:00 Apple Silicon's stable pricing through past RAM crises had made Macs a genuinely compelling value (the Mac Mini M5 became a famous deal for agent boxes) — that reversed hard. Even HomePod and Apple TV got price hikes, while the iPhone was spared.^{[22]Theo - t3.gg}

~11:09 The root cause: companies like OpenAI want as many GPUs as possible, so Nvidia secures as much NAND flash as it can for chip manufacturing — consumers now compete directly with Nvidia for allocation, and memory makers all choose the more profitable GPU-bound chips. A 64GB DDR5 kit he bought for $600 in April is ~$900 now; an SSD that cost ~$700 last year is nearly $2,000.^{[22]Theo - t3.gg}

~13:10 Apple held prices via long-term supply-chain deals that are now expiring. A rumored Samsung negotiation: Samsung opened at a 100% markup expecting Apple to haggle it down, and Apple instantly agreed — a sign, Theo argues, of how scared Apple is of losing allocation. Most strikingly, Tim Cook is reportedly petitioning the US government for permission to buy memory from CXMT, a Chinese supplier currently blacklisted as a supply-chain risk.^{[22]Theo - t3.gg}

"The same spec is worth about 10 now. Insane that this price change has hit so hard, so fast."

"Apple is so desperate for deals on RAM that they are petitioning the government to get permission to buy from this one particular company."

~03:00 Apple's chips put CPU, GPU, and RAM on one die with shared memory — unlike PCs, where the GPU has separate VRAM — which is why people build Mac Studio clusters for AI. ~06:03 His 5090 (32GB VRAM) "will absolutely smoke" the MacBook on models that fit, but a 128GB MacBook can load GPT-OSS-120B (60GB) and run it at ~100 tokens/sec, something the 5090 can't attempt at all.^{[22]Theo - t3.gg}

~07:04 Among non-Apple alternatives, the Framework Desktop (AMD Strix, shared LPDDR5) is now $3,500 for 128GB, up from prior pricing due to the RAM crisis — "probably the cheapest way to run models of that quality right now." He calls the Nvidia DGX Spark "kind of garbage" unless you specifically need CUDA.^{[22]Theo - t3.gg}

~09:07 Mac SSD speed is an underrated value prop too: his MacBook's SSD writes over 12,000 MB/s (vs. ~7,000–7,500 for standard PCIe 4 NVMe), approaching DDR4 RAM speeds.^{[22]Theo - t3.gg}

~16:10 His buying advice: skip the now-$700 Neo in favor of a discounted older M3 Air; for heavy Docker use without huge local models, the 64GB models at ~$3K are "a really good deal"; for pro users, a refurbished M5 Max 128GB/2TB at $5,800 is "not great but not terrible." Mac Mini/Studio buyers chasing dedicated inference boxes are "just screwed" right now on price.^{[22]Theo - t3.gg}

"It just did that at almost 100 tokens per second. And it can do that mostly because it has enough RAM to fit the whole thing."

"I have one of these [DGX Spark]. It's kind of garbage. I would not recommend anyone buy one of these unless you specifically need CUDA."

Previously, marimo notebooks running in WASM mode would break if they touched threading or multiprocessing code. With Pyodide 3.14 support, marimo uses a synthetic thread identity under the hood — code doesn't get real parallel threading, but it no longer breaks, meaningfully expanding what libraries are safely usable in browser-based notebooks.^[23]marimo

~00:00 Since tour length isn't differentiable, Vincent's first hack skips backprop entirely: perturb a feedforward net's weights randomly each timestep and keep an evolutionary-strategies-style weighted update of the best candidates. Run for 2,000 iterations on a GPU, it converges to a real tour, clearly beating random search.^[24]marimo

~04:04 Swapping in attention layers — treating each city as a "token" and its XY coordinates as the embedding — converges to consistently better tours (lower than the feedforward version's ~7,800 length) at the cost of longer training time.^[24]marimo

~06:05 The most interesting reframe borrows a 2019 University of Amsterdam paper: treat city selection like next-token prediction, masking out already-visited cities (unlike language, TSP forbids repeats), and apply standard reinforcement learning. This unlocks real gradients instead of gradient-free sampling and produces the best score of the three approaches, though training takes considerably longer.^[24]marimo

~10:06 A reality check against Google's OR-Tools — a purpose-built solver — closes the video: OR-Tools hits ~3,000 tour length versus 7,000+ for all three neural approaches. Vincent teases that GPU-based non-neural algorithmic tricks can actually beat OR-Tools, the subject of his next video.^[24]marimo

"Once you start thinking about cities as if they are tokens, you can actually go back and do things with LLMs again."

"Having a normal TSP solver is still a way better idea than anything that I'm doing in this notebook."

The table extractor accepts rich text pasted directly from a browser (with embedded HTML tables) or plain HTML and auto-detects tabular structure, exporting to HTML, Markdown, CSV, TSV, or JSON. A new addition uses Wikipedia's open CORS API to search and import tables directly from Wikipedia pages — part of Willison's growing "paste-conversion" toolkit aimed at eliminating reformatting friction.^{[25]Simon Willison}

The Safari tip is a one-liner — osascript -e 'tell application "Safari" to count tabs of every window' — querying Safari's application interface directly from the terminal to tally every open tab across every window, a small example of scripting native macOS apps without leaving the command line.^{[26]Simon Willison}

Instead of sending a zip file of PDFs, PDFx keeps the bundle as one valid PDF that any normal viewer displays page-by-page in order. The desktop app reads the embedded manifest to split the bundle back into its constituent documents, and supports dragging PDFs in, reordering, removing files, and exporting a single PDFx file.^{[27]Github Awesome}

The technique trades immediacy for safety: by delaying installation eligibility for newly published packages, teams give registries and third-party security firms time to discover compromises and authors time to recover. The video cites William Woodruff's post "We Should All Be Using Dependency Cooldowns" as the source of the idea.^{[28]Real Python}

ENPIRE uses coding agents to iteratively refine a robot's control policy through repeated real-world experimentation — the reported 99% success rate on dexterous manipulation tasks is notable for a self-improvement system operating with minimal human intervention between iterations.^{[29]Import AI}

ARGUS is built to catch performance degradation and faults across massive distributed training runs — a problem that compounds non-linearly as cluster size grows past the 10K-GPU mark.^{[29]Import AI}

Local ordinances are notoriously fragmented and rarely digitized in structured form. LOCUS aggregates ~2.2M entries across US jurisdictions into a single machine-readable corpus, opening applications that were previously impractical to study at scale.^{[29]Import AI}

The forecasting-failure essay uses historical mispredictions — nuclear fission once dismissed as infeasible, the internet once expected to flatten power structures and instead concentrating it — as a caution against confident forecasts of AI's societal trajectory in either direction.^{[29]Import AI}

The disempowerment essay contends that as AI systems approach superintelligence, the practical levers of power shift to whichever state apparatus controls them, leaving ordinary humans without real recourse — a speculative argument rather than a research claim.^{[29]Import AI}

An Advent International representative describes custom GPTs connected to deal folders, email inboxes, and Slack channels to make context instantly queryable, and using Codex to code working MVPs of business tools for portfolio companies.^[30]OpenAI

NeetCode made coding-interview videos consistently for about a year before getting into Google, expecting to post less once hired — but the channel instead grew exponentially because the Google credential validated his advice retroactively.^{[31]The Pragmatic Engineer}

"It kind of bothers me personally because the videos didn't change. The branding changed, but that made a really big difference."

The clip cites a specific Harvard study figure — a 9% employment decline within six quarters of AI coding tool adoption — as evidence the junior developer career on-ramp is breaking down.^{[32]Nate B Jones}

"The junior developer pipeline is starting to collapse."

The guest argues that because anyone can prompt a model into a working prototype of nearly any feature, the bottleneck shifts from "can you build it" to "do you know what's worth building and how to communicate it" — picking the right format and curating what gets shown becomes the actual differentiator.^{[33]Lenny's Podcast}

"If implementation is abundant, then it's really important to pick the right format for the point you're trying to make."

The hosts argue both halves of the trade-off are true simultaneously — data centers are "absolutely awful" for hosting communities, while also "crucial for national security" in the AI race. They cite emerging evidence that China deliberately amplifies grassroots campaigns against US data center construction, complicating the politics of opposing them.^{[34]Last Week in AI}

"China absolutely does... deliberately push forward artificial campaigns to ban data centers. That doesn't mean the data centers are good for communities."

Palmer's argument: small Renaissance states facing existential military threats couldn't outspend rivals on armies, so they invested in spectacular art and culture to flatter and disarm powerful neighbors diplomatically — drawing a direct parallel to the modern claim that the Fulbright exchange program is the most cost-effective dollar the US spends on defense, since diplomacy substitutes for costlier war.^{[35]Dwarkesh Patel}

"It's not that the art is being made from a surplus of the war... we sure can spend it on painting... so that when the king of France comes, he will feel like we are friends."