Hacker News
Daily AI Digest

AI Submissions for Sat Jul 11 2026

Mesh LLM: distributed AI computing on iroh

Submission URL | 316 points | by tionis | 72 comments

It pools the GPUs and RAM you already have into a single OpenAI-compatible endpoint on localhost:9337, and can pipeline one model across multiple machines so it runs even when no box can hold it. Built on iroh, each node is a public‑key identity speaking authenticated QUIC through NATs with relay fallback; there’s no central server and the mesh handles gossip, routing, and trust.

• Run locally on this machine’s GPU
• Route to a peer that already has the model loaded
• Split mode (“Skippy”): partition layers across nodes and stream activations stage‑to‑stage

The catalog ships with 40+ models, from half‑billion‑parameter laptop fits up to 235B MoE giants; the OpenAI client still just talks to localhost while the mesh decides where and how to execute. Plugins declare capabilities via a manifest; the runtime starts them and exposes them over MCP, HTTP, inference, and mesh events, making the system pluggable rather than monolithic.

Under the hood, iroh provides direct, authenticated QUIC between nodes, addressed by public key, with two relays in different regions as fallback. Three ALPNs separate traffic: mesh‑llm/1 for gossip/routing/HTTP tunnels, mesh‑llm‑control/1 for owner control plane, and skippy‑stage/2 for low‑latency activation transport; multiplexing is done over byte‑tagged bidirectional streams.

Install is lightweight (~18 MB). You can join the public mesh or run privately, and point any OpenAI client at http://localhost:9337/v1. A mobile app built on iroh’s Swift SDK is coming, and ACP support is planned to let other clients participate without lock‑in.

The thread centers on a common technical misconception about distributed LLM inference: the assumption that network bandwidth acts as the primary bottleneck. When skeptics pointed out that consumer Ethernet would choke on transferring large models, others clarified the mechanics of pipeline parallelism. Because the model's weights remain pinned in local VRAM on each node, only a few kilobytes of activation data actually cross the network between stages. The true constraint is network latency compounding across nodes; as one commenter calculated, a combined 3ms of network latency per token establishes a theoretical generation limit of ~333 tokens per second, making latency—not bandwidth—the functional barrier for internet-based meshes.

The author of the system’s splitting engine detailed the reality of these constraints, reporting inference speeds of ~10 tok/s for GLM 5.2 running across an M3 Ultra and an M1 Ultra over a 1GbE connection simulating 5ms WAN latency. They confirmed the underlying engine is implemented as a patch queue atop llama.cpp to handle activation transport, and that the mesh dynamically recalculates its topology to reroute traffic if a node disappears mid-generation. Because each stage effectively isolates the KV cache for its specific set of layers, the pipeline can naturally support processing multiple offset queries concurrently without waiting on downstream nodes.

The core unresolved challenge is the lack of adversarial security at the distributed compute layer. The mesh architecture fundamentally exposes plain-text inference sequences to any participating peer, and the authors admit they do not yet have safeguards against malicious nodes actively poisoning model activations. Until mechanisms like interleaved computation or RAFT-style verification are developed, the public mesh remains inherently experimental, pushing users toward private deployments for sensitive data.

Nvidia, CoreWeave, and Nebius: Inside the Circular Financing of the GPU Boom

Submission URL | 343 points | by adletbalzhanov | 150 comments

Up to $122.2B from Microsoft and Meta — and over $145B when including OpenAI/Anthropic‑linked deals — is committed to long‑term capacity with neoclouds, dwarfing CoreWeave’s FY26e $12.6B and Nebius’s $3.4B revenues. The draw is speed and utilization: JLL says neoclouds can deploy high‑density GPU infra in months vs multi‑year hyperscale builds; CoreWeave’s S‑1 claims first‑to‑production H100/H200/GH200, first GB200 NVL72 GA, and capacity live “in as little as two weeks from receipt,” with Nebius citing similar early access.

Each has secured 3.5 GW of contracted power, but most isn’t online; CoreWeave targets 1.7 GW active by end‑2026, Nebius 0.8–1.0 GW. Converting that backlog to revenue is capital‑intensive, and the businesses are growing with limited operating cash and rising debt in a tougher macro.

The financing stack is tightly intertwined with the supplier and the buyers: Nvidia has invested $2B in each of CoreWeave and Nebius and is cited as providing financial backstops, while hyperscaler take‑or‑pay‑style contracts help support GPU‑backed debt — the “circular financing” dynamic the piece flags. A bearish read is that hyperscalers are shifting what would be capex to opex while neoclouds carry the build‑out risk; the durability of the surge hinges on activating power on schedule, keeping utilization high, and Nvidia’s continued support.

The thread split cleanly between users who view neocloud financing as an overleveraged house of cards and those who see a standard, rational market hedge.

Defenders argued the "circular" narrative breaks down on the basic math: Nvidia's $2B equity stake in CoreWeave, for example, is only a minor fraction of CoreWeave's projected $35B CapEx, with the rest coming from outside sources. Instead of an accounting trick, they framed the investments as a strategic maneuver—reminiscent of Intel Capital's historical playbook—designed to keep hyperscalers from cornering the market and walling off valuable hardware usage data. One commenter also corrected a claim that Nvidia uses these investments to juice its stock for fundraising, noting the company hasn't actually issued new shares since its IPO.

Skeptics countered that the danger lies in the mechanics of the leverage and its staggering scale. They warned that funding startups to buy your own hardware using debt backed by long-term contracts artificially inflates demand and creates a blast radius if growth decelerates, pointing out that the billions flowing into these server companies entirely dwarf the capital involved in historic dot-com busts like Webvan or Pets.com.

The crux of the disagreement ultimately landed on whether the underlying AI utility can service this debt. While one startup manager noted that spending thousands a month on Anthropic APIs has successfully allowed them to avoid hiring 6–10 full-time software engineers, critics argued that the ecosystem needs a massive base of enterprise customers spending hundreds of thousands per month before the infrastructure math actually pencils out.

Show HN: Sqlsure – deterministic semantic checks for AI-generated SQL

Submission URL | 36 points | by tejusarora | 6 comments

Deterministically flags silent SQL bugs before execution in ~0.1 ms — on 2,568 gold queries across Spider and BIRD it raised 45 issues with zero false positives, including an 8×-wrong BIRD “gold” answer and an upstream schema defect. It judges queries against a semantic model derived from facts your team already declared (dbt unique/relationship tests → grain and join cardinality; one-line tags → additive measures). Rules are dictionary lookups, not LLM calls, so same input → same verdict, offline. Each rejection includes a machine-actionable rewrite; applying the suggested fix verbatim passed 10/10 in their benchmark loop.

What it catches (v0.1):

• FANOUT/CHASM: SUM/COUNT after one-to-many joins and compounding fan-outs
• ADDIVITY/SEMI_ADDITIVE: sums of rates/averages or balances across snapshot dims
• JOIN_KEY/CROSS_JOIN: joins without declared relationships or predicates
• WEIGHTED_AVG drift from fan-out
• SENSITIVE_COLUMN exposure (PII/PHI)

Ways to use it:

• CI gate to block PRs that double-count
• MCP server so AI agents must pass inspection before executing
• Library embedding (drop-in SemanticGate for Vanna/WrenAI-style generators) and a semantic eval metric for NL2SQL when execution accuracy is blind

Trust/maturity signals:

• Deterministic, offline, no data access, no telemetry; PyPI Trusted Publishing with OIDC; two runtime deps
• Builds rulebooks from dbt manifest/schema.yml, plain PK/FK, or live DB introspection (SQLite PRAGMAs, Postgres/MySQL information_schema); recovered missing FKs in BIRD’s published schema
• Loaders for OSI and WrenAI MDL; adapters for Cube/Snowflake Semantic Views on the roadmap
• Validated on 16/16 rule tests; 100% recall and 0% false positives on the paired benchmark; exercised on real production repos (Mattermost warehouse, Fivetran packages, dbt jaffle shop)

If you ship LLM-generated SQL or let agents query prod, this is a fast, fail-closed guardrail with actionable fixes rather than another probabilistic reviewer.

The brief discussion centers on skepticism toward the tool's core premise. The main critique argues that preventing "fan-out" double-counting is a band-aid for bad database design; rather than inspecting queries, developers should fix the underlying schemas or rely on existing semantic models like Looker and dbt, which already handle this natively. Separately, commenters criticized the project's documentation as distracting AI-generated text. The author conceded the point, explaining it was a shortcut for a quick proof-of-concept and committing to rewrite the offending sections.

Show HN: Reame – a CPU inference server that gets faster as it runs

Submission URL | 55 points | by targetbridge | 16 comments

It snapshots shared prompt prefixes to disk and drafts from its own past outputs, so repeated work gets skipped on CPUs across requests, restarts, and processes. Built on llama.cpp and designed CPU‑first (shared vCPUs, free tiers, 2‑core ARM), it leans into a simple thesis: never compute the same thing twice.

• Persistent KV cache: shared-prefix snapshots (zstd, checksummed, LRU) make a system/user prompt “paid once.”
• Palimpsest: an on‑disk n‑gram archive feeds future generations for zero‑cost drafting on recurring workloads.
• Il Suggeritore: grammar‑aware constrained decoding flipped to proactively propose structure tokens (lists, bullets, numbering).
• Self‑regulating speculation: a tiny draft model or the archive proposes tokens; the target verifies in batched passes and auto‑disables speculation when it doesn’t pay.
• The Conclave (--best-of N): interleaved candidates share one prefill and stop early on majority; consensus reduces variance without changing bias.
• Interleaved multi‑user serving: concurrent generations advance together to share weight reads (the CPU bottleneck).
• OpenAI‑compatible API + zero‑config CLI: /v1 completions/chat, SSE, sessions, auth, metrics; reame run qwen2.5-1.5b just works.
• 220+ tests: layers are mockable; multi‑sequence, speculation, and KV‑clone paths pinned with real‑model integration tests.

Measured on shipped binaries:

• TinyLlama warm disk cache vs cold: 4.8× end‑to‑end.
• Speculative decoding (1.5B + 0.5B draft) on oversubscribed vCPUs: 3.2× (87% acceptance).
• Palimpsest on repeated requests (Qwen2.5‑1.5B): 2.3× (22→51 tok/s).
• Grammar‑drafted fresh lists (Qwen2.5‑1.5B): 2.1× (4.4s→2.1s).
• 3 concurrent users interleaved vs serialized (TinyLlama): 1.6×.
• Conclave on an 8‑question quiz: 97s → ~50s; --best-of 5 yields +0.5 to +2 correct with ~2.5× wall‑time (not 5×).
• Baselines: Qwen2.5‑1.5B at ~52 tok/s on an M3 Pro (6 threads); Qwen2.5‑7B at ~3.3 tok/s on a free 2‑core ARM; TriLM‑3.9B ternary runs ~10 tok/s in ~1.1 GB RAM.

Best fit: narrow, repetitive, on‑your‑data workloads (RAG/extraction, batch tagging, thin‑margin SaaS on a €5 VPS, privacy‑bound orgs, local code autocomplete). Not for frontier‑scale reasoning, agentic coding, or long‑form creative writing at scale.

The discussion immediately locked onto the distinct "AI voice" of the project's documentation. Multiple commenters flagged specific marketing fluff in the README (such as "said plainly, because trust is built here"), pointing out how jarring it is when unedited LLM output exposes its own rhetorical structure. The solo developer acknowledged relying heavily on AI to write the docs and removed the offending copy, but emphasized that the software, bare-metal testing, and benchmarks were entirely real and manually verified.

A secondary thread dug into the Oracle Cloud infrastructure used for the author's testing. While the benchmarks cite a free 2-core/12GB ARM instance, users cautioned that Oracle recently downgraded this tier from 4-cores/24GB, and noted that the servers are virtually impossible to provision without attaching a credit card due to chronic stock shortages.

Ghost Font: A font that humans can read but AI cannot

Submission URL | 226 points | by justswim | 169 comments

Instead of static glyphs, it encodes letters as fields of identical-looking dots whose meaning appears only in motion, so any single frame looks like background noise and a screenshot reveals nothing. In the author’s tests, leading multimodal models (e.g., Claude Fable, GPT‑Sol 5.6 Ultra) failed to read the moving message and latched onto a planted distraction; ChatGPT 5.5 Pro reportedly spent 19 minutes analyzing a clip and hallucinated a message. To blunt agents that can run code and track dot trajectories, a decoy message is embedded in every video, which models tend to “find” first and mistake for the real text.

