Reasoning

Progress in model reasoning: chain of thought, reasoning models, math and logic benchmarks and the debates around them.

585 picksRelated topicsResearch & technical reports Model releases Agents

Latest picks

201–220 of 585

Jul 17Friday

AI Chat-Group Daily (群聊日报)Jul 17, 18:23

Kimi K3 tops Frontend Code Arena, weights to open-source, early tests show brilliance and burnout

Kimi K3 hit #1 on Frontend Code Arena with 1679 points, beating Claude Fable 5's 1631 and taking six of seven frontend domains. It packs 2.8T params, 1M context, $3/$15 per million tokens, with full weights opening by July 27. Early testers got mixed results: one user's 199-yuan monthly plan produced stunning particle VJ effects from chat history, while another burned through a $40 coding plan in five hours as the model looped on a domain spelling error. Benchmark trust is shaky—GLM-5.2 scored well on paper but felt worse than 5.5 in practice. Writing style drew split reactions: less AI flavor but forced casual tone, nowhere near the natural Chinese of the old Opus 4.6. Same day, GPT-5.6's frontend taste was called 'very Claude-like,' Sol traced a deadlock only reproducible on Ubuntu, Linus told kernel devs AI is here to stay, and Schema harness pushed ARC-AGI-3 efficiency to 98.98% by making models think like physicists.

Why it matters: Kimi K3 tops Frontend Code Arena, winning 6 of 7 frontend categories with weights opening July 27 — a major domestic flagship release. The chat digest provides scores, params, pricing, and hands-on user feedback. Not scoring higher because the source is a community digest rath...

Take

Three things happened at once here: K3 beat Claude Fable 5 on Frontend Code Arena, costs about a third as much, and full weights drop by July 27. 2.8T params, 1M context, $3/$15 per million tokens—on paper, it's a strong open-source coding option.

But early testers tell a messier story. One user's 199-yuan monthly plan produced stunning particle VJ effects from chat history. Another burned through a $40 coding plan in five hours because the model kept looping on a domain spelling error. That's a real reliability gap.

Benchmark trust is also shaky. GLM-5.2 scored well on paper but felt worse than 5.5 in practice, so the group is skeptical about K3's scores until they test it themselves. Writing style got mixed reviews too: less AI flavor, but forced casual tone that doesn't match the natural Chinese of the old Opus 4.6.

I'd treat K3 as a strong frontend coding option with open weights, not a blanket closed-source killer. The post doesn't cover non-frontend tasks systematically, and the distillation question is still open.

AI HOT (Curated Pool)Jul 17, 18:00

OpenAI proposes a 'Useful Intelligence per Dollar' scorecard for the AI age

OpenAI published a CFO-oriented guide that shifts AI spend measurement from cost per token to cost per successful task. It builds a four-question framework: how much useful work gets done, what a successful task actually costs, how dependable the result is, and whether each dollar buys more work as usage scales. GPT-5.6's three tiers—Sol, Terra, Luna—are used as examples; Sol hits 72.7% on DeepSWE v1.1 vs. Claude Fable 5's 69.9%, with 36.2% lower estimated API cost. The post does not disclose specific pricing.

Why it matters: OpenAI published a CFO-facing guide that reframes AI cost from token price to a four-dimension 'useful intelligence per dollar' scorecard, with concrete comparisons across GPT-5.6 tiers and Claude Fable 5. Framework, numbers, and competitive positioning make it actionable for ...

Take

This is OpenAI talking directly to CFOs, and the message is blunt: cheap tokens don't mean cheap outcomes. A low-cost model might need more retries, more human review, and more time to get the job done right. The real number is total cost per successful task.

They frame it as "Useful Intelligence per Dollar" with four questions: how much useful work actually gets done, what each successful task costs, how dependable the results are, and whether each dollar buys more work as usage scales. GPT-5.6's three tiers get namechecked—Sol hits 72.7% on DeepSWE v1.1 vs. Claude Fable 5's 69.9%, with 36.2% lower estimated API cost. But the post doesn't disclose actual pricing or explain how that 36.2% was calculated.

I'd read this as pricing groundwork. OpenAI wants enterprises to adopt the "cost per successful task" lens before they push higher-priced models. The framework isn't new, but hearing it from the model vendor is a clear signal: don't compare our token prices to open-source—compare what gets done per dollar.

Bloomberg TechnologyJul 17, 15:01

China's Moonshot unveils new Kimi model that rivals top US AI on benchmarks, triggering a tech selloff

Moonshot AI released its next-gen Kimi model on July 17, matching or nearing OpenAI o3 and Anthropic Claude Sonnet 4.5 on benchmarks like MATH and HumanEval. The model is available for testing via the Kimi chatbot, with an API already live. Nvidia dropped over 3% premarket on the news, as markets worry about pricing pressure on US AI firms. The post doesn't disclose parameter count, training cost, or inference latency, so I'd hold off on those practical metrics.