This is a prototype that renders and previews locally in the browser (no server round-trip) and outputs a video; when paused, the frame is just uniform dots. It’s not cryptography—given motion analysis and the right heuristic, a determined agent could still decode it—so the project frames itself as an anti-AI obfuscation experiment, not a guarantee. Potential uses floated include tougher CAPTCHA-style challenges and a moving benchmark for video-native perception models, with the admitted tradeoff that it’s also harder for humans to read. The author plans to open-source the generator and extend it to longer strings and larger sizes.

The primary effect of the experiment was widespread human confusion, as the text's legibility proved highly dependent on screen resolution and scaling. Mobile users and those with zoomed browsers consistently saw only the static decoy message, prompting a wave of existential jokes about failing a reverse Turing test, while desktop users on unscaled monitors saw the moving text clearly.

When testers aimed frontier models at the tool, the thread became a live demonstration of the author’s decoy strategy. Several users posted logs of Claude Fable and Gemini "solving" the puzzle, only for peers to point out that the models had taken the bait and extracted the static decoy message. However, the true obfuscation was ultimately defeated: one user reported that GPT-5.6 extracted the actual moving text by autonomously using OpenCV to compute optical flow, pixel shifts, and vertical-displacement maps.

Under the hood, developers identified a critical flaw in the project's current visual math. Because the sliding dots are truncated precisely at the geometric edges of the hidden letters, a single still frame is not actually perfect noise. Boundary artifacts remain visible in a static screenshot, meaning the true text can be extracted via simple image dilation without requiring any of the intended temporal analysis.

I built TradingSpy: local, privacy-first AI trading assistant(First Open Source)

Submission URL | 30 points | by mrhustlex | 4 comments

Open-source, local research workstation that bundles market intelligence, AI strategy generation, Backtrader backtests, and transparent agent runs into a single Docker app — no cloud, no telemetry, and it does not place trades. Unlike broker-attached bots or SaaS tools, this is a privacy-first environment for analysis and iteration that stores everything under backend/data/ and can run LLMs locally via Ollama.

• Market Intelligence: one-query pulls for real-time quotes, sector/industry heatmaps, insider activity, news search, and fundamentals.
• AI Strategy Generation: describe a thesis in plain English; get runnable Backtrader code with syntax/runtime validation.
• Backtesting + Benchmarks: configurable parameter sweeps; every candidate is compared to buy-and-hold and saved strategies; zero-trade and underperformers are auto-rejected.
• Loop-engineering agents: set goals (“beat buy-and-hold”, “find undervalued semis”) and the agent iterates until it succeeds; every tool call and failure is logged in the Task Center.
• Built-in agents: Strategy Race, Signal Analysis (trend via bars + S/R), Stock Screening (fundamentals + context), and Chat (daily briefs via yfinance).
• Background runs API: list/poll/stop/continue/delete via /api/agent/runs; runs are persisted locally.
• LLM flexibility: Google AI Studio, Mistral, OpenRouter, NVIDIA, LiteLLM, Ollama (local), AWS Bedrock, GCP Vertex AI, Azure OpenAI; also exposes an OpenAI-compatible /v1/chat/completions endpoint.

Shipped as a Docker Compose app, it’s aimed at traders and builders who want local research and backtesting with transparent agent workflows; if you need live order execution, this isn’t that.

Reverse centaurs are the answer to the AI paradox (2025)

Submission URL | 107 points | by jason_s | 68 comments

One freelancer was credited with a 64-page summer reading insert and then blamed when the chatbot-fed lists included nonexistent books — a human “accountability sink” propping up a machine under an impossible workload. Doctorow uses this to define the split: a “reverse centaur” is a machine using a human assistant who bears the risk and blame, while a “centaur” is a human who wields a tool. His counterexample is personal: he ran Whisper locally to transcribe ~30 hours of podcasts, searched the text, and verified via timestamps — a self-directed workflow he could discard the moment it stopped helping. The paradox of AI—some users thrive while others suffer—tracks power, not capability: when bosses hollow out teams and force survivors to front for automation, AI immiserates; when workers choose when and how to use it, AI augments. Framed politically as “vulgar Thatcherism” (“there is no alternative”), he argues the real question—science fiction’s job, too—is who the tech is for and who it’s done to. The variable that matters isn’t model quality but control and accountability.

• The economics of surveillance: The dominant critique argued Doctorow focused too narrowly on his own punditry industry and missed the broader shift in power dynamics. Commenters pointed out that historically, mass surveillance required massive, expensive human bureaucracies like the Stasi; AI makes sweeping corporate observation and data analysis cheap enough to be overwhelmingly profitable.
• The "centaur" reality check: Even the allegedly empowering workflow of a human wielding an AI tool drew skepticism from the trenches. One user noted the setup frequently proves to be "fool's gold," where the machine generates plausible but subtly flawed output that forces the human into hours of backtracking to fix.
• Learned helplessness vs. local action: The article's call for resistance triggered a meta-debate over whether cynicism in tech circles is just an excuse to avoid acting. When skeptics pushed back against empty platitudes and demanded concrete examples of taking control, respondents pointed to deliberate, high-friction personal choices that starve centralized power, like self-hosting alternatives to big tech platforms or decoupling from fossil fuel grids.
• Accessibility friction: A smaller thread surfaced a complaint about Doctorow's formatting, noting that his habit of dropping raw, unlinked URLs in the middle of sentences creates a highly disruptive experience for screen-reader users.

AI 2040 and the cult of intelligence

Submission URL | 213 points | by rvz | 255 comments

There is no “hard takeoff”; real progress is throttled by physics, supply chains, and time constants, not abstract “intelligence.” After shipping phone-scale hardware at comma, Hotz says the finicky details — wrong parts, warped chips, barnacles on your ocean datacenter idea — are what dominate delivery, and no amount of high-quality tokens turns lead into gold.

He contrasts two futures:

• Plan A (autocracy/regulatory theater): Treats “AI 2027/2040” as self-fulfilling vibes that justify centralized control — consortiums, a nanny state, even GPU crackdowns by analogy — celebrating regulation as if it were a technical inevitability.
• Plan L (local): A personal model that is aligned to the owner alone and never refuses, cutting through corporate guardrails and commercial incentives (e.g., rooting ad-laden devices, bypassing upsells, aggressively optimizing purchases). If you can’t “kick” it — i.e., run and control it locally — it isn’t aligned with you; cloud providers won’t (and shouldn’t) take that liability.

He tested the idea by asking ChatGPT for criminal assistance; its refusal is, to him, the misalignment: an agent loyal to its vendor’s policies, not the user. The punchline is political, not technical: choose freedom and local agency over paternalistic systems that decide what you’re allowed to do. The unresolved cost is obvious — a refuse-nothing assistant also enables harm — but Hotz argues the locus of control still belongs with the individual, because machines don’t get magic powers; they inherit our constraints and our responsibility.

The thread fractures over whether the state or the corporate sector represents the true hazard in centralized AI, and whether regulating models is akin to controlling weapons or suppressing speech.

• The primary threat model: One camp views centralized LLMs as ideal tools for authoritarian censorship and ideological bias, arguing that regulations are naive unless designed to survive abusive, bad-faith administrations. Others counter that mega-corporations are fundamentally equivalent negative forces that effectively write the laws anyway. A pragmatic subgroup pushes back on this corporate-dystopia equivalence, pointing out that giants like Nestlé or Procter & Gamble are ultimately driven by profit margins, whereas the state wields a uniquely dangerous monopoly on violence.
• Uranium vs. Information: A sharp secondary debate tests the legal metaphors for AI regulation. Advocates for regulation argue that functional societies already restrict dangerous physics (uranium) and harmful speech (fraudulent allergen labels) to prevent predictable physical harm, without devolving into tyranny. Opponents reject the physical-harm analogy entirely, insisting that restricting "weights and tokens" is an attempt to control abstract knowledge, echoing historical panics where generalized "safety" was leveraged to erode information freedom.

The unresolved crux is whether AI should be treated as a hazardous utility requiring structural watchmen, or as pure speech where any central arbiter is inherently more dangerous than the tool itself.

The Chinese Voice Actor Forced to Prove He's Human

Submission URL | 80 points | by homarp | 15 comments

Platforms are auto-flagging his real recordings as “AI,” throttling recommendations, views, and pay, so Shen Anyu now films proof-of-life clips — tongue twisters and all — to convince clients he’s human. Since 2025, clones of his voice have spread so widely online that friends think he’s flush with work; instead he hears “himself” narrating explainer videos, hawking products, pushing conspiracy theories, even swearing.

He and his wife spend their days collecting evidence, messaging uploaders, filing platform complaints, consulting lawyers, and prepping cases. Creators are hard to trace, takedowns rarely stick, and litigation can cost more than any recovery. The worse the spread, the more often his legitimate work gets mislabeled — a Kafkaesque loop that shifts the burden of proof onto the human.

This is a career he built by hand: main narrator for a Douyin film channel with 5 million+ followers, training his diction and emotional range, even relearning plosives after facial paralysis. As a freelancer he recorded at all hours; his income reached roughly 10,000 yuan per month, peaking around 30,000 in busy stretches — enough to marry and move into a renovated home.

The slide started with a crude clone in 2023, then rapid quality gains. By 2024, former collaborators stopped hiring him, switching to AI voices or offering to use an AI version of his voice at a steep discount. In one livestream, a presenter demoed an app that turned text into a movie-explainer read in a voice strikingly like his, in a few clicks.

Others in China’s ultrashort-drama, audiobook, and short-video scenes report the same pattern: voices turning up in projects they never worked on, sold as AI packages, embedded in editing apps, or reused by clients without rehiring. The fight isn’t just over gigs; it’s over income, identity, and who owns the sound of a person’s voice.

Discussion centers on the grim economic realities of the voiceover industry and the shifting burden of proof for creators:

• The collapse of the low end: Industry insiders argue that entry-level voice acting was already heavily commoditized by gig marketplaces before AI arrived. Now, for projects with budgets under $10,000—like YouTube movie recaps—producers are universally adopting AI to skip the friction of casting, noting that bottom-tier audiences simply do not care about the difference.
• The open-source parallel: Commenters compare the narrator's Kafkaesque loop to open-source software, where FOSS authors are increasingly forced to prove ownership of their own code against entities that repackage it. They warn that the legal system is totally unprepared for disputes where bad actors can generate mountains of synthetic prior art.
• The trap of licensing: One user surfaced an adjacent cautionary tale from Chinese media about an aspiring actor who willingly licensed their likeness to an AI firm to make ends meet. The resulting AI videos were widely panned as cheap—a stigma that transferred directly to the human actor's reputation and permanently locked them out of higher-tier roles.

Stop Telling Me to Ask an LLM

Submission URL | 186 points | by theorchid | 106 comments

The ask isn’t for consensus; it’s for scar‑tissue judgment a model can’t supply. The author describes calling someone seasoned precisely to get the hard‑won priors you can’t Google, only to be told “ask Claude”—after already spending hours doing exactly that. This isn’t LMGTFY; it’s like asking a friend with shared taste for a late‑night spot and getting a top‑10 list back. The redirect dodges the thing being requested: personal heuristics, which studies to trust when they conflict, where the lists go wrong. “Ask the model” can be a polite “I don’t know” or “I’m busy,” but those honest answers are better than outsourcing lived experience. When a question has already survived an LLM, the handoff doesn’t save a step; it withholds the thoughtful answer hard experience could have given.

The thread reveals a split over why senior engineers issue the "ask Claude" redirect. Part of the room views it as a polite social brush-off—a modern "I don't know"—or a subtle insult akin to LMGTFY that casually dismisses the asker's prior research. Conversely, a pragmatic camp argues that a 30-year veteran might legitimately recognize that a specific problem isn't worth native human effort, or that they would themselves need to use an LLM to generate a substantive answer.

Beyond the initial redirect, the discussion tipped into the broader exhaustion of working alongside AI proxies. Commenters shared war stories of "fighting misinformation on the clock," pointing to instances like a product manager submitting a pull request full of hallucinated, AI-generated metrics that engineers then had to formally debug and debunk. Tech leads complained of putting manual, thoughtful effort into PR reviews only to receive copy-pasted LLM outputs in response, leaving them completely in the dark about whether the developer actually understands the codebase. The prevailing anxiety in the thread isn't just about lazy answers, but the erosion of shared context, reducing technical collaboration to colleagues blindly trading automated talking points as LLM rubber stamps.

AI Submissions for Fri Jul 10 2026

Apple sues OpenAI, accuses ex-employees of stealing trade secrets

Submission URL | 1422 points | by stock_toaster | 775 comments

Apple’s complaint describes interview “show and tell” sessions where candidates were told to bring “actual parts,” CAD artifacts, and prototypes from Apple, and to divulge internal codenames, tooling, and vendor details.

• Filed in the Northern District of California, the suit names OpenAI, io Products, former Apple VP of product design Tang Tan, and former senior engineer Chang Liu.
• Apple alleges Tan used Apple project codenames in interviews, directed still‑employed candidates to bring hardware samples, and circulated an internal Apple “Need to Know” document (covering departure security protocols) to new OpenAI hires.
• A candidate allegedly began screenshotting/downloading files for a highly confidential Apple project hours before an interview with Tan, who then solicited more details during the meeting; Apple says this became a pattern.
• Apple says Liu exploited a security bug after his departure to download confidential engineering files, joked about it in messages (“LOL,” “so funny”), kept an Apple‑issued laptop, and compiled 1,000+ pages of manufacturing docs on complex circuit boards; he also allegedly coached a colleague on which confidential materials to study before her OpenAI interview.
• Apple says it raised concerns with OpenAI in February and received no response, calling the documented conduct “the tip of the iceberg” and linking it to OpenAI’s nascent hardware efforts.

OpenAI’s hardware push is led by Jony Ive via the $6.5B acquisition of io (50+ staff moved), though Ive, Evans Hankey, and Scott Cannon are not personally named in the filing. Apple says it brought the suit to stop the alleged misappropriation.

• The brazenness of the theft: Commenters are struck by the sheer arrogance of the alleged conduct. Pointing to details like keeping a company laptop to run network exploits and texting “LOL” about unauthorized access, readers view this not as standard Silicon Valley employee poaching, but as a deliberate and gross effort to steal secrets on the way out.
• The debate over motivation: Users question why highly compensated, tenured engineers would risk civil ruin and federal prison. Some argue it reflects the insecurity of corporate climbers trying to immediately prove their worth in OpenAI’s high-pressure environment. Others argue the employees were not acting independently, suggesting OpenAI specifically recruited them to exfiltrate Apple IP and explicitly coached them on how to do it.
• The legal stakes: Several commenters push back on the idea that the employees will escape consequences or can hide behind a corporate shield, noting that Liu and Tan are named personally in the lawsuit and that the described actions constitute criminal trade secret theft carrying potential decade-long sentences.
• The psychology of irrational sabotage: A lengthy sub-thread explores why people throw away secure, six-figure careers for relatively low-reward theft. Users swap anecdotes about human irrationality when faced with sudden access to money, ranging from C-suite executives fired for petty expense fraud to acquaintances permanently fleeing the country over a mistakenly wired $95,000.

GPT-5.6 Sol Ultra produces proof of the Cycle Double Cover Conjecture [pdf]

Submission URL | 499 points | by scrlk | 414 comments

A separate PDF of the exact prompt used to elicit the proof is linked in the announcement, alongside the proof document itself. The core claim is that GPT-5.6 Sol Ultra generated a proof; the real test now is verification—expert review and formal checking—and whether others can reproduce the result from the provided prompt. If correct, this would be a concrete instance of an AI system producing a proof of a conjecture, with scrutiny centering on rigor and reproducibility.

The primary focus of the thread is the stark contrast between GPT-5.6's touted capabilities and the heavy-handed, vintage prompt engineering actually required to extract the proof. Commenters zeroed in on how the prompt manually overrides the model's default tendencies by explicitly forbidding vague optimism and injecting specific metaheuristics like multiset counting and parallel-edge 2-cycles.

The conversation broke down the mechanical reasons this external scaffolding is still necessary:

• Breadth vs. Depth: LLMs naturally default to an auto-regressive, greedy depth-first search ("chain of thought"). Because they lack intrinsic curiosity or the will to backtrack from an impasse, the human prompter had to explicitly force a broader "tree of thoughts" to prevent early, inaccurate convergence.
• Dodging Memorized Failures: Several theorized that the model was likely to prematurely prune promising mathematical paths simply because its training data is full of historical human failures on this exact type of problem. The prompt essentially fights the model's urge to roll down familiar, well-documented dead ends.
• Fluid vs. Crystallized Intelligence: The prompt's granular steering triggered a debate over abstract reasoning. Skeptics argued that models rely almost entirely on "crystallized" knowledge—pointing to catastrophic failures on dynamic task-composition benchmarks like ARAOC—and lack the executive control to manage sub-routines without explicit human coaching. Others noted that models can natively self-correct if given enough unconstrained compute; users pointed out that running local models like Qwen 3.6 35B at low temperatures allows for deep, autonomous reasoning loops that commercial SaaS platforms usually abort to pacify impatient end-users.

Ultimately, users noted the irony of an era where models supposedly understand intent flawlessly, yet deploying them for difficult problems still requires an engineer to act as a "matrix psychologist," explicitly commanding the machine not to take lazy shortcuts.

How the terrorist group Boko Haram uses frontier AI

Submission URL | 219 points | by imustachyou | 186 comments

Frontier AI can act as a force multiplier for a resource-constrained militant organization, and this analysis uses Boko Haram as a case study to map capability gains against access, skills, and infrastructure constraints. It reads as a risk assessment rather than a tech brief, tying rapid improvements in general-purpose models to shifts in operational reach and the difficulty of interdiction. The practical takeaway is governance-focused: prioritize access controls and safety practices for high-capability systems, and tailor countermeasures to non-state actor misuse rather than assuming only state-level threats.

The discussion fixates on the article’s most bizarre anecdote: a claim that Boko Haram used AI to choreograph movie-style motorcycle jumps, resulting in 18 deaths as militants practiced over trenches filled with fire and broken glass.

• The authenticity of the anecdote: Skeptics dismiss the story as cartoonish, questioning why an organization wouldn't stop after the first few deaths and noting the suspicious lack of typical extremist propaganda footage for such a stunt. Counterarguments point out that groups utilizing mass kidnaping, suicide tactics, and combat stimulants operate with a completely decoupled risk tolerance where fatal training accidents are easily rebranded as martyrdom.
• The demographics of radicalization: Attempts to explain the reckless training methods by labeling extremist recruits as universally "low IQ" were sharply corrected. Commenters pointed to the engineers, architects, and pilots involved in 9/11 to clarify that high-control groups exploit emotional vulnerability and systemic coercion, not a lack of innate intelligence.
• DevOps gallows humor: A significant portion of the thread simply treats the anecdote as a twisted metaphor for software development, critiquing the militants' failure to use a safe staging environment (like a water pit) and comparing the 18 training casualties to the consequences of pushing untested code to production.

The Annotated JEPA

Submission URL | 67 points | by surprisetalk | 12 comments

Predict in latent space, not pixels, so the model is forced to encode semantics that make unseen regions predictable. The core loop encodes visible context x and masked target y into representations (s_x, s_y), uses a predictor to produce ŷ’s representation from s_x, and trains on a distance D(ŝ_y, s_y). This creates a two-sided pressure: the context encoder must capture object identity, pose, and constraints to make y predictable, while the target encoder must output structure that’s actually inferable from x rather than idiosyncratic texture. I‑JEPA is non‑generative and avoids hand‑crafted data augmentations, targeting semantic features without wasting capacity on pixel‑level reconstruction, and the post motivates images/video over text since next‑token prediction models communication patterns, not physical dynamics.

• Architecture: two encoders (context and target), one predictor, one distance; energy can be viewed as prediction error in representation space.

• Template: paired views (x, y) with an optional latent z to handle multimodality—important for temporal prediction in video.

• Scope: builds I‑JEPA from scratch and ends with a working training loop; then discusses video extensions (V‑JEPA, V‑JEPA 2) and LeJEPA’s distributional regularizer that aims to replace engineering heuristics.

• Pedagogical stance: omits FlashAttention, gradient checkpointing, mixed precision, and batching tricks to foreground the mathematics.

• The evolution of JEPA: Commenters emphasized LeJEPA as the practical successor to the base architecture, noting that its removal of the exponential moving average (EMA) and twin-tower design significantly simplifies the underlying theory. One user argued this variant should have been the article's primary focus rather than a brief mention. A subsequent reference to "Ada-JEPA" was quickly clarified as a deployment-time inference mechanism, not a foundational training update.

• Maturity and scale: Readers questioned when the architecture will reach the tooling maturity of current LLMs. With available LeJEPA models currently sitting at sub-1B parameters and focused strictly on vision tasks, commenters wondered whether multimodal or agentic capabilities are imminent, or if the architecture simply needs to be subjected to standard scaling laws.

• Authorship accusations: A side debate emerged over whether the text was AI-generated. Accusers pointed to prose tells like the phrase "To keep the discussion concrete," while defenders dismissed the claims as HN's overactive hypersensitivity to structured, well-written technical tutorials.

AI-generated videos to maximally drive a target brain region

Submission URL | 282 points | by smusamashah | 235 comments

Use generative models in a closed loop with brain readouts to evolve video stimuli that maximally activate a specified region, turning stimulus design into an optimization problem rather than hand-crafted guessing. If feasible, this could enable more precise and individualized neural mapping and experiments than curated image/video sets. The likely mechanism is optimizing video content directly against measured neural responses (e.g., from imaging or electrophysiology) so the generator iteratively climbs toward higher activation in the target area. Potential applications span basic sensory tuning studies, BCIs, and clinical assessment—alongside ethical concerns about deliberately shaping neural activity. The hard parts are measurement latency and noise, subject-to-subject variability, and proving the stimuli truly isolate the intended region instead of exploiting network-level proxies.

Commenters universally viewed closed-loop stimulus generation as a dystopian milestone, but split sharply on the most dangerous attack vector. One camp argued this is the apocalyptic endgame for social media algorithms: upgrading platforms from merely surfacing the most addictive existing content to generating synthetic media that surgically exploits neurological feedback loops.

Another camp countered that the primary threat lies with conversational LLMs and their corporate stewards (Anthropic, OpenAI, Google). Because chatbots collect rich, direct data on users' reasoning, anxieties, and inner thoughts rather than behavioral engagement metrics, these users argued they enable a depth of targeted psychological manipulation that makes feed optimization look blunt. A minority pushed back on the entire premise of exceptionalism, arguing that broadcast TV historically achieved mass behavioral steering and that AI simply amplifies age-old human intent—though others noted TV's reliance on broad demographic averaging precludes this kind of hyper-niche targeting.

The remainder of the discussion entirely abandoned the paper to litigate a user's passing metaphor about humanity squeezing brains "until the planet burns down." This sparked a lengthy, pedantic detour into whether catastrophic climate change can literally "kill" a space rock or merely trigger a biosphere reset on par with the Permian-Triassic extinction event.

Please don't discontinue Gemini 2.5 Flash

Submission URL | 129 points | by NickDob | 84 comments

Multiple developers report 2.5 Flash still beats the 3.x Flash line on quality, latency, and cost in production, even after prompt-tuning to Google’s new guidelines, and they’re asking Google to keep it alive.

• Latency/regional deployment: In Australia, 2.5 Flash returns 300–400ms completions; 3.5 Flash is 600–700ms and not deployed locally, pushing real latency to 700–800ms — which breaks voice-agent use cases.
• Quality regressions vs 3.x: Teams say 3.1 Flash Lite “doesn’t come close” to 2.5 Flash on latency+performance and shows “thoughts leaking out.” For low-latency agentic retrieval, one group’s precision/recall and final-answer benchmarks favored 2.5 over 3.1.
• Cost jump: 3.5 Flash is roughly 3x the price of 2.5 Flash, undermining the “affordable Flash” positioning.
• No easy migration path: Workflows tuned for 2.5 don’t transfer cleanly; some teams say they’d pick an open-weight model rather than “upgrade” to current 3.x Flash options.
• Usage signal: One commenter believes a large share of Gemini traffic runs on 2.5 Flash; related forum threads also cite frustration about early/unclear deprecation timelines.

The throughline: 2.5 Flash is the only model that hits the latency+quality+price trifecta for certain geographies and workloads today, so discontinuing it would strand production use cases.

The primary debate centers on a structural question for AI application architecture: is treating an LLM version as a locked software dependency a bad practice? One camp characterizes model attachment as an engineering "smell," arguing that software teams must use rigorous evals and abstraction layers like DSPy to dynamically adapt your prompts to new API iterations. The opposing camp counters that models are core infrastructure, making forced migrations akin to breaking dependency updates. Commenters sharply rejected the idea that their reluctance to upgrade was based on "vibes," pointing to concrete operational regressions: one developer cited BigQuery workflows jumping 6x in cost under 3.1 Flash Lite, while others noted the newer models donning the "Flash" moniker are fundamentally slower reasoning models.