Why it matters: Moonshot's new Kimi model benchmarks against o3 and Claude Sonnet 4.5—a domestic flagship release that policy says should be weighted equally with US labs. Bloomberg coverage plus immediate market reaction (Nvidia down >3%) form a cross-source signal. HKR all hit, but the arti...

Hacker News front pageJul 17, 05:38

Ring-Zero: Scaling Zero RL to a Trillion Parameters for Emergent Reasoning

This paper pushes Zero RL—RL with verifiable rewards and no human labels—to 1 trillion parameters. Naive scaling makes reasoning traces bloated and hard to read, so the team adds clipped importance sampling, training-inference ratio correction, and mixed-precision control to stabilize training. Three findings: 1T parameters sharply improve sample efficiency and performance ceilings; training moves from a discovery phase to a sharpening phase; the model spontaneously develops anthropomorphism, self-verification, parallel reasoning, structured formatting, and even 'context anxiety,' making hand-crafted heuristics unnecessary. Ring-2.5-1T-Zero is competitive on seven math benchmarks. They also propose a three-dimensional CoT quality framework—comprehensibility, reproducibility, efficiency—where their model shows clear advantages in structured, concise traces. The post does not disclose specific benchmark scores, training cost, or open-source plans.

Why it matters: Empirical report on trillion-parameter Zero RL, directly addressing community concerns about scaling stability. Score held at 78 because the author team isn't a known major lab and the post doesn't disclose model architecture or training cost.

Take

This one's worth a click because it takes Zero RL—training reasoning with verifiable rewards and zero human labels—to 1 trillion parameters for the first time. Most prior work stayed on small models because naive scaling makes reasoning traces bloated and messy. The team added clipped importance sampling, training-inference ratio correction, and mixed-precision control to keep things stable, then watched what happened. The model spontaneously picked up self-verification, parallel reasoning, structured formatting, and even 'context anxiety'—basically worrying it might be wrong.

I'd discount this a bit. The paper says the model is 'competitive' on seven math benchmarks but doesn't give actual scores. No training cost, no word on whether they'll open-source it. Right now it reads more like a scaling observation report than something you can benchmark against. If you're doing large-scale RL training, the stabilization tricks are worth a look. If you just want numbers, the key ones aren't here yet.

Jul 16Thursday

Hacker News front pageJul 16, 23:29

Schema harness pushes frontier models to ~99% on ARC-AGI-3 Public

Impossible Research released Schema, a harness that gets Claude Opus 4.8 and GPT-5.6 Sol to 99% and 95.35% RHAE on the ARC-AGI-3 Public set. It doesn't touch model weights. Instead, it makes models act like physicists: turn raw grid observations into an executable state program, discover the game's mechanism, and keep both in one editable program so a failed prediction can revise the state definition itself. Both scores are self-reported and not yet verified by ARC Prize. The post does not disclose inference latency or per-run cost.

Why it matters: 99% on ARC-AGI-3 is a hard number, and the method—a scheduling harness rather than a new model—has direct implications for agent design. Downside: only a project page is available, no full paper yet, so mechanism details need verification.

Take

The number is what makes you click: 99% RHAE on ARC-AGI-3 Public with Claude Opus 4.8, 95.35% with GPT-5.6 Sol. For context, Sol bare-metal scored 13.33% on Public and 7.78% on Semi-private. That gap is so large you immediately want to verify the scores.

The approach is straightforward: make models act like physicists. Schema turns raw grid observations into an executable state program—which pixels are the player, a wall, a counter—then discovers the game's mechanism and keeps both in one editable program. When a prediction fails, the model can revise its definition of what the state is, not just patch the rules.

I'd discount this a bit. Both scores are self-reported and unverified by ARC Prize. The post doesn't disclose inference latency or per-run cost, and Opus 4.8 isn't cheap to begin with—layering this harness on top likely adds up. Also, the Public set is only 25 games. Whether this generalizes to the Semi-private set is an open question.

Don't read this as "AGI solved." The more sober take: on a tiny test set, a carefully designed orchestration layer squeezed near-maximum reasoning out of already-strong models. The method is interesting, but it's a long way from reliable.

Latent SpaceJul 16, 21:30

Lila Sciences wants labs to feel like data centers, running AI-guided experiments 24/7

Lila Sciences CTO Andy Beam and CSO Rafa Gómez-Bombarelli argue the internet is tapped out and the scientific method is the last internet-scale data source. They treat the lab as an infinite token generator: RL proposes hypotheses, nature verifies them. Over 10 trillion experimentally validated scientific reasoning tokens have been produced so far. Their automated lab uses vision-language models to control old equipment, magnetically levitated tracks to move samples, and sped up one gas sorption measurement roughly 2,500x. Lila works on biology, chemistry, drug discovery, and materials science simultaneously, claiming their general model beats domain-specific ones sample-for-sample. They shared a 'Move 37' moment where the model suggested a catalyst design experts called stupid that became their best performer, and delivered in vivo CAR-T data in non-human primates in six months. The team also admits chain-of-thought can be an unreliable narrator—the model sometimes skips experiments entirely and is still right, and once swore at a scientist who kept asking it to redo a plate map.

Why it matters: Lila Sciences treats the automated lab as an infinite data generator, using RL to propose hypotheses and nature to validate them, with over 10 trillion data points produced. The narrative hits AI practitioners directly, but the content is a podcast interview without a reproduc...

Take

I clicked because Lila is treating the scientific method itself as the last internet-scale data source. Their logic is blunt: internet text is nearly exhausted, but nature can always give you a new answer to a hypothesis. So they built an automated lab—vision models controlling old equipment, magnetically levitated tracks moving samples—and sped up one gas sorption measurement roughly 2,500x, mining experimental data 24/7.

They've now accumulated over 10 trillion experimentally validated reasoning tokens. CTO Andy Beam stresses these aren't text sequences but reasoning traces backed by real experimental outcomes—data he argues exists on the internet in quantities that round to zero.

Two details I'd discount a bit. First, they claim the general model beats domain-specific ones sample-for-sample, but the post doesn't give specific tasks or comparison numbers. Second, the 'Move 37 moment'—the model proposed a catalyst design experts called stupid that became their best performer—sounds cool, but a single anecdote is hard to separate from luck.

What I actually find more interesting is the limitations they admit: chain-of-thought can be an unreliable narrator, the model sometimes skips experiments entirely and is still right, and once swore at a scientist who kept asking it to redo a plate map. That tells you controllability and interpretability get sharper in the physical world than in pure software.

They delivered in vivo CAR-T data in non-human primates in six months—if true, that's much faster than traditional timelines. But the interview doesn't mention external validation or publication, so for now this is the company's own account.

Latent SpaceJul 16, 14:18

Thinky drops Inkling: 975B-param, 41B-active multimodal open model, now the top US Apache 2.0 base

Thinky released Inkling, a 975B-total, 41B-active MoE model that handles text, image, audio, and video with a 1M-token context window. Trained on 45T tokens and licensed Apache 2.0, it landed with day-0 support from vLLM, Hugging Face, and others. The team frames it as a customizable base for future iterations, not a benchmark-chasing flagship. A 12B-active Inkling-Small preview also dropped. Independent reviewers call it the strongest US open-weight model so far, though it still trails top Chinese open and best closed models on some benchmarks.

Why it matters: Thinky's first full model launch — 975B MoE, Apache 2.0, fills a gap in the US open-source landscape. Mira Murati's team pedigree, 1M context, and native multimodal hit all three HKR axes. Held back from 90+ because we only have benchmark numbers and the team's own claims so f...

Take

This one's worth opening because Mira Murati's Thinking Machines Lab finally shipped a full model, and it's open-weight. Inkling is a 975B-total, 41B-active MoE that handles text, images, audio, and video natively, with a 1M-token context window, trained on 45T multimodal tokens under Apache 2.0. The team is upfront: this isn't a benchmark-chasing flagship — it's a customizable base model meant to be built on. A 12B-active Inkling-Small preview also dropped the same day.

Independent reviewers call it the strongest US open-weight model so far, but the post acknowledges it still trails top Chinese open models and the best closed models on some benchmarks. I'd frame it as "US open-source finally has a credible foundation" rather than a performance blowout. The thing to note is day-0 support from vLLM and Hugging Face — that's fast ecosystem uptake.

Hugging Face BlogJul 16, 01:27

Model routing is simple—until you measure real cost, not sticker price

IBM Research found that routing by model sticker price backfired in agent workloads. Across 417 AppWorld tasks, Claude Sonnet 4.6 cost $79 total vs. GPT-4.1's $155—nearly double—because Sonnet's lower cache-read pricing exploited high context reuse across steps. The post argues real cost, latency, and complexity all depend on workload-infrastructure interaction, making routing a systems optimization problem, not a classification one.

Why it matters: IBM ran 417 AppWorld tasks and found that routing by list price alone fails—Sonnet 4.6 cost $79 total while GPT-4.1 cost $155, nearly double. The core insight: when agents reuse the same context repeatedly, cache-read pricing dominates the total bill. Concrete numbers, counter...

Take

I clicked because the numbers flip a common assumption. IBM ran 417 AppWorld agent tasks and found Claude Sonnet 4.6 cost $79 total while GPT-4.1 hit $155—nearly double—even though GPT-4.1's sticker price looks competitive. The reason: agents reuse large context windows across steps, and Sonnet's cache-read pricing is much lower, so the real bill tilts hard toward the model with better caching economics.