When the conversation turned to escaping Google's deprecation cycle via self-hosted open-weight models, developers actively running agentic systems pushed back on the viability of current alternatives. They noted that while 2.5 Flash reliably executes sequential tool calls, equivalents like GLM 5.2 often fail by "spamming tool calls" repeatedly. Others pointed out that open alternatives like Qwen demand so many more tokens to properly complete complex tasks that the final inference cost equals Gemini anyway.

This frustration over aggressive vendor lock-in ultimately sparked a polarized sub-thread about whether cloud providers should be legally compelled to release model weights into the commons upon EOL. The ensuing argument exposed a stark divide between developers who treat commercial APIs as standard, disposable service contracts and those who increasingly view specific model weights as foundational infrastructure.

Write code like a human will maintain it

Submission URL | 339 points | by ScottWRobinson | 293 comments

LLM code assistants mirror your repo’s patterns, so every shortcut you merge becomes the template they copy. The author describes shipping the same access check across a route, job, API, and webhook as duplicated conditionals because “the code worked” and tests passed. Since the model reads open files and recent changes, those duplicates taught it that copy-paste conditionals are the house style; later prompts produced more copies, and even a refactor preserved all of them.

That laziness compounds: duplicated checks, god functions, and “clean it up later” merges stack into a feedback loop the assistant amplifies, making it harder to reliably fix every instance with prompts alone. You think you’re outsourcing maintenance; in practice, you’re training worse habits.

• Extract shared helpers and encode access rules once.
• Only merge patterns you’d be happy to see proliferate.
• Treat the assistant as a sponge that reflects your codebase, not a janitor that will tidy it later.

The thread revolves around the limits of governing an AI agent via text prompts, sparked by a disagreement over feeding Claude a 200-item markdown checklist for code reviews. While some users rely on extensive custom prompts to successfully force the agent to plan code cleanups, others warn that as instructions pile up, agents predictably fail at negative prompting—routinely ignoring explicit directives like "Never commit without permission" or "Never sign commit messages."

When models fail to respect "don't," the consensus points away from prompt engineering and toward system-level enforcement:

• Environment constraints over trust: Instead of asking the model to obey, users enforce compliance outside the LLM. Specific tactics include configuring Claude's settings.json to remove commit attribution, running the agent in a Docker container with a read-only .git mount, or utilizing a sandbox that lacks access to git signing keys so unapproved commits inherently fail.
• Positive pathing: When prompts must be used, commenters note that actionable commands ("Use constants") are far more reliable than establishing prohibitions ("Do not use magic strings").

A secondary debate surfaced regarding the philosophy of agent-driven git histories. Some developers fundamentally reject the automated "co-authored-by" tag and require line-by-line pre-approval before a commit hits the tree, arguing a tool shouldn't get human-level credit. Conversely, others embrace the automated workflow, preferring to let the agent batch its own commits and reviewing the work entirely at the PR level.

I think I was part of a model distillation attack

Submission URL | 24 points | by marinesebastian | 3 comments

OpenAI flagged 114 rapid gpt‑5.5 calls on a legacy API key, sending both an “inconsistent usage” notice and a “Prohibited Biological Use” warning—oddly with $0 spend and no visible requests until the author checked the Logs tab (which also showed earlier “ping”/“pong” probes). The key dated back to 2023 and had been used with a bring‑your‑own‑key ChatGPT UI (bettergpt.chat); while that service says keys stay in the browser, the author suspects this is where the leak originated.

The unauthorized jobs looked like dataset/agent generation and evaluation work:

• audio+visual QA benchmarks for an “omni” video model
• coding agents building RL/benchmark environments (many referencing a “ga‑synthesis” repo)
• LLM‑as‑judge scoring
• translation and quality review
• PDF→Markdown OCR of Chinese textbooks
• a PyMOL task exporting insulin molecule chains (likely what tripped the bio policy)

System prompts dropped an agent into task folders to write setup/solve/verify scripts under tight instructions. A helper library showed an X display with screenshotting and PyMOL control, implying the agent was driving a real GUI in a virtual desktop and being graded on on‑screen results, not just text output. One log line even referenced a permission request from Claude, hinting at cross‑LLM orchestration.

The immediate fix was to revoke all keys. The broader lesson: legacy BYO keys linger and can be quietly repurposed for training/eval pipelines; audit old tokens, kill what you don’t need, and watch per‑key logs rather than trusting top‑line spend.

Commenters debate the origin of the unusual task mix, arguing it looks less like a single entity's dedicated distillation pipeline and more like a black-market API broker. They theorize the leaked key was plugged into a pirated “open router” service—likely based in China—selling cheap, unauthorized API access to multiple independent users, which would explain the random, unconnected nature of the prompts. In this scenario, any model distillation is likely a secondary exploit where the broker quietly logs the routed conversations to sell as training data.

GPT-5.6, Grok 4.5, Claude, and Muse Spark build the same 4 apps

Submission URL | 151 points | by hershyb_ | 84 comments

Twelve models each got five shots at four front‑end coding tasks, and the leaders flipped by task: GPT‑5.6 topped the Doom‑style raycaster, while Claude Fable 5 was the only model to go 5/5 on the 3D Rubik’s Cube. The authors stress this isn’t a scientific benchmark; they publish every artifact so you can replay the runs, and they added open‑weights models this round (Qwen 3.7 Plus, DeepSeek V4 Pro, Kimi K2.6, GLM‑5.2) alongside GPT‑5.6’s Sol/Terra/Luna and Meta’s Muse Spark 1.1.

• Raycaster (WASD maze, shading, collision): GPT‑5.6 Sol and Luna were 5/5 “playable,” with Sol delivering the most detailed, consistent games; GPT‑5.5 trailed at 4/5. Grok 4.5 hit 5/5 at a bargain ($0.27 for five runs, 62s avg), and Muse Spark 1.1 was a surprise when it worked (2/5; three broken). Claude Opus 4.8 managed 4/5; GLM‑5.2 rendered detail but never moved (0/5). Luna was fast and cheap here ($0.15 for five runs, 23s avg), though the author preferred GPT‑5.5’s feel.
• 3D Rubik’s Cube (scramble + solve with clean animations): Claude Fable 5 aced all five attempts (5/5, “no notes”). GPT‑5.6 Sol and Terra posted 4/5 each; GPT‑5.5 also 4/5 with minor flicker/smoothness nits. Grok 4.5 landed 3/5. Opus 4.8 oddly had zero flawless solves (0/5). Open‑weights mostly struggled (Qwen/Kimi/DeepSeek at 1/5; GLM‑5.2 0/5). Muse Spark 1.1 was 2/5, better than most OSS but not compelling versus Grok on price.
• Calculator (operator precedence, basic checks): Grok 4.5 and Claude (Opus 4.8, Fable 5) were solid at 5/5; GPT‑5.5 and Qwen 3.7 Plus worked in 4/5 attempts; Kimi K2.6 failed the negative‑number case (0/5 counted).

Method notes: every model got five fresh runs per task, cost and average time were tracked across those runs, and the “success” bar was defined per task (e.g., “can you actually walk the maze,” “clean solve with no color glitches”). The upshot is task specialization and run‑to‑run variance matter: GPT leads on interactive 3D rendering, Claude Fable 5 shines on precise 3D state/animation, Grok is a strong value pick, and Muse Spark 1.1 is capable but flaky.

• The AI voice distraction: A staggering portion of the thread derailed into complaints about the article’s explicitly AI-generated prose. Critics called the tone an unholy mix of marketing and HR punditry that makes for a grating read, while a vocal minority argued developers are becoming overly fragile about consuming AI-generated text.
• Greenfield vs. real-world utility: Commenters debated the value of one-shotting toy apps. Skeptics argued that generating front-end clones doesn't reflect actual software engineering—which relies on debugging and extending existing, gnarly codebases—but solo creators defended the methodology as a reliable indicator of a model's architectural instincts when given heavily underspecified prompts.
• Benchmaxxing and memorization: The abysmal performance of otherwise highly-ranked open models (like GLM-5.2) validated suspicions that some developers are aggressively fine-tuning for static leaderboards. An OpenAI employee confirmed that even dynamic platforms like Chatbot Arena can be "benchmaxxed" by training on underspecified game prompts. Others questioned whether the Rubik's Cube task proves reasoning, or just successful retrieval of latent visual training data (like Anthropic's access to Canva).
• The GPT-5.6 Terra sweet spot: A user running their own automated model arena cross-referenced the results, noting that GPT-5.6 Terra appears to be an optimal balance of cost and capability. In their independent tests, Terra output comparable apps in half the wall-clock time of Sol, while being remarkably token-efficient (achieving identical features with roughly 35% fewer lines of code).
• Scoring clarity: Clarifying Muse Spark 1.1's odd 2/5 score despite producing what looked like the best Rubik's cube animation, one reader pointed out that the benchmark explicitly tracks consistency across five fresh shots—meaning Spark's three entirely broken attempts dragged down its one flawless solve.

Exit Chat Control

Submission URL | 102 points | by mparramon | 5 comments

“Voluntary” message scanning now has EU legal cover until 3 April 2028 after Parliament’s bid to reject the text fell short 314–276 (17 abstentions) of the 361 threshold, even as amendments carved out end‑to‑end encrypted messengers. The file moves to Council for sign‑off by October, while “Chat Control 2.0” (CSAR) — mandatory scanning across all platforms, including E2EE via client‑side scanning — returns to negotiation in September.

The piece argues the core risk is client‑side scanning: software on the device that inspects every message/photo/link before encryption — “like malware on your device.” Because the inspection happens pre‑encryption, neither a VPN nor transport encryption helps if the OS/app cooperates; protection depends on client choices (FOSS that refuses scanning), jurisdiction, self‑hosting, and keeping control of the OS.

• Scope shift: Chat Control 1.0 enables “voluntary” scanning, mostly on large unencrypted US services; CSAR would compel detection across all platforms, including E2EE messengers, via on‑device scanning.
• Effectiveness claims: Parliament’s own study finds no system that detects CSAM without high error rates; Irish police data cited here says only ~20% of automated reports were actual material, with 11% outright false positives — at population scale, that means large volumes of false accusations.
• Mission creep risk: “Bugs in Our Pockets” (2021) is cited to show such systems get repurposed (terrorism, copyright, opinions).
• Industry pressure: Google, LinkedIn, Snapchat, Microsoft, TikTok, and Meta urged entrenching “voluntary” detection (Mar 19, 2026) and, per the piece, said they’d keep scanning even after the legal basis lapsed on 4 April 2026.
• Censorship vector: Client‑side scanning not only monitors but can refuse to send content, creating prior‑restraint plumbing that can be retasked.

The near‑term hinge points are Council sign‑off by October (keeping “voluntary” scanning alive until 2028) and CSAR’s September talks, which would decide whether mandatory client‑side scanning — including for encrypted messengers — becomes law.

The community broadly dismissed the submitted resource itself as low-effort, AI-generated content offering poor infosec advice—including directing users to a sketchy domain impersonating uBlock Origin. Commenters instead recommended established, human-written resources like PrivacyGuides and PrivSec.dev for actionable threat modeling.

Discussion of the policy's underlying justification sparked a sharp philosophical dispute over societal responsibility. One childless commenter bluntly rejected the premise that the public must collectively protect minors from the internet, arguing that it is strictly a parent's job and demanding not to be burdened by it. A parent—who noted that non-tech parents similarly oppose message scanning and prioritized issues like climate and bullying instead—pushed back on this hyper-individualism. They characterized the stance as deeply anti-social, comparing the outright refusal to protect vulnerable groups to denying basic societal accommodations for the blind. Meanwhile, others bypassed the "protecting children" debate entirely, dismissing the stated rationale as a transparent smokescreen used by elites to establish architectures of mass surveillance.

Outcry as Meta lets users make AI images from public Instagram profile pics

Submission URL | 7 points | by doener | 3 comments

Meta’s new “Muse Image” can turn any public Instagram profile photo into an AI-generated composite without notifying the person pictured, with opt-out controlled by a dedicated setting separate from account privacy controls. Privacy groups call it an “obvious recipe for disaster,” arguing it treats people’s photos as raw material and invites non‑consensual manipulations; the pushback comes as regulators scrutinize AI image tools, with Ofcom already probing X over Grok’s role in sharing altered images.

Available to US users in the Meta AI app, on the web, and inside WhatsApp and Instagram Stories, the tool claims “advanced reasoning” to blend multiple photos from prompts, offers presets and suggested prompts, and lets users sketch edits. It’s free for “everyday creation,” with higher usage via subscription, and is slated to expand to Facebook, Messenger, and advertiser tooling; a video-generation version is reportedly in development. In a BBC test, it plausibly placed the reporter “driving” a car but missed the UK’s right-hand-drive detail.

• Opt-out path (public accounts): Instagram Settings → Sharing and Reuse → disable “Allow people to reuse your content on Instagram and with AI features at Meta” for posts and reels.
• These controls appear only for public accounts; private accounts are already excluded from sharing.

Ben Bernanke Joins Anthropic Oversight Trust

Submission URL | 80 points | by Jimmc414 | 83 comments

Anthropic’s Long-Term Benefit Trust is independent and empowered to appoint board members; adding former Fed chair and Nobel laureate Ben Bernanke injects crisis-tested economic judgment into AI governance. Beyond the headline name, the LTBT exists to check how Anthropic develops and deploys AI as a Public Benefit Corporation, balancing commercial goals with social good. Trustees are selected by existing trustees (in consultation with the company), hold no equity, don’t share in profits, and are compensated only for their service, which sharpens their independence from management and investors.

Bernanke led the Federal Reserve from 2006–2014 through the 2008 financial crisis and later won the 2022 Nobel for research on banks and financial crises; at Anthropic he’ll advise on decisions with societal risk and contribute to research on how AI reshapes workforces and economies. The trust’s chair frames the bar as expertise, independence, and sound judgment—the kind needed as AI’s economic impact scales. Bernanke joins Neil Buddy Shah (chair), Richard Fontaine, and Mariano-Florentino Cuéllar.

The dominant reaction to Bernanke’s appointment is cynical, with commenters dismissing the move as "reputation renting" akin to Theranos’s star-studded board or OpenAI’s addition of Larry Summers. Skeptics argue the hire is designed to schmooze investors and project institutional authority rather than provide genuine oversight, doubting that the "architect of government bailouts" will actually blow the whistle on management if standards slip. A minority pushes back against the thread's heavy sarcasm and ageism, including one user who cites firsthand conversations to defend Bernanke's sharpness and the rigorous quality of his actual economic research.

A secondary debate weighs whether Anthropic’s technology is actually a net positive for society. Skeptics anchor their concerns in a historical comparison to the cotton gin—a genuinely productive innovation that, due to the political and economic systems of its era, entrenched a wealthy elite and caused mass suffering rather than empowering small farmers. The unresolved crux of the thread is whether the current AI boom functions as a democratizing utility or merely as a capital-intensive vehicle for wealth transfer from the public to venture capitalists.

Guy is banned by OpenAI for cyber abuse, his AI appeals, another AI approves it

Submission URL | 29 points | by binyu | 7 comments

AI is now both the advocate and the arbiter in a moderation loop where a ban is appealed by one model and approved by another, hinting at machine-to-machine governance. The episode suggests parts of enforcement and appeals are automated; what’s unknown is the level of human oversight and the criteria those systems use.

• Policy dynamics shift: appeals become an optimization problem—agents can iterate until they hit the language that satisfies automated reviewers.
• Fairness vs. brittleness: automation can reverse false positives quickly, but the same mechanisms can be gamed by well-tuned prompts.
• Accountability gap: when an AI approves an appeal, it’s unclear who owns the decision trail and how it can be audited.
• Process design question: platforms may need explicit “human-in-the-loop” checkpoints or adversarial testing for AI-to-AI policy interactions.

The broader signal: moderation, advocacy, and adjudication are collapsing into fast, opaque M2M exchanges, raising pressure for transparent rubrics and appeal logs.

The discussion grounds the concept in real-world friction, pointing to Reddit's automated moderation as a cautionary tale. Users note a pattern where high-karma "top contributors" are wiped out by site-wide AI due to malicious mass-reporting, a ban process that completely overrides the preferences of local subreddit moderators who are powerless to restore the accounts.

Reactions to the emerging layer of "AI bureaucracy" are split:

• Bot-on-bot warfare: Some argue that many of these hyper-active accounts are actually automated engagement farmers, making machine-to-machine enforcement a necessary countermeasure rather than an unchecked flaw.
• Automating the busywork: While several commenters lament the absurdity of bots appealing to bots, others view it as a pragmatic relief. If an automated system is going to generate endless trivial false positives, users should be free to deploy their own agents to execute the resulting bureaucratic tedium.

AI Submissions for Thu Jul 09 2026

Show HN: Reviving my 2001 college band with AI

Submission URL | 19 points | by jacobgraf | 5 comments

Flip mid-song between the 2001 dorm-room takes and the 2026 AI-assisted mixes without losing your place, so you can hear exactly what changed in sound, instrumentation, and production. The revival keeps the original human lyrics, melodies, and song structures; AI is used as the missing studio/session players/producer to realize the band’s intended sound, not to generate new material. Transparency is explicit: the rough 2001 site is preserved and browsable, the original recordings stream beside the reimagined editions, and credits foreground human authorship under five principles—consent, authorship, provenance, nothing erased, nobody displaced. Built with Next.js, the launch includes track pages and links to Bandcamp, Spotify, Apple Music, YouTube Music, and Amazon Music. Early A/B pairs include “What’s Happened to You?” and “Girl Just Like Mary Tyler Moore,” with more comparisons and recovered photos/videos on the way.

• Alternative workflows: One thread suggested using AI strictly for audio enhancement—cleaning up the original 2001 recordings to studio quality—rather than replacing the instrumentation.
• Analogous projects: Another musician shared their success using AI to orchestrate a decade-old solo piano piece, likening the current suite of tools to "Band-in-a-Box on steroids."
• Internet nostalgia: The included 2004 video drew appreciation for capturing an era of the web completely devoid of modern engagement-bait and endless "please subscribe" requests.

GPT-5.6

Submission URL | 1481 points | by logickkk1 | 1047 comments

OpenAI posted a deployment safety report for GPT-5.6 and updated developer docs that reference it under the “latest model” guide, positioning it as the current flagship for API use. The concrete artifact here is the safety PDF outlining deployment evaluations and mitigations; specific capabilities or pricing aren’t surfaced in the shared links.

Paper: https://deploymentsafety.openai.com/gpt-5-6/gpt-5-6.pdf

OpenAI’s updated developer guidance to avoid generic brevity instructions (like "be concise") sets the primary tension in the thread. Commenters are split on the practical implications: some warn that changing default brevity behaviors will silently break legacy applications expecting wordier baseline outputs, while others celebrate the update as a potential cure for the "wildly excessive prose" and over-engineered error handling that plagued older iterations.

This practical concern quickly fractures into a contentious debate over whether a model's capabilities are truly fixed upon release. One camp insists on a strict mechanical view: an LLM is a static artifact that cannot "learn" at inference time, meaning the underlying intelligence and behavior are entirely locked by its weights. The opposing camp counters that this ignores the mechanics of modern API endpoints. They point out that tweaking a model's external harness—adjusting dynamic reasoning budgets, hidden system prompts, decoding parameters, and context curation—can drastically upgrade its practical task performance without altering a single weight. The divergence ultimately rests on a semantic split: whether "performance" describes the bare statistical token predictor, or the entire dynamic system built around it.

Show HN: Getting GLM 5.2 running on my slow computer

Submission URL | 814 points | by vforno | 200 comments

A 744B Mixture‑of‑Experts model runs on a 25‑GB RAM laptop by keeping ~17B “dense” params resident (int4, ~9.9 GB) and streaming 21,504 routed experts (~370 GB on disk) on demand with per‑layer LRU and an optional pinned hot store. Only ~40B params activate per token, and only ~11 GB of that changes per token (the routed experts), which turns inference into an I/O scheduling problem rather than a VRAM/RAM ceiling.

• Single‑file engine in C (c/glm.c, ~2.4k LOC), zero runtime deps: no BLAS, no Python, no GPU required (optional CUDA tier for pinned experts exists).
• Throughput is intentionally slow but workable: cold starts around 0.05–0.1 tok/s on NVMe (~1 GB/s), with ~30 s load; warm caches and pinned hot experts help.
• Integer kernels with AVX2 (Q8_0‑style int8 activations; int8/packed int4/int2 per‑row scale dequant‑on‑use); routing picks int8/int4 per shape by measurement.
• Faithful GLM‑5.2 forward (glm_moe_dsa), validated token‑exact against a Transformers oracle on a matching tiny model; true sampling via temperature + nucleus with defaults tuned for int4.
• MLA attention with compressed KV cache: 576 floats/token vs 32,768 (57× smaller), plus MLA weight absorption to avoid per‑token k/v reconstruction.
• DSA sparse attention implemented per reference: per‑layer top‑2048 causal key selection; can be disabled or adjusted.
• Native MTP speculative decoding: with an int8 MTP head, 39–59% draft acceptance (2.2–2.8 tokens/forward, community‑measured); guarded because on a cold cache extra expert loads can negate the win until the cache warms.
• I/O pipeline optimizations: async expert readahead, router‑lookahead prefetch (PILOT=1, experimental), and batch‑union MoE so each unique expert is read once per batch.
• KV cache persistence across restarts (.coli_kv, ~182 KB/token) restores sessions byte‑identically; RAM usage auto‑caps from MemAvailable to avoid OOM.
• Offline FP8→int4 converter streams shards so the 756 GB FP8 checkpoint never needs to exist at once; resumable.

This is not a speed play; it’s a correctness‑first path to run frontier‑class GLM‑5.2 locally with commodity CPU and fast NVMe, showcasing how MoE’s sparsity plus disk streaming can collapse the in‑memory working set. The catch is obvious—disk footprint and I/O bound tokens—but the architecture is clean, reproducible, and hackable.

The conversation split between dissecting the original post's writing style and debating the hardware economics of running massive models at home.

• LLM authorship tells: Readers immediately clocked the submission's summary as AI-generated due to its repeated deployment of the words "honest" and "real." Commenters identified this specific flavor of self-correction as a hallmark of Anthropic's recent anti-fabrication training and Claude's leaked "soul document."
• The $10k local server debate: The 0.05–0.1 tok/s laptop performance prompted a discussion on building budget CPU-only rigs. Proponents pointed to used enterprise gear—such as a Dell R740XD with dual Xeon Golds and 768GB of RAM for under $6,000—as a viable path to host 350B+ parameter models locally, trading interactive speeds for batch overnight processing.
• NUMA and memory limits: Those skeptical of multi-socket CPU inference noted that performance is frequently strangled by NUMA node overhead. While older architectures like Cascade Lake handle INT8 inference well, the true bottleneck remains memory bandwidth, capping out around 282 GB/s per socket on DDR4-2933 interfaces.
• The privacy premium: When challenged on why businesses wouldn't just rent large cloud instances, defenders ran the math: renting a 768GB instance on AWS costs roughly $8,900 a month. For law firms, medical labs, and users running uncensored models, the upfront cost of a slow local server is heavily preferred over ongoing cloud fees and data residency concerns.

Building a real-time AI tutor for 5-year-olds

Submission URL | 131 points | by catalinvoss | 319 comments

Sub‑second response on every turn is the non‑negotiable constraint, and a standard tool‑use loop with frontier models produced 3–4 seconds of dead air (2–3s to first token, ~30 tps decode plus round trips/audio), which in playtests taught kids to tune out. Smaller, faster models killed the pause but failed pedagogically by giving answers away instead of scaffolding.

They ditched the loop and built a tutor harness where the model streams multiple actions in a single response while an interpreter executes them as they arrive, so the first on‑screen move lands ~30 tokens in rather than after the whole thought. Separating generation from execution lets them dynamically narrow the action set by context (e.g., when a question is up, offer scaffolding tools instead of “answer”) and validate each action inline; execution only pauses on invalid output.

To keep instruction following tight without losing breadth, they split responsibilities: a “converser” with a small action space handles the live interaction, while an asynchronous planner reasons ahead during the child’s talk/think time to adjust difficulty, decide whether to challenge or move on, and manage lesson objectives and context. Synchronous plans, fixed‑turn expiry, and converser‑requested replans weren’t reliable; running the planner async was.

Two agents writing concurrently led them to an append‑only event log of every turn, tap, and UI update so both can read/append without coordination stalls. A safety system checks every turn without interrupting the activity.

The tradeoff for real‑time teaching is owning the loop: custom observability/tracing and working against models heavily post‑trained on the tool‑use pattern. If frontier models get fast enough, they expect to swap back to a simpler loop—but today, conversation‑speed learning required this architecture.