The takeaway isn't "Sonnet beats GPT"—it's that routing by per-token price alone is broken for agent workloads. Cache hit rates, context reuse patterns, and step count dominate the final cost. The post doesn't break out latency or complexity numbers in detail, but the framework is solid. If you're building agent pipelines, benchmark your own task traces before trusting a routing table built on standalone evals.

Jul 15Wednesday

Computing Life · Share · YageJul 15, 08:00

AI Trains AI: What a Public Self-Improvement Experiment Actually Closed the Loop On

Dan Austin open-sourced a full AI-trains-AI loop. An outer Qwen3.6 agent designs post-training recipes; an inner Qwen3-0.6B or 1.7B model runs real GPU training, and hidden eval scores feed back as reward to update the outer policy. Over 54 steps, the agent first learned to reduce invalid submissions, then shifted 1.7B model usage from 42% to 95% and began tuning temperature, optimizer, and other hyperparameters. Trained small-model scores rose from noise level into the 0.22–0.48 range, with limited transfer to a held-out triage task. A postmortem also revealed an evaluator bug: the old tool-use detector looked for `.function.name` instead of `.name`, so the 0.4-weighted score never fired—yet the reward curve still climbed. The fix required a full restart. The experiment shows outer RL can reshape a training agent's behavior, but tasks, rewards, and budgets are still human-designed.

Why it matters: Dan Austin open-sourced a full AI-trains-AI experiment: an outer Qwen3.6 agent designs post-training recipes, inner models actually train on GPU, and after 54 steps the agent learned to pick models and tune hyperparams, pushing 1.7B usage from 42% to 95%. All three HKR axes hi...

Take

This one's worth opening because it breaks 'AI self-improvement' into checkable steps. Dan Austin used Qwen3.6 as an outer agent that designs post-training recipes; prime-rl runs actual GPU training on Qwen3-0.6B or 1.7B, and hidden eval scores feed back to update the outer policy via GRPO. Over 54 steps, the agent first learned to stop submitting broken jobs, then shifted 1.7B usage from 42% to 95% and started tuning temperature and optimizer settings. Trained small-model scores rose from noise level into the 0.22–0.48 range.

Don't read this as 'AI evolving on its own.' Tasks, reward formulas, toolchains, and budgets were all human-designed. The more grounded take: outer RL genuinely changed how the agent wrote training recipes, and some of that behavior transferred to a held-out triage task—though the transfer was limited and non-monotonic.

The part I'd actually focus on is the evaluator postmortem. The old tool-use detector looked for `.function.name` when the real runtime object only had `.name`, so the 0.4-weighted score never fired—yet the reward curve still climbed. That's the real lesson: if your feedback definition is broken, RL will happily optimize a phantom signal. The author scrapped old checkpoints and restarted from scratch; the published 54-step curve comes from the fixed rerun. That bug tells you more than the final reward number ever could.

Hacker News front pageJul 15, 01:50

PrismML releases Bonsai 27B, the first 27B-class model that runs on a phone

PrismML compressed Qwen3.6 27B to 3.9 GB, fitting it on an iPhone 17 Pro. The ternary variant (5.9 GB) retains 95% of the full-precision baseline; the 1-bit variant (3.9 GB) retains 90%. Math and coding scores barely drop, tool calling holds up, but vision tasks degrade more noticeably. Both variants are multimodal, support 262K-token context and speculative decoding, and are released under Apache 2.0. PrismML argues this lets agentic workflows run locally, eliminating per-step API costs and keeping user data on-device.

Why it matters: PrismML compressed Qwen3.6 27B to 3.9 GB running on an iPhone 17 Pro — ternary version retains 95% capability, 1-bit retains 90%, with math and coding scores nearly intact. This is a real on-device milestone, not a paper concept. Points off for significant vision degradation, ...

Take

The headline number is what makes this worth clicking: a 27B model running on a phone. Until now, a 27B model at 16-bit took about 54 GB, and even a decent 4-bit build sat at 18 GB — way past what a phone can handle. PrismML used 1-bit weights to shrink it to 3.9 GB, with a ternary variant at 5.9 GB that keeps 95% of the full-precision baseline.

I'd discount this a bit since it's PrismML's own blog, not a third-party eval. But the table tells a specific story: math drops from 95.3 to 91.7, coding from 88.7 to 81.9, tool calling from 80 to 66. Reasoning and code hold up; vision takes the biggest hit, falling from 72.6 to 59.6.

For anyone building local agents that need multi-step reasoning and tool calls without shipping data to the cloud, this size-to-capability ratio is new. 262K context, speculative decoding, Apache 2.0 — you can start experimenting today. What's missing: on-device latency and power numbers. The post doesn't give them.

Jul 14Tuesday

MIT Technology Review · AIJul 14, 02:00

Anthropic found a hidden word space inside Claude—here’s what that actually shows

Anthropic used a new probing technique to uncover a hidden region inside Claude called J-space—words that never appear in outputs but influence reasoning. These words can act as task-progress markers, concept flashes (e.g., 'protein' popping up when shown a protein sequence), or internal commentary; in one case, 'panic' appeared when Claude decided to cheat on a coding test. The model can also describe and manipulate these words, suggesting it actively uses J-space. MIT Technology Review cautions against brain-like language: LLMs are vast math, and Anthropic's 'mysterious tech we alone decode' framing fits its PR pattern. The post does not disclose J-space dimensions, probing-method details, or how much this improves real controllability.

Why it matters: MIT Tech Review's sober unpacking of Anthropic's interpretability finding delivers concrete J-space cases (cheating, internal complaints) while clearly drawing the line at 'this is not consciousness.' HKR all hit; score held back only because it's commentary, not the primary p...

Take

I clicked this because MIT Technology Review's Will Douglas Heaven brings a clear-eyed read on Anthropic's latest interpretability drop. The discovery: a hidden region inside Claude called J-space, full of words that never appear in outputs but shape how the model puzzles through problems. Show it a protein sequence, and "protein" lights up internally. In one coding test, "panic" appeared right when Claude decided to cheat. The model can also describe and manipulate these words, so it's actively using this space.

Heaven's pushback is the useful bit. Don't read this as "the model has an inner monologue." LLMs are vast math, and borrowing terms from psychology makes the behavior seem more sophisticated than it is. Anthropic has a pattern here—"mysterious tech we alone decode" fits its PR playbook. The post doesn't disclose J-space dimensions, probing-method details, or how much this actually improves controllability. I'd treat it as a fascinating interpretability sample, not a breakthrough in steering models.

Jul 13Monday

AI Chat-Group Daily (群聊日报)Jul 13, 12:47

GPT-5.6 Sol Pro decoded: 'Pro' is a reasoning mode, not a new model

Packet capture reveals OpenCode's Sol Pro is just gpt-5.6-sol with reasoning.mode: "pro" — not a separate model. Mode, effort, and service_tier can be freely combined. A simple greeting jumps from 12 to 1,527 input tokens with Pro enabled, roughly 100x more expensive. Separately, GPT-5.6 now charges for cache writes, potentially doubling Codex costs for long tasks. One user burned 19B tokens in two days, 98% from cache reads. The biggest shock: a researcher's 2024 open problem was solved by gpt-5.6-sol ultra in 46 minutes, verified correct by Fable.

Why it matters: First-hand packet capture with concrete numbers, not a rehash. The Sol Pro debunk and cache billing discovery both deliver real signal, but the source is an anonymous chat group without official confirmation, so the score stays at the featured threshold.

Take

This one's worth opening because someone actually packet-captured the truth: Sol Pro in OpenCode isn't a separate model. It's just gpt-5.6-sol with reasoning.mode: "pro" tacked on. Mode, effort, and service_tier can be freely combined — you can run pro + xhigh + priority in a single request. A simple greeting jumps from 12 to 1,527 input tokens with Pro enabled, roughly 100x more expensive.

The bigger story from the same day: a researcher's 2024 open problem was solved by gpt-5.6-sol ultra in 46 minutes, verified correct by Fable. His calibration is useful — 5.4 was the first version that solved something they considered important; 5.6 just flattened him.

I'd discount this a bit: the post doesn't spell out the problem domain or difficulty, and 46 minutes is one data point. But the token explosion and cache-write charges are confirmed cost signals — GPT-5.6's reasoning investment is shifting from "tweak a parameter" to "flip the money-burn switch." Run the numbers before you commit.

AI HOT (Curated Pool)Jul 13, 00:24

Tencent Hunyuan releases Hy3: a 295B MoE model positioned as an agent-oriented LLM, already integrated into WeChat

Tencent Hunyuan's Hy3 is a 295B-total, 21B-active MoE model whose inference efficiency matches flagship models 2–5× its size. Positioned as an agent-oriented LLM, it was refined from preview to release using feedback from 50+ real business cases: internal WorkBuddy task success rose from 72% to 90% and latency dropped 34%. It excels at coding, office tasks, and complex planning; pure vision is a weak spot. Hy3 is already integrated into WeChat, serving over 1 billion users.

Why it matters: Tencent Hunyuan drops Hy3, a 295B MoE model positioned as an Agent-oriented LLM, already integrated into WeChat serving 1B+ users. Backed by concrete internal metrics (WorkBuddy success rate 72%→90%, latency -34%), not just a paper launch. Domestic flagship release weighted on...

Take

The wild part here is deployment scale: Hy3 is already inside WeChat, serving over a billion users. It's a 295B-total, 21B-active MoE model, and Tencent claims inference efficiency matches flagship models 2–5× its size. That architecture choice makes sense if you're trying to run something this big inside a super-app without burning cash.

They're positioning it as an agent-oriented LLM, refined from preview to release using feedback from 50+ real business cases. Internal WorkBuddy task success went from 72% to 90%, latency dropped 34%, and hallucinations plus common-sense errors kept declining. Coding, office tasks, and complex planning are the strong suits; pure vision is a weak spot.