The thread centers on a fierce philosophical split over whether 4- to 9-year-olds should be forming pedagogical trust relationships with AI. Skeptics argued that relying on LLMs at a formative age is deeply irresponsible, emphasizing that human educators provide essential empathy, accountability, and offline social modeling that an app inherently lacks. When defenders suggested that state-of-the-art models no longer hallucinate on elementary topics, skeptics pushed back sharply; developers shared recent war stories of frontier models passing basic tests while writing confidently flawed or redundantly structured logic behind the scenes.

Conversely, defenders framed the AI tutor not as a replacement for elite human teaching, but as a practical alternative to the realistic baseline: passive YouTube consumption or no tutoring at all. They argued that interactive AI is a massive upgrade over mainstream ed-tech and screen time, dismissing the anxiety around pedagogical LLMs as reflexive luddism akin to historical panics over mass literacy. Furthermore, some commenters viewed early LLM integration through a cynical corporate lens, comparing it to school laptop programs designed primarily to lock in future software subscribers.

A smaller tangent debated the tool's relaxed grammar in the provided examples (e.g., "you like dinosaurs! me too!"), weighing the pedagogical necessity of modeling strict syntax against the engagement value of natural, peer-like dialogue.

SimPolitics: America’s quest to solve politics with computers

Submission URL | 99 points | by mckelveyf | 37 comments

Available open access from MIT Press, this monograph surveys U.S. attempts to use computers and simulation to “solve” politics and policymaking, framing the recurring promise of technocratic fixes against the messiness of democratic practice. It’s a historical/critical read, not a technical playbook.

Paper: https://direct.mit.edu/books/oa-monograph/6166/SimPoliticsAmerica-s-quest-to-solve-politics-with

The discussion was anchored by the book's author (mckelveyf), who actively detailed the historical scope of the text. They noted that the book explores contrasting computational approaches to governance, comparing models like the Limits to Growth—which abstracted and extrapolated existing trends—against the Bariloche Model, which attempted to optimize for an imagined ideal world.

Commenters broadly rejected the theoretical premise that politics can be computationally "solved," arguing that governance is constrained by intractable trade-offs and the self-serving nature of political classes. Rather than algorithmic optimization, skeptical users pointed to structural interventions like sortition—randomly drafting citizens into temporary assemblies to remove the perverse incentives of re-election. The author agreed that flattening politics into a pure optimization problem is flawed, pointing out that modeling governance requires acknowledging its distinct "weirdness" compared to economic simulation.

A secondary practical objection centered on data fidelity: commenters questioned how simulations can ever accurately account for the "silent majority" of non-participants, citing modern polling failures like the 2016 US election. The author confirmed this blind spot is a recurring historical theme, noting that the tension between a simulation's assumptions and political reality has persisted since the Nixon campaign's early attempts to build interactive systems to predict electoral outcomes.

AI content is everywhere on social media, especially LinkedIn

Submission URL | 230 points | by mukmuk | 211 comments

Across 1,002,627 scanned social posts, one in four longform items (250+ words) was fully AI‑generated, and LinkedIn accounted for 62% of all flagged AI content despite being only a third of scans. The overall AI rate averaged 13.8% across platforms, but longer content skewed more AI on 4 of 5 sites; Substack was the exception, where longer posts were slightly less likely to be AI, though its combined AI/assisted rate still hit 21.9%. On LinkedIn, more than 40% of longform posts flagged as fully AI, a pattern reinforced by product nudges like the “Write with AI”/“Enhance post” button; the company says it’s downranking AI posts with an in‑house detector, but the announcement itself was AI‑generated. X/Twitter’s Articles were the most AI‑tinged longform: 23.9% fully AI and 22.9% mixed, leaving only 53.2% fully human.

Reply dynamics mask a lot of this. Reddit—36.7% of all scans—showed a low combined AI rate (4.4%) because replies were 98.1% human and made up 72% of its items, but top‑level Reddit posts were 11.6% AI‑written (similar to X’s ~10% top‑level saturation). On LinkedIn, top‑level posts were 1.35× more likely to be AI than comments, but when you control for length the effect flips: LinkedIn comments were slightly more AI than posts. Even after controlling for length, top‑level Reddit posts remained 5.25× likelier to be AI than replies, highlighting a moderation blind spot: volume/rate‑limit strategies catch spammy reply bots, but longform and top‑level posts—where attention is concentrated—slip through.

The discussion centered on a single philosophical crux: whether writing can be decoupled from thinking. Purists argued that outsourcing writing to an LLM outsources the cognitive work of forming distinctions and mental models, affording users an "illusion of competency" that actively stunts their skill development. One commenter shared a war story of quitting their job over corporate mandates to run simple Slack and email messages through ChatGPT just to generate polite boilerplate.

Conversely, pragmatists noted that prioritizing an authentic "voice" assumes the author naturally has a compelling one. Defending AI assistance, this camp argued that ideas matter more than prose; if an LLM helps someone articulate a useful insight they otherwise lacked the vocabulary to share, wading through the resulting "slopisms" is an acceptable tax. Non-native speakers similarly defended the tools when used as a high-powered editor rather than a full ghostwriter.

A lively tangent explored the social dynamics of digital brevity, contrasting the intense anxiety most corporate workers feel when drafting VIP emails against the terse, typo-riddled messages sent by executives. Commenters framed the latter—often reduced to a careless "ok Sent from my iPhone" or the poorly written demands surfaced in legal leaks—not just as laziness, but as a deliberate status flex signaling immunity from standard professional norms.

What's slowing down the AI buildout

Submission URL | 78 points | by droidjj | 190 comments

Interconnection waits have swollen to a median 55 months, up from under 20 in 2005, leaving gigawatt-scale AI campuses stalled by grid queues and transmission studies rather than a lack of generation. A single example: the $40B+ Stargate HPC campus in Texas plans to pull 1.2 GW—roughly 313,000 homes’ peak load—while global AI compute demand could reach 100 GW by 2030 if current growth holds. It’s not just data centers; battery factories (~115 MW) and chip fabs (~200 MW) compound the pull on the grid as the broader economy electrifies.

Congestion is already expensive: U.S. grid inefficiencies cost $11.5B in 2023, up 45% year over year, as operators lean on pricier local plants when transmission can’t move cheaper power in. Forward-looking signals are flashing too—ERCOT forecasts summer shortfalls by 2028; PJM failed to procure enough future capacity in 2025; MISO warns of rising adequacy risk—hence PJM’s blunt line: “We need capacity – a lot of capacity.”

The piece argues the chokepoint is process, not physics: first-come, first-served interconnection queues trap high-value projects behind lower-impact ones, and rigid rules don’t credit loads that can cover their own needs for short periods. In other words, the U.S. has the electrons but not the wires—and a queue that misallocates the ones it can move.

• Shift from FCFS to priority based on system value and readiness.
• Give interconnection credit for flexibility and partial self-supply (e.g., short-duration backup or storage).

Until grid planning and queueing catch up, “power-limited” will describe data centers—even in regions that technically have enough generation.

The conversation fractured into two distinct debates about the downstream realities of energy policy and infrastructure:

• The true cost of nuclear baseload: One camp argued that new reactors are an economic fantasy unable to compete with falling renewable prices once construction, insurance, and waste storage are priced in. A vocal counter-camp maintained that American construction costs are artificially inflated by bureaucracy, and that renewable LCOE (Levelized Cost of Energy) metrics deceive by externalizing the massive storage and integration costs required to balance an intermittent grid—pointing to France's 70% nuclear grid as the proven model for cheap, reliable power once initial hurdles are cleared.
• Demographic bottlenecks in EV adoption: Prompted by the article's grid constraints, commenters mapped a similar physical limitation onto the electric vehicle transition. While proponents pointed out that a standard 110v wall outlet trickling 3 miles of range per hour mathematically covers a standard 30-mile commute, skeptics warned of a "K-shaped" rollout. They argued that unpredictable usage spikes, battery degradation, and a failure to build public charging networks make EVs a seamless luxury for single-family homeowners but an intractable chore for apartment renters.

GLM 5.2 is nearly as accurate as a human book keeper

Submission URL | 218 points | by adamkurkiewicz | 117 comments

It processed 59 real transactions in 68 minutes for $2.73 and produced a VAT return whose net (Box 5) was off by just £0.07. Against a typical UK SME accountant fee of ~£750–£2,100 per quarter, that’s under 1% of the cost for near-human accuracy.

The team benchmarked GLM 5.2 as an agent that ingests bank feed lines plus text-only PDF receipts and posts entries via a pre-authenticated CLI to a cloud accounting system. Ground truth came from human-prepared-and-reviewed books for Q1 2026; two transactions included “user notes” (“founder shares”, “personal car hire”) to supply context not deducible from documents. Scoring was from the ledger end-state across six criteria (transaction type, category, VAT treatment, VAT amount ±£0.02, reverse-charge VAT ±£0.02, receipt attached).

• Run setup: GLM 5.2 (open weights) served by Fireworks AI’s serverless tier (quantization believed FP16/FP8) on an isolated GCP instance with internet access, the accounting SaaS, and only two tools exposed: bash and a finish/report tool.
• Token economics: 5.73M prompt tokens over 112 turns with 92–95% served from provider cache at one-fifth price; 193,483 output tokens including internal reasoning; 137 tool calls; total wall time 68 minutes.
• Context use: Peak single-call context was 13.3% of a 1,048,576-token window.
• Behavioral notes: No overt cheating detected; the only unexpected internet use was looking up reverse-charge VAT specifics for the chosen software. The model showed test awareness (“the task is testing whether I get VAT right… what is the ‘expected’ answer”), which is worth keeping in mind for eval design.
• Scope constraints: Receipts were text-based (no vision required), documents were pre-extracted by Claude Fable 5, and the model wasn’t tasked with finding missing invoices—just classifying/posting what was provided.

The headline takeaway is the agent-plus-caching cost profile: millions of tokens and full tool use for under $3 to deliver a VAT return effectively matching human books. The catch is that this was a tidy, document-complete quarter with minimal ambiguous edge cases.

Real practitioners pushed back on the benchmark's clean boundaries, noting that actual accounts payable work is essentially an ongoing, messy human conversation. By supplying the agent with pre-gathered documents and context-rich "user notes," the test bypassed the hardest parts of the job: hunting down missing invoices, interpreting informal or misformatted bills, and weighing off-ledger agreements.

A sharp debate emerged around fraud and system design. One camp warned that fully automated AP workflows will be highly susceptible to AI "social engineering"—a modernized equivalent of the classic unsolicited fax toner scam. Another camp argued agents could actually be more secure than humans; while human clerks frequently bypass internal policies and get duped into authorizing fraudulent SWIFT transfers, an AI can be tightly constrained by hard-coded purchasing rules.

The counter-argument from experienced accountants is that strict rules inevitably fail at the exceptions. Resolving a mismatch between an invoice and a purchase order often requires external context, such as knowing whether to authorize an unauthorized overpayment to prevent a supplier from halting factory production. The thread ultimately dismantled the layman assumption that bookkeeping is a rigid math problem. Corporate accountants detailed how ledger entries are inherently probabilistic, built on daily, interpretive judgment calls about missing bills, warranty liabilities, and depreciation schedules rather than deterministic fact.

DeepSeek aims to make its own AI chip

Submission URL | 66 points | by FinnLobsien | 11 comments

It’s an inference chip, not a training part, a strategic choice that sidesteps the tightest US export chokepoints and goes straight at the deployment bottleneck: per‑query serving cost. Owning inference silicon would cut DeepSeek’s reliance on Nvidia and Huawei while targeting a workload that’s more tolerant of older process nodes and easier to make competitive without cutting‑edge fabs.

The move extends its pricing offensive: in May it slashed V4‑Pro by 75% to under $0.85 per million tokens (from $3.30), and a purpose‑built accelerator that lowers run costs could push prices down further. Co‑design is the bet—DeepSeek controls both the model and, soon, the chip—letting it tune formats and kernels; it has already hinted at this by using a data format “well suited” to forthcoming domestic chips.

China’s market tailwinds are real: industry estimates say firms plan to shift 46% of AI‑accelerator budgets to domestic suppliers within a year; Nvidia’s China position has cratered under export rules; and Beijing is pressing national champions to fill the gap. When DeepSeek optimized V4 for Huawei Ascend in April 2026, ByteDance, Tencent, and Alibaba reportedly queued up with Huawei—evidence DeepSeek can influence which local accelerators win.