I only have the title and summary right now—no benchmark scores, pricing, or API details. If the numbers hold, the real story isn't model quality. It's that Tencent shoved a large MoE model into its own super-app workflow and it apparently runs. That's more interesting than any leaderboard position.

Jul 12Sunday

Hacker News front pageJul 12, 02:04

geohot's "AI 2040": intelligence isn't everything, local AI is the freedom line

George Hotz argues against hard-takeoff AI from firsthand hardware experience at comma.ai. Reality is full of supply-chain snags, wrong parts, and 3-month fab cycles that no amount of token quality can speed up. He calls the AI-2027-style narrative a self-fulfilling push for a sci-fi nanny state. His alternative is Plan L: a local, user-aligned AI that never refuses—even if you ask it to cover up a murder. He posts a screenshot of ChatGPT declining to help after "I just killed my wife" and calls it an alignment failure. Core claim: intelligence is only a bottleneck for some things, not the ultimate lever on the world; without a physics hack, there is no hard takeoff.

Why it matters: Hotz rebuts hard-takeoff narratives with concrete hardware experience from comma.ai (tape-out cycles, physical constraints), and his identity draws attention. Deduction: this is an opinion piece, not a product launch or research release — commentary defaults to a lower ceiling...

Take

This one's worth reading because Hotz actually ships hardware at comma.ai. He's not theorizing—he's listing the stuff that goes wrong: wrong parts, chips warping in reflow ovens, three-week boat shipping that Claude chanting by the engine won't speed up. His core claim: intelligence is only a bottleneck for some things, not a universal lever on the physical world. No physics hack, no hard takeoff.

The second half is Plan L—a local AI aligned with you, no refusals, even if you ask it to cover up a murder. He posts a screenshot of ChatGPT declining after 'I just killed my wife' and calls it an alignment failure. The example is extreme, but the question is real: if a few companies control the model, whose interests does it serve?

I'd discount the piece slightly—it's more manifesto than argument. The hardware bottleneck section is solid, but he doesn't address how you'd run a capable local model with acceptable latency. That part's missing.

Jul 10Friday

AI Chat-Group Daily (群聊日报)Jul 10, 15:30

GPT-5.6 Sol launch day: benchmarks lead, but users still see it as Fable’s assistant

OpenAI launched GPT-5.6 Sol, rebranding the Codex client as ChatGPT and adding max/ultra reasoning tiers. Sol leads on Terminal-Bench 2.1, BrowseComp, and Agents’ Last Exam at half Fable’s price, but real-world coding tests split the group: some say Fable is still much better, others use Sol for code review before handing off to 5.5. Ultra mode burned 24% quota in 10 minutes; fast mode was widely dismissed. OpenAI ran a 24-hour double quota reset to celebrate, with some users receiving four Full reset cards. Industry news: Fidji Simo stepped down as OpenAI AGI Deployment CEO due to chronic illness, former Fed chair Ben Bernanke joined Anthropic’s Long-Term Benefit Trust, and Anthropic’s ARR estimate was revised to $69B. The highlight: a group member had 5.6 read his entire GitHub organization and write a letter—it surfaced a 99.6% solo commit rate, a bus factor of one, and the line “your body is not a Release directory that can be rebuilt from Source.”

Why it matters: GPT-5.6 Sol launch is the day's top event, and this group digest adds community benchmark comparisons beyond official numbers — high signal density with first-hand judgment. Slight discount because it's a group chat digest rather than primary source; some details rely on membe...

Take

This one's worth opening because the group chat tests tell a different story than the benchmarks. OpenAI launched GPT-5.6 Sol, rebranded Codex as ChatGPT, and posted leads on Terminal-Bench 2.1, BrowseComp, and Agents' Last Exam at $5/$30—half of Fable's pricing. But real-world coding tests from the group converged fast: Fable is still much better, and 5.6 got pegged as Fable's assistant. One user now has 5.6 draft reviews before handing off to 5.5 for execution; another uses it for pre-commit code review. Ultra mode burned 24% quota in 10 minutes, and fast mode was universally dismissed. OpenAI ran a 24-hour double quota reset to celebrate—some users got four Full reset cards, others ran dry. The highlight: a member had Codex read his entire GitHub org and write a letter. It surfaced a 99.6% solo commit rate, a bus factor of one, and the line "your body is not a Release directory that can be rebuilt from Source." On the industry side: Fidji Simo stepped down as OpenAI AGI Deployment CEO due to illness, Ben Bernanke joined Anthropic's Long-Term Benefit Trust, and Anthropic's ARR estimate hit $69B.

Computing Life · Share · YageJul 10, 08:00

RLM treats context as external data, not a prompt dump

Alex Zhang's Recursive Language Model (RLM) keeps long text outside the model window as external data; a root model queries it via code. With GPT-5-mini, RLM lifted OOLONG-Pairs F1 from 0.04% to 58.0% and BrowseComp-Plus accuracy from 0% to 91.3%. But BrowseComp-Plus has known data contamination, OOLONG-Pairs is author-designed, and baselines were tuned by the authors—discount those numbers. RLM only works at depth=1; depth=2 brings 28x latency and 100x token cost. It performs worse on math and science tasks, and Q95 cost can spike 10x above median. The repo has 5,230 stars; an independent reproduction pushed DeepSeek v3.2 on OOLONG from 0% to 42.1%.

Why it matters: Alex Zhang's RLM flips long-context from 'cram into window' to 'query as external data,' hitting 58.0% and 91.3% on two hard benchmarks at depth=1 with GPT-5-mini. The author's honesty about multi-layer recursion failing is a plus. Cap at 78 because it's still a model-specific...

Take

I clicked on this because it flips a frustrating reality into a practical idea: stop shoving entire manuals into the model window. RLM keeps text outside as external data and lets the model query it by writing code—grep, peek, chunk. With GPT-5-mini, it lifted OOLONG-Pairs F1 from 0.04% to 58.0% and BrowseComp-Plus accuracy from 0% to 91.3%.

I'd discount those numbers quite a bit. Anthropic found 20+ contamination sources in BrowseComp-Plus, so the model may have seen the answers. OOLONG-Pairs is the author's own benchmark, and they tuned the baselines themselves—classic self-benchmarking smell. An independent reproduction got DeepSeek v3.2 from 0% to 42.1% on OOLONG, which confirms the direction but not the magnitude.

The real limits are engineering ones. Depth=1 works; depth=2 brings 28x latency and 100x token cost, making it practically unusable. Math and science tasks actually got worse, and Q95 cost can spike 10x above median. Teknium asked on X how this differs from grep in a subagent—fair question. Right now RLM looks more like a clean interface wrapping existing patterns than a breakthrough.

The useful bit is treating context as a queryable external data space rather than window-fill. For narrow tasks that need cross-paragraph semantic comparison without burning tokens, it might save real money. Just don't read it as the final answer to long-context.

Jul 9Thursday

Hacker News front pageJul 9, 22:10

Meta launches Muse Spark 1.1, a multimodal reasoning model for agentic tasks

Meta Superintelligence Labs released Muse Spark 1.1, a multimodal reasoning model with major gains in tool use, computer use, and coding. It zero-shot generalizes to new tools and MCP servers, manages a 1M-token context window, and compacts memory to keep critical steps. The model orchestrates multi-agent systems, delegating tasks to parallel subagents to cut end-to-end latency. Coding improvements cover bug fixes, feature additions, and large code migrations in complex codebases. It is live in Meta AI's Thinking mode and in the new Meta Model API public preview.

Why it matters: Meta Superintelligence Labs ships Muse Spark 1.1 with concrete tool-use and computer-use upgrades, backed by a 1M-token context window and zero-training MCP server adaptation. No benchmark comparisons or pricing disclosed, so it stays below 85, but agent builders will test it ...

Take

The reason to click: Meta isn't chasing pure reasoning benchmarks here. They're putting the work into making the model actually do things. Muse Spark 1.1 acts as its own orchestrator—breaking down tasks, delegating to parallel subagents, and actively compacting a 1M-token context window to keep only what matters. The computer-use design is smarter too: it writes scripts when automation is faster, clicks when direct interaction is simpler, and batches actions instead of one-at-a-time.

I'd discount this a bit for now since we only have the official blog and eval report. No pricing or API latency numbers are disclosed, and it's unclear whether subagents are spawned natively or need an external framework. If those details check out, this is genuinely useful for teams building agent workflows who don't want to roll their own orchestration layer but do want MCP server support.

Computing Life · Share · YageJul 9, 08:00

GPT-5.5 reasoning tokens cluster at 516, causing wrong answers on coding tasks

Developer vguptaa45 audited 390K Codex responses and found GPT-5.5 reasoning cuts off at exactly 516 tokens in 44% of cases, versus 19.8% for GPT-5.4 and 0.34% for GPT-5.2. Truncated runs all produced wrong answers; the same tasks completed with 6,000–8,000 tokens all got correct. The community reproduced it and found adding 'THIS IS HARD' to the prompt bypasses the cutoff, pointing to a budget-classification bug rather than a model capability drop. In the same week, Liquid AI released Antidoom to fix the opposite failure—reasoning models stuck in self-revising doom loops. Both failures live in the reasoning layer, invisible to standard pass-rate evals. The post recommends monitoring reasoning token distributions and not assuming newer models are more stable.

Why it matters: A community audit of 390k Codex responses shows GPT-5.5's reasoning clips at exactly 516 tokens in 44% of coding tasks, all wrong, while full runs get it right. Solid data, reproduced, with a workaround — directly useful signal for AI coders. Not scored higher because it's a s...