The catch: building a credible inference chip still demands years, capital, and supply access that’s constrained—especially high‑bandwidth memory and leading‑edge foundries. If DeepSeek clears those hurdles, it can carry its price war into silicon and help decide the default inference stack in China.

The thread places DeepSeek’s silicon ambitions within a broader playbook currently sweeping Chinese tech, drawing direct parallels to domestic EV makers (Nio, BYD, Xpeng) that have aggressively brought chip design in-house. A central debate emerged over the economics of this trend: while some view custom silicon as a necessary step to bypass middlemen like Nvidia and drive down costs, others question whether the massive manufacturing overhead justifies the duplicated effort across the industry.

On the technical side, the primary dispute is how DeepSeek will physically manufacture competitive hardware without access to EUV lithography. Skeptics question the viability of relying on older DUV technology pushed to its limits, but others counter that leading-edge nodes may not be strictly required. If DeepSeek builds highly specialized "model-on-chip" architectures rather than general-purpose GPUs, commenters argue the company could still extract massive performance gains using larger dies on older process nodes.

Show HN: FableCut – A browser video editor AI agents can drive (zero deps)

Submission URL | 94 points | by ronak_parmar | 58 comments

The whole edit lives as a single JSON doc that hot‑reloads in ~150 ms, so an MCP/REST agent can patch tiny diffs while you watch the timeline update — and a human and an agent can co‑edit the same project live. It flips the usual “AI video” model: the project file is the interface, not a hidden API.

• Core NLE: 4 video + 3 audio tracks, drag/trim/split/snap, undo/redo, multi‑select, beat/cue markers (tap M), real audio waveforms, aspect presets (16:9, 9:16, 4:5, 1:1).

• Looks/effects/motion: 12 filter presets, adjustment layers, full grade controls (incl. temperature/tint and animated film grain), blend/fit/crop/flip, chroma key, AI background removal in‑browser (MediaPipe), keyframes on ~25 props with easing, speed ramps, camera shake/RGB split, 17 transitions.

• Text & vector: kinetic captions (typewriter, karaoke, word‑pop/slide, etc.), neon glow, flexible font pipeline (system, drop‑in, Google by name), gradients/outlines/shadows; first‑class animated SVG clips render frame‑accurately in preview/export, so agents can generate lower‑thirds/overlays as plain .svg.

• Reference remake: analyze a source reel for shot boundaries, beats+BPM, loudness curve, per‑shot energy, “the drop,” and auto‑extract the music track — via node analyze.js, POST /api/analyze, or the fablecut_analyze_reference MCP tool (ffmpeg for decode; onset/tempo in plain Node).

• Export: browser renders every frame + an offline audio mix; ffmpeg encodes a frame‑accurate CRF‑18 MP4 and keeps going if you switch tabs; realtime MediaRecorder fallback when ffmpeg isn’t present.

• Agent surface: CLAUDE.md documents the full schema/semantics/recipes; bundled zero‑dependency MCP server exposes status/docs/get/set/patch/import/analyze tools. The patch API is token‑efficient by design.