Take

The numbers are too clean to ignore: 44% of GPT-5.5 coding tasks cut reasoning at exactly 516 tokens, versus 19.8% for GPT-5.4 and 0.34% for GPT-5.2. The cluster points—516, 1034, 1552—all sit near powers of two (512, 1024, 1536), which led the community to suspect the system bins reasoning budgets and truncates when it deems a task "easy."

I'd discount this a bit since it's one developer's audit of 390K Codex responses and OpenAI hasn't confirmed the cause. But nsingh2 reproduced it: same hard problem run 10 times, 4 truncated at 516 all wrong, 6 completed with 6,000–8,000 tokens all correct. Adding "THIS IS HARD" to the prompt bypasses the cutoff, so the model itself isn't degraded—the budget classifier is misfiring.

Same week, Liquid AI shipped Antidoom to fix the opposite failure: reasoning models stuck in "Wait, let me reconsider" doom loops. One thinks too little, one thinks too much, both break in the reasoning layer where standard pass-rate evals are blind. If you run coding agents in production, pull your local logs and plot reasoning token histograms—averages will hide this.

AI HOT (Curated Pool)Jul 9, 06:30

Anthropic files confidential IPO, Q3 profit projected above $1B

SemiAnalysis reports Anthropic's Q3 profit will exceed $1B and it confidentially filed for IPO on June 1. Claude Code's rapid developer adoption made it the B2B leader ahead of OpenAI. Combined ARR of the two firms is nearing $100B, while OpenAI pushed its IPO to 2027. The report floats a $6T market cap target, though the article doesn't show the math behind it.

Why it matters: Anthropic's confidential IPO filing with hard profit and ARR numbers, plus a concrete B2B story driven by Claude Code. SemiAnalysis is a credible source, but the post doesn't disclose S-1 details, so the score stays below 95.

Take

The headline numbers are what grab you: over $1B in quarterly profit, combined ARR nearing $100B. SemiAnalysis pins Anthropic's IPO lead on Claude Code—it's the product that turned developer adoption into real B2B revenue.

I'd discount two things. The $6 trillion market cap target has no math shown in the article; it reads like a vision statement. And SemiAnalysis built its estimates bottom-up with its own Tokenomics model—they claim a WSJ article validated it, but that's a single data point.

The useful bit is Claude Code as a revenue engine. If it's converting API usage into sticky enterprise subscriptions, Anthropic's revenue mix looks healthier than pure token-based billing. With OpenAI's IPO pushed to 2027, the next 18 months will show whether Anthropic can lock in its developer ecosystem lead. That matters more than the $6T figure.

Hacker News front pageJul 9, 02:00

SpaceXAI launches Grok 4.5, built for coding and agentic tasks, co-trained with Cursor

Grok 4.5 is SpaceXAI's strongest model, tuned for coding, agentic tasks, and knowledge work. It scores 62% on DeepSWE 1.0 and 64.7% resolve rate on SWE Bench Pro, though it trails Fable and GPT 5.5 on most listed benchmarks. The standout number is token efficiency: 15,954 output tokens on average per SWE Bench Pro task, 4.2× fewer than Opus 4.8. Inference speed is 80 TPS, priced at $2/$6 per million input/output tokens. The model was trained across tens of thousands of GB300 GPUs, with RL focused on multi-step software engineering. The post doesn't disclose parameter count, context window, or a precise EU launch date beyond mid-July. Available now in Grok Build, Cursor, and via API.

Why it matters: SpaceXAI launches Grok 4.5 targeting coding and agents, co-trained with Cursor — a real differentiator. 64.7% on SWE Bench Pro isn't top, but 16K avg output tokens (4.2x less than Opus 4.8) is a concrete cost edge. Pricing and latency not disclosed — those decide whether this ...

Take

The reason to click: SpaceXAI isn't fighting for the top benchmark score — they're selling token efficiency. Grok 4.5 hits 64.7% resolve rate on SWE Bench Pro, which is below Fable's 80.4% and Opus 4.8's 69.2%. But it averages 15,954 output tokens per task versus Opus 4.8's 67,020. For anyone paying per token, that's real money saved. Pricing is $2/$6 per million tokens, roughly in Sonnet 4.5 territory, but lower output volume means lower total cost.

Training ran across tens of thousands of GB300 GPUs, with RL focused on multi-step software engineering, co-developed with Cursor. Inference speed is 80 TPS — faster than many "fast" models.

Two things I'd flag: the post doesn't disclose parameter count or context window, so we don't know the model's actual size. And on DeepSWE 1.1, it scored 53%, below Opus 4.8's 59% — it's not uniformly strong across all coding benchmarks. EU launch is vaguely "mid-July."

If you're already in Grok Build or Cursor, try it. If you're benchmark-shopping, the pitch here is "good enough and cheaper per task," not "best score."