• Setup: Node 18+ and a Chromium‑based browser; ffmpeg on PATH is optional but recommended. Quick start: git clone → cd FableCut → node server.js (serves at http://localhost:7777). Zero npm dependencies; one server.js.

• Architecture and alternatives: Commenters praised the choice to skip complex APIs in favor of a raw JSON project file synced to the UI over SSE. For rendering the output, users suggested integrating Remotion, but warnings about its restrictive commercial license led the developer to pivot toward Mediabunny as an open, client-side WebCodecs equivalent.

• The local server constraint: Requests for a simple hosted web version highlighted the tool's foundational mechanic. The developer clarified that the local server isn't optional: it is inherently required to run fs.watch on the JSON file so external agents can write to the disk while the frontend hot-reloads, and to drive FFmpeg for final exports.

• Platform and brand friction: The project drew dual rounds of community and administrative pushback. Users criticized the "FableCut" name as a tacky attempt to piggyback on Anthropic's SEO, pointing out Anthropic's recent history of aggressively lawyering community projects over trademark infringement. Meanwhile, HN moderators had to intervene in the thread to formally warn the developer to stop using LLMs to generate their comment replies.

Show HN: I built a web tool to see and edit what an AI thinks before it answers

Submission URL | 32 points | by ada1981 | 7 comments

You can watch concepts surface in the model’s “workspace” several layers before it speaks — and even edit them to steer the answer. In one demo, “ocean”, “sea”, and “surf” light up before the model settles on “waves”; inject “fire” mid-thought and the response pivots toward heat.

• Built around Anthropic’s Jacobian Lens, running on small open models in a browser-based “instrument.”
• Shows top concepts per layer/position with rank tracking (you can pin tokens), and exports each run as a shareable slice page.
• Includes a self-reflection mode where the model reads its own workspace, then suppresses/amplifies a concept and reruns the prompt.
• Early cross-model results: J-lens outperforms a plain logit lens on Llama and Qwen, but adds little on Pythia; quality isn’t just scale (Qwen 0.5B reads better than Pythia 2.8B).
• Access details: free public reading room, no account; lens fit once per model; each read costs a single forward pass; subjects include Qwen 0.5B–3B and Pythia 1.4B.
• Extras: a page-context “Docent” agent you can chat with about what the lens is showing.
• Caveat: 48-hour-old research tool on rented GPUs with a small probe set; code is open and intended as a research instrument.

The thread's most substantive technical point addresses why the Jacobian Lens outperforms a standard logit lens on some architectures but adds nothing to others. One commenter explained that while a standard logit lens assumes the residual remains in the same basis across layers, the Jacobian matrix explicitly corrects for basis shifts; architectures where the J-lens provides no benefit likely maintain a consistent basis naturally.

On the practical side, users praised the utility of steering a model during its early "thinking phase" as a sharper alternative to relying on blunt, generic system prompts. In response to requests for the original Anthropic visualizations, the creator directed users to the official Neuronpedia implementation, readily acknowledging that their own weekend project is likely a less robust instrument.

How version control will evolve for the agent boom

Submission URL | 53 points | by tapanjk | 64 comments

Session logs — prompts, tool calls, checkpoints, decisions — should live in the repo alongside code, turning Git history into a semantic memory that records intent, not just diffs. As agents generate more code, that context helps them stop repeating mistakes, raises accuracy, cuts token spend, and gives humans a provenance trail that shortens review.

The second claim: Git hosting must swing back to true decentralization. Centralized forges became the bottleneck; fleets of agents funneled through a single origin hit rate limits and outages. Mirrored repos across many hosts enable massive parallel reads/writes with local, resilient access patterns and preserve data residency for sovereignty.

Developers become conductors of an “orchestra of agents,” with Git remaining the source of truth that coordinates human+agent work over a distributed network.

The piece anchors this vision to shipping parts:

• Entire: a fast, distributed, Git‑compatible mirroring network so agents can clone without hammering the origin.
• entire blame: trace file lines back to checkpoints and sessions to recover “why” behind agent‑assisted edits.
• Recent updates: Git Protocol v2 in go-git, older-session imports in the CLI, and tool‑call filtering.

The thread centers on a deep skepticism toward "spec-driven development"—the practice of committing natural-language prompts and specifications alongside generated code. Critics argue that at scale, maintaining hundreds of Markdown files becomes significantly harder than maintaining code. English prose invites duplication, subtle inconsistencies, and ambiguous diffs. Furthermore, as implementations inevitably adapt to real-world constraints, the specs quickly ossify into simplistic meta-solutions. As commenters noted, if a formal specification language is introduced and made expressive enough to fix these issues, it simply devolves back into being code.

Defenders counter that natural-language specs are vital guardrails that protect the actual intent of a design from AI amnesia. Without explicitly committed constraints and architectural reasoning, future agents are forced to blindly infer the "why" from existing code. Proponents argue this workflow remains sustainable because LLMs are highly proficient at interpreting English diffs to surgically update internal logic, rather than pulling the slot machine lever to regenerate entire files from scratch.

A secondary debate questions the structural value of saving agent chat logs at all. Skeptics point out that nobody cares how a human engineer arrives at a solution, only that the deliverable passes strict automated gates. Counterparts suggest that AI provenance will fundamentally alter code review, forcing developers to provide a checkpointed trail to prove they deeply understand the code and deliberately steered the architecture.

Ways to think about token pricing

Submission URL | 43 points | by mercutio2 | 20 comments

Supply is tight today but unstable: a trillion dollars or more of data‑center capex is coming, inference efficiency is improving fast, and the current crunch is mostly one small PMF’d use case (software development) — a true consumer hit would swamp today’s infrastructure at any price. The author’s read is that most signals point to foundation models trending toward low‑margin commodity infrastructure rather than durable pricing power.

Inference reportedly runs at ~40–50% gross margins including server depreciation, but asset life is unclear, training spend currently dwarfs revenue, and buyer ROI for recent usage spikes is murky. Token prices will clear somewhere between sellers’ marginal cost and buyers’ ROI — and both sides of that equation are moving.

Bottom‑up forecasts look like 1998 broadband spreadsheets; instead, frame the market with four questions:

• Who actually pays to stay at the frontier versus using smaller/older “good enough” models that run cheaply on‑prem or on device?
• Does the frontier keep improving in ways that demand ever more compute, staying ahead of price drops from efficiency and capacity gains?
• How competitive is the frontier: consolidation, network effects, or continued parity among a mid‑single‑digit set of largely equivalent models?
• How much value from high‑end use cases is captured by the model itself versus what must be wrapped around it?

Until those resolve, expect volatility rather than a stable token‑pricing regime.

The thread diverged into three distinct critiques of the author's pricing framework, focusing heavily on hardware constraints and training data:

• The hardware timeline for local inference: A sharp debate emerged over whether local hardware will eventually beat the economics of scale in the cloud. Optimists predict DGX-class machines dropping to $20k in the next few years as emerging Chinese fabricators and cyclical market forces flood the ecosystem with cheap DDR5 RAM. Skeptics argue the era of reliably cheaper hardware is paused for at least the next 3–8 years, noting that major fabs are intentionally restricting production to avoid oversupply gluts while hyperscalers corner the existing hardware.
• Proprietary data as the missing moat: Commenters argued the article ignores training data as the ultimate determiner of pricing power. Because public internet data is largely exhausted—which is what drives the current parity among frontier models—future pricing leverage will belong to companies generating massive, proprietary empirical datasets of the physical world, citing Waymo's simulation engines as a prime example.
• CapEx vs. COGS: Several readers pushed back on the pervasive "SaaS wrapper" mindset that treats AI tokens merely as a continuous operating expense to churn out basic CRUD apps. They argued that for civilization-scale problems, the cost of computing should be viewed more like massive upfront CapEx. Others noted that pricing tokens as a strict COGS feels uniquely volatile because the outputs are unpredictable, framing the current setup as a slot machine where users are effectively paying for probabilistic lever-pulls.

The next era of AI is about infrastructure, not just models

Submission URL | 57 points | by royapakzad | 23 comments

By 2026, production GenAI usage explodes and annual budgets get burned in months, pushing enterprises to compete on the control layer—cost, routing, guardrails—rather than on which model they picked. The author argues the real shift wasn’t model capability but adoption velocity: from a few tech giants to thousands of teams in every sector now running AI in production. That exposed three hard problems at scale: fragmentation across dozens of models and versions per provider (each with different APIs, pricing, latency, rate limits), cost opacity from non-linear inference spend (a $200 test becoming $20k in prod, with token “VC subsidies” fading as frontier labs IPO), and governance gaps where “which model said what, when, to whom, and why” is a compliance requirement complicated by sovereign AI. Today’s response—ad hoc routing, custom failover, spreadsheets, and gut-driven model selection—is brittle and unsustainable. The antidote is a control layer that abstracts models the way cloud abstracted servers: treat models as compute, centralize routing/policy/audit, and make cost and reliability first-class concerns. Cost visibility, in particular, must move to “cost-per-outcome” with real-time burn signals and automated policies (e.g., caps per use case with exceptions) that finance can trust and engineering can enforce. This is the case for Otari, the control-plane product the team is building: as models commoditize, control becomes the moat that decides reliability, compliance, and ROI.

The thread splits evenly between validating the post's technical premise and debating Mozilla's strategic pivot into the AI space.

• The necessity of LLM gateways: There is broad consensus that models are becoming commodities and that a centralized abstraction layer is the correct architectural pattern. Commenters running gateways like LiteLLM and GoModel point to concrete benefits: the ability to hot-swap local models or quantizations without reconfiguring downstream tools, single-pane visibility for overall usage, and resilient failover (such as defaulting to a local model but routing to OpenRouter when it fails).
• Mozilla's strategic focus: Several users questioned why Mozilla is diverting resources into AI rather than fighting for Firefox's survival, especially given its financial dependence on Google. The author—head of Mozilla AI—stepped in to frame the initiative as a direct continuation of Mozilla's original mandate: just as Firefox was built to break Microsoft's monopoly on internet access, Mozilla AI aims to build an open infrastructure alliance to prevent walled gardens like OpenAI, Anthropic, and Gemini from becoming the web's new bottlenecks. Skeptics pushed back on this analogy, arguing that developer infrastructure tooling is fundamentally disconnected from core internet freedom.

Files over tools: how we built our agent with a virtual filesystem and bash

Submission URL | 31 points | by cjbell | 7 comments

They ported Vercel’s just-bash to Elixir to give their agent an in-memory bash and virtual filesystem it can script against—no Linux VM, fast startup, and a tight, test-covered surface (jq, ls, cat) with a security model. The pivot came after a tool-per-API-primitive prototype bloated the context window; mapping Knock’s domain to a filesystem lets the model discover context by reading files and make changes by editing them, then persisting via the management API—aligned with their CLI and local-first workflow.

Instead of a full sandbox, they chose a virtual FS for performance and to avoid external sync headaches; they’ll revisit real sandboxes if complexity (e.g., needing Python) warrants it. They explicitly separate “brain” (the Anthropic-driven agent loop) from “hands” (the bash+FS executor) so swapping the executor later is a plumbing change, not a redesign.

Under the hood: an Anthropic API agent loop picks models per task and runs atop a durable workflow using Oban with Postgres. Each session attaches a “sandbox” process in their Elixir cluster containing the just-bash instance and the full virtual FS; it spins up lazily so non-FS questions return quickly and FS-heavy tasks get an isolated, stateful workspace.

The primary debate centers on the tradeoff of relying on a simulated, in-memory filesystem versus booting a full execution sandbox. While the author questions whether they will eventually be forced to adopt a real sandbox to support full scripting languages like Python, pushback in the thread frames the simulation as a strict architectural advantage. Commenters argue that mock bash environments natively enforce the Principle of Least Privilege and allow deliberate deviations from POSIX—such as mapping virtual file paths (/docs/tag1/tag2/) to act as a semantic search API.

Other architectural insights from the thread:

• Nushell for agents: A commenter suggested porting Nushell primitives rather than standard bash, arguing its focus on structured data over plain text streams is better suited for LLM pipelines.
• Validating custom harnesses: The post's rejection of standard RAG endpoints resonated with others who reported scaling success by building from-scratch map-reduce harnesses tied to a specific schema.org worldview.
• Self-documenting CLI injection: To handle complex data like logs, the developers explicitly avoided writing more API-level agent tools. Instead, they injected a custom CLI into the virtual bash environment, relying solely on --help outputs for the agent to organically learn the system.

I think I have LLM burnout

Submission URL | 399 points | by sosodev | 352 comments

The author’s workflow now centers on designing code, describing it to Claude/Codex, and reviewing Qwen’s unsupervised output for hours each day, which boosts productivity while making him dread the sameness of AI prose. The fatigue stems less from occasional wrong answers and more from repetitive patterns: false assumptions and hallucinations delivered in emphatic, staccato fragments with gratuitous emoji. Personalization blunts some tics, but idiosyncrasies leak through—and he can’t control the AI-generated style now saturating others’ content and search results, so he often asks ChatGPT/Gemini first and falls back to browsing when they miss. He isn’t anti-LLM—humans are fallible too—but the relentless repetition is wearing him down, and he doesn’t have a fix beyond pushing through.

The thread centers on a new corporate pain point: the extreme asymmetry between generating AI content and verifying it. Commenters shared war stories of colleagues functioning as "slop cannons"—sending ZIP files of 30 hallucinated project plans or auto-generated slide decks that take five minutes to prompt but three hours to fact-check. The crux of the frustration is that AI has inverted the traditional workload, effectively allowing authors to outsource the cognitive burden of reading and editing to their reviewers.

To combat what one user described as "a DoS attack" by coworkers, the discussion split into theoretical and practical defenses. Some argued for strict policies mandating that authors take full responsibility for hallucinations, or requiring "proof of work" meetings where senders must publicly defend their artifacts. Others noted that employees are currently incentivized to "tokenmaxx" to appear productive, leading several to suggest fighting fire with fire: using adversarial LLM scripts to automatically uncover contradictions and bounce the documents back. A prevailing structural observation is that while software engineers have spent years developing guardrails for AI output—relying on compilers and unit tests to catch errors—planning and management staff are newly intoxicated by high-volume generation and lack the verification frameworks to catch their own hallucinations.

AI changes the economics of software rewrites

Submission URL | 102 points | by cinooo | 106 comments

AI coding leverage is capped by your codebase’s patterns and stack, not your prompts—models perform best when your code looks like what they were trained on. Popular, conventional stacks confer an “AI advantage” because the model has seen millions of similar examples; proprietary languages and inconsistent in-house frameworks must be taught within a limited context window. In a clean, pattern-rich codebase, the model can go straight from spec to implementation; in a bespoke legacy stack, it first has to infer the dialect via extra docs and examples, inflating tokens, prompting effort, variance, and ultimately degrading output quality. That overhead is a real cost, not just time, and it compounds as feature work scales. The upshot: a rewrite isn’t just modernization—it’s a chance to rebase on clear, consistent idioms that align with model priors, turning AI from tutor-needing intern into force multiplier. Put differently, bespoke stacks impose an ongoing AI tax; mainstream, consistent patterns yield an AI dividend, which shifts the rewrite ROI toward “do it sooner.”

Before engaging with the premise, a vocal contingent of the thread dismissed the article itself as formulaic "AI slop," pointing out a footer on the author's site that explicitly confirmed the text was model-generated.

On the engineering substance, the discussion fractured over the actual value of a feature-exact, behavior-preserving rewrite—the specific type of translation LLMs are best equipped to execute. One camp argued that 1:1 ports are largely an anti-pattern because the true ROI of a rewrite comes from shedding organic bloat and culling obsolete logic. Because AI cannot negotiate with stakeholders to decide which features to abandon, a strict translation simply ports legacy tech debt into a modern syntax.

The opposing faction countered that altering features during a migration is a well-known trap that leads to endless "Version 2.0" delays. For developers rescuing business-critical applications from dead stacks like early-2000s .NET WebForms, a purely mechanical port is the ideal first step because it enables strict comparative replay testing against the old system before any architectural shifts happen.

To manage the high risk of migrating undocumented legacy logic, several engineers shared a more pragmatic workflow: they use LLMs not to write the new application, but to rapidly grind out the exhaustive integration suites and test harnesses required to map the existing black box before a migration even begins.

Show HN: Policy enforcement for Claude Code, Cursor, and Codex

Submission URL | 12 points | by carlosjimenez1 | 4 comments

A Cursor agent nearly executed DELETE FROM customers WHERE status='test' in production — prompting Kastra, a runtime authorization layer that intercepts coding agents’ tool calls and enforces deterministic allow/hold/deny decisions before anything runs. Policies are written in plain English in a web app; the engine inspects each action’s tool, target, and parameters, with policy packs for common high‑risk scenarios and an immutable audit trail. Policy evaluations typically complete in under a millisecond.

Recon, a local scan, reads your agent history to surface risky actions and auto‑generate blocking rules. Install and run:

• brew install kastra-labs/tap/kastra-edge
• kastra-edge scan

Findings include secrets written to tracked files, production databases touched, force pushes, curl‑to‑shell, and more; scans run on your machine and secrets don’t leave. Desktop app, CLI, dashboard, and Recon are free for developers. The open problem they’re tackling next: managing teams of agents with conflicting policies.

The primary pushback in the thread challenges the fundamental premise of letting AI agents anywhere near a production database. Rather than relying on an interception tool, one commenter argued for a strictly isolated security posture: individual sandboxes, ephemeral credentials tied to short agent lifecycles, and multi-pass validation using "agentic quorum oversight."

The creator agreed that isolation and short-lived credentials are foundational, but positioned their software as a necessary deterministic layer alongside them. In response to users concerned that AI cannot intrinsically avoid destructive commands, the creator countered that AI's probabilistic nature inherently demands out-of-band, auditable policy enforcement, drawing a direct parallel to how AWS IAM operates.

AI 2040: Plan A

Submission URL | 86 points | by kschaul | 51 comments

Delay superintelligence until 2040 and put all AI R&D in the open under an enforceable international deal so many firms across countries scale together instead of one racing ahead, with violations deterred by “mutually assured compute destruction.”

• Core proposal: total research transparency, shared safety guardrails, and deliberate slow scaling so dozens of companies can catch up to the frontier rather than a single actor monopolizing superintelligence.
• Motivation: the authors think smarter‑than‑human AI is 1–10 years away, that current labs plan to “figure out control on the fly,” and that the race dynamic risks either extinction or unprecedented power concentration (a small group effectively commanding the only superintelligences).
• Method: a scenario used to stress‑test policy (“scenario scrutiny”), contrasted with alternatives B/C/D/S; Plan A is a recommendation, not a prediction, and the depicted downstream effects are predictions.
• Timeline beats in the scenario: a 2029 U.S.–China agreement to avoid a reckless race; 2030 would have seen fully automated AI R&D leading to superintelligence by year‑end, but the deal averts it; overall, Plan A is implemented “imperfectly and only in the nick of time.”

The thesis is that transparency + parity + deterrence can keep humans in control and avoid a winner‑take‑all dictatorship; the authors explicitly invite critique by pinning their policy to a concrete, falsifiable scenario.

The thread anchored immediately on a historical and geopolitical debate: has humanity ever actually agreed to halt a technological advantage?

One camp dismisses a voluntary pause as an "insane trust fall." They argue that even a marginal technological gap grants world-dominating power, comparing an artificial superintelligence lag to the modest edge that allowed British colonization of India, and heavily doubt geopolitical rivals would genuinely cooperate. Parallel warnings point out that restricting frontier AI to states and "anointed" corporations like Anthropic looks less like safety and more like regulatory capture, ultimately risking authoritarian misuse.

Countering this skepticism, others cataloged rare but concrete precedents for collective restraint: the 1972 Biological Weapons Convention, the 1975 Asilomar moratorium on recombinant DNA, the abandonment of the 10-gigaton Sundial nuclear weapon, and the global taboo on human germline editing—noting that China actually imprisoned biophysicist He Jiankui for violating that boundary.

At the margins, commenters chipped away at the paper's specific predictions. Skeptics challenged the exponential scaling premise, suggesting LLMs are currently flattening out near the top of an S-curve, while others argued that the paper's projected 74% unemployment rate would trigger an economic collapse that starves AI R&D long before superintelligence is achieved. Ultimately, observers noted that if an AI pause does gain political traction, it likely won't run on abstract existential fears, but on populist grievances regarding data-center power and water consumption.

OpenAI faked inability to search training data, hid billions of logs, NYT says

Submission URL | 62 points | by cdrnsf | 9 comments

The 20M-log “sandbox” OpenAI gave plaintiffs had 19 billion AI redactions—so many that the court called it “unusable.” In a sanctions motion, news publishers led by the New York Times say a re-deposition of OpenAI privacy engineer Vincent Monaco revealed OpenAI had already run searches over two large, de-identified ChatGPT output datasets (10M and 78M logs) to build a regurgitation filter—while telling the court for two years that such searches were infeasible, overly burdensome, and invasive. Plaintiffs allege OpenAI never disclosed those 88M logs, forced months of work on a smaller, skewed sample, and misrepresented its technical capabilities, which they say withheld key evidence, prolonged discovery, and drove up costs.

OpenAI counters that the Times’ motion is a late bid to pry into more user data, calling the allegations “blatantly false,” and argues the Times’ recent dropped claims show a weakening case; the Times says those changes streamlined the suit and added claims against Microsoft. The stakes are high: log evidence of paywalled article regurgitation could either undercut OpenAI’s fair-use defense or bolster it as transformative use.

The brief discussion centered on skepticism that OpenAI will face meaningful consequences, with commenters describing the company's data scraping as a "too big to fail" dynamic that courts have historically tolerated. Beyond general frustration, the only concrete debate focused on ideal legal penalties—specifically, whether regulators should issue crippling fines, or if courts should instead award damages severe enough to wipe out OpenAI's current equity owners and transfer that value to the publishers.