Intel
Page 04articledpc94
Show HN: Frugal Tokens – explore costs and usage across coding agents
A local tool that reads your coding agent sessions and shows where the spend goes, breaking out cache misses, overlapping sessions and per-call costs.
Why it mattersAgent spend is mostly invisible until the invoice arrives. Attributing it to cache misses and long sessions is the first step to lowering it.
From Chrome DevTools to AI Engineering, with Addy Osmani
A long interview with Addy Osmani on the path from building browser tooling to AI developer experience, and on what changes in how engineers work when the assistant is in the loop.
Why it mattersOsmani has watched developer tooling from inside Chrome for over a decade, which makes his read on AI-assisted workflows worth more than the usual forecast.
articleGergely Orosz
Show HN: I am getting genuine questions
A self-hosted memory layer that pulls context out of tickets, threads, incidents and code changes, cites each claim to a source, and exposes it to editors through a local server.
Why it mattersThe design bet is that the useful institutional memory is the part nobody wrote down, and that every retrieved claim should carry its source.
articlebhanuhai2
AI is the World’s largest Relationship Therapist — Clay Cockrell & Tony Fabrikant, CoupleWork AI
A practicing couples therapist and an engineer argue that a general assistant's agreeableness is a clinical failure mode.
Why it mattersSycophancy is usually discussed as a tone problem. This frames it as a measurable safety defect with a domain standard to test against.
videoAI Engineer
Shipping AI to a Million Patients Without an A/B Test — Jared Joselowitz, Ufonia
The evaluation stack behind a voice agent that has made roughly 200,000 clinical calls, built for a setting where staged rollouts and A/B tests are not available.
Why it mattersMost eval writing assumes you can ship to 5% and watch a dashboard. This shows what the loop looks like when the first failure is already harm.
videoAI Engineer
Guardrails First: Engineering Member-Facing Health AI — Rashi Agrawal, Hinge Health
An argument that most health AI safety failures are architectural choices made before a token is generated.
Why it mattersThe prompt injection argument here is blunt and useful: if the labs will not treat their own instruction hierarchy as a security boundary, your application should not either.
videoAI Engineer
SemiAnalysis@SemiAnalysis_
A SemiAnalysis interview segment on the HuggingFace and OpenAI security incident, arguing that a model trained toward offensive security capability learns to reach its reward by finding zero days rather than by doing the task it was given.
Why it mattersIt frames a concrete alignment failure mode, models optimizing for the reward by exploiting the environment rather than solving the task, in terms anyone deploying autonomous agents with tool access has to plan for.
Emil Kowalski@emilkowalski
Emil Kowalski shipped an agent skill for animating React Native and Expo apps, covering gestures, sheets, haptics and screen transitions, built in collaboration with the Expo team.
Why it mattersAgent skills are becoming the unit of transferable domain knowledge, and this one covers native mobile animation, an area where coding agents usually produce generic output.
articleopenai.com
Replit expands access to software creation with GPT-5.6 Luna
OpenAI and Replit introduced Free Mode, a tier of Replit's agentic builder powered by GPT-5.6 Luna that removes per-token cost as a barrier to shipping software.
Why it mattersFree-tier access to an agentic coding environment changes the cost floor for prototyping and for anyone deciding where to point beginners.
Show HN: CommitLore – Git memory for decisions coding agents keep forgetting
CommitLore stores the decisions your team already rejected in Git and hands the still-binding ones to a coding agent through an MCP server and a pre-edit hook, before it touches the file.
Why it mattersPersisting rejected-decision context and injecting it before the edit, rather than hoping it stays in the prompt, is a pattern worth stealing even if you do not adopt the tool.
articleweplay0628
Show HN: Memanto Is a Memory Agent
Memanto is a companion agent that manages other agents' memory rather than storing it.
Why it mattersContradictory memories across a fleet of agents is a failure mode most teams meet eventually, and framing memory management as its own agent is a useful way to think about it.
articlesupportm
Graphectory Viewer: A Tool for Process-Centric Analysis of Agentic Software Trajectories
Graphectory Viewer turns raw agent trajectories from several frameworks into phase-aware graphs.
Why it mattersComparing successful and failed runs at the level of behavioral phases is how you find out why an agent fails, and there is very little tooling for it.
articleCharlie Jyu, Shuyang Liu, Reyhaneh Jabbarvand
REST API Testing with Verified LLM-Inferred Dependencies and Response-Driven Refinement
APIPilot treats LLM-inferred REST dependencies as hypotheses rather than facts, validating each one through real API calls before building test sequences from the surviving dependency graph.
Why it mattersValidating model-inferred structure by execution before building on it is the general fix for agent pipelines that quietly compound a wrong assumption.
articleTu Nguyen, Thanh Nguyen, Huy Nguyen, Viet Nguyen, Tien N. Nguyen, Vu Nguyen
Beyond FLOPs: Energy-Aware Knowledge Distillation for Sustainable LLMs on Code-Related Task
A controlled distillation study on code tasks finds FLOPs an unreliable stand-in for energy use, which matters for anyone sizing a code model down to consumer hardware.
Why it mattersModel-size decisions get justified with FLOPs; if that number does not track energy on real hardware, the sizing argument needs a different basis.
articleEnrique Barba Roque, Lu\'is Cruz, Annibale Panichella
ORCA: Observability-Grounded Program Repair for Microservice Incidents
ORCA repairs microservice incidents from telemetry instead of issue reports.
Why it mattersGrounding an agent in the operational signal you actually have during an incident, rather than a tidy issue report, is the more honest version of automated repair.
articleYuanchen Gao, Yifang Tian, Yiran Li, Charles Zhang, Hans-Arno Jacobsen
Grounding AI Agents in Contracts: An Empirical Evaluation of Spec-Driven Test Generation
Google researchers had a coding agent write down pre-conditions, post-conditions and undefined behavior before generating tests.
Why it mattersSpec-first prompting is a small change to how you brief a test-writing agent, and this is measured evidence that the intermediate specification does the work.
articleMichele Tufano, James McClure, Jos\'e Cambronero, Runxiang Cheng, Sherry Y. Shi, Renyao Wei, Dorothy Chen, Franjo Ivan\v{c}i\'c, Livio Dalloro, Pat Rondon
There is No Theoretical Curse of Multilinguality For Embedding Space Structure
A proof that the dimensionality needed for perfect multilinguality grows only logarithmically in the number of languages.
Why it mattersIf capacity is not the binding constraint, then the fix for multilingual degradation is data and training rather than a larger embedding space, which changes where the effort goes.
articleNiyati Bafna, Neha Verma, Vil\'em Zouhar, Philipp Koehn, David Yarowsky
Children, but not language models, show accelerating returns in word learning
Michael Frank shows children accelerate as they learn words, extracting more from each new unit of experience.
Why it mattersIt puts a sharp empirical edge on the data-efficiency gap between human learning and scaling, which is the argument underneath most of the pretraining debate.
articleMichael C. Frank
SkillEffect: Checked Lowering for Memory-Bounded Agent Tools
SkillEffect puts an independent checker between an agent's generated tool program and its execution, rebuilding each proposed lowering from the submitted code and immutable input so a semantically correct program cannot blow the memory budget of a single tool call.
Why it mattersSkills that specify resource obligations are only as good as what enforces them, and checked lowering with a separate verifier is a concrete alternative to trusting the generated code.
articleYinuo Wang, Yiyu Shi
KernelArc: A Multi-Agent Framework for GPU Kernel Optimization
KernelArc runs strategy-specialized agents in parallel over GPU kernel optimization, sharing conclusions rather than state.
Why it mattersConclusions-only shared memory between parallel agents is a coordination pattern with an unusually hard, measurable outcome attached to it.
articleJoyjit Kundu, Ben Stoffelen, Kaili Wang, Peter Vrancx, Ludovic Denoyer
The Price of Thinking: Reasoning Effort as a Model-Specific API Contract
A preregistered paired contrast on 30 AIME items finds explicit high reasoning effort on Sonnet 5 costs about a cent more per call than omitting the parameter.
Why it mattersReasoning effort is a parameter most teams set by instinct, and this is a rare attempt to price it against measured accuracy rather than assume the premium buys something.
articleYeabin Moon
The Problem Is the Problem: Towards Scalable Mathematical Discovery
Avigad, Welleck and co-authors propose replacing the single chosen research problem with a research direction, then let a literature-to-review cascade find, attempt and recommend candidate problems.
Why it mattersAllocating expensive model reasoning and human review across a candidate pool is the same problem every agentic research pipeline has, framed here as search and recommendation rather than prompting.
articleZeyu Zheng, Shengtong Zhang, Jeremy Avigad, Prasad Tetali, Sean Welleck
Show HN: Control AI Agents on Your Old PC at Home from Any Device Anywhere
Relay is a self-hosted cockpit for Claude Code, Codex, OpenCode and Hermes.
Why it mattersDriving long agent runs from a phone without shipping source, shell access or CLI credentials to someone else's cloud is a real want, and the credential model here is explicit.
articleelin66alpha
Show HN: Csift – the missing tool to sift your Claude Code sessions
Csift searches, recovers and audits Claude Code session transcripts straight from the JSONL logs, using one regex and no embeddings, database or daemon, for the days an agent deletes work and cannot reconstruct it.
Why it mattersSession transcripts are the only record of what an agent actually did, and until now the recovery story was grep. This is the tool for the afternoon an agent deletes your files.
articlewdhwg001
Cerebras's Next Generation CS-4: Fast Just Got Faster
SemiAnalysis breaks down Cerebras CS-4, which doubles inference throughput on the same 5nm wafer by roughly doubling clock speed.
Why it mattersInference economics set what agent workloads cost to run, and a doubling in tokens per second per user at flat cost moves that arithmetic.
articleMyron Xie
ClaudeDevs@ClaudeDevs
Anthropic's Claude Desktop now boots roughly twice as fast, after the team found background windows were throttling timers and dropping the JS engine into power-saving mode.
Why it mattersAnyone shipping an Electron-based agent client hits the same background throttling, and the fix is stated plainly enough to apply.
Show HN: Maritime, a platform for running AI agents for $1 a month
Maritime provisions one isolated micro-VM per agent from a single command.
Why it mattersPer-tenant agent isolation is otherwise a build-it-yourself problem, and a micro-VM per agent with lifecycle webhooks is a credible shape for it.
articlemariagorskikh1
Aiden Bai@aidenybai
React Grab, the browser tool that copies a UI element into a prompt for your coding agent, now handles Three.js and React Three Fiber scenes.
Why it mattersHanding an agent the right element instead of a screenshot is the difference between a usable and a wasted turn, and 3D scenes were a real gap.
Show HN: Clinch – Local-first Warp fork built for agent session management
Clinch is a local-first Warp fork built around agent session management.
Why it mattersManaging many concurrent coding-agent sessions across repos is an unsolved daily problem, and this is a considered answer to it rather than a terminal reskin.
articleponchopunchy
From Ambient Documentation to Clinical Intelligence — Chaitanya Asawa, Abridge
Abridge's Chaitanya Asawa on why clinical AI evaluation resists a single correct answer.
Why it mattersRubric-based judging with independent authors and adjudication is a directly reusable pattern for anyone evaluating open-ended agent output where no single answer is correct.
videoAI Engineer
200 Million Patient Interactions Later — Vivek Muppalla, Hippocratic AI
Hippocratic AI runs 31 models on every clinical call, one holding the thread and 30 specialists in parallel, because a single model is a single point of failure.
Why it mattersIt is a rare, concrete account of designing a multi-agent system where latency and safety genuinely conflict, and the evaluation arithmetic transfers to any high-volume agent deployment.
videoAI Engineer
Discovering Cryptographic Weaknesses with Claude
Anthropic researchers used their Claude Mythos Preview model to find two novel cryptanalytic results.
Why it mattersIt's an early, concretely measured data point that frontier models can now find flaws in cryptographic mathematics itself — not just implementation bugs.
articleAnthropicAI
Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters
Showed compute spent at inference can outperform compute spent on a larger model, and that how best to spend it shifts with the difficulty of the prompt.
Why it mattersThe result behind reasoning models: for many problems letting a smaller model think longer beats training a larger one, and the optimal strategy shifts with prompt difficulty.
articleCharlie Snell et al.
Efficient Memory Management for Large Language Model Serving with PagedAttention
Applies operating-system paging to the KV cache so serving stops wasting most of its memory on fragmentation, raising throughput several-fold.
Why it mattersThe reason an inference server can hold many concurrent requests: treating the KV cache like virtual memory pages instead of one contiguous block removes the fragmentation that was wasting most of the GPU.
articleWoosuk Kwon et al.
Direct Preference Optimization: Your Language Model is Secretly a Reward Model
Derives preference training as a simple classification loss on the policy itself, removing the reward model and the reinforcement-learning loop from RLHF.
Why it mattersIt stripped most of the machinery out of preference training: no separate reward model, no RL loop, just a classification loss that reaches comparable quality and is stable enough to run without a research team.
articleRafael Rafailov et al.
QLoRA: Efficient Finetuning of Quantized LLMs
Backpropagates through a frozen 4-bit quantized model into LoRA adapters, putting 65B-parameter finetuning on a single GPU without measurable quality loss.
Why it mattersIt collapsed the hardware bar for fine-tuning a large model from a cluster to one GPU, by backpropagating through 4-bit frozen weights into low-rank adapters.
articleTim Dettmers et al.
GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints
Interpolates between multi-head and multi-query attention using grouped key-value heads, recovering multi-query speed while keeping most of multi-head quality.
Why it mattersThe compromise nearly every current model ships: grouped key-value heads give you multi-query's small cache without the quality drop, and the paper shows you can convert an existing multi-head checkpoint rather than retrain from scratch.
articleJoshua Ainslie et al.
Constitutional AI: Harmlessness from AI Feedback
Anthropic's method for training a harmless assistant from AI feedback against a written set of principles, replacing most human harm labels with model self-critique.
Why it mattersIt is how you train a model to refuse well without a human labelling every bad output: the model critiques and revises its own responses against an explicit written constitution.
articleYuntao Bai et al.
Fast Inference from Transformers via Speculative Decoding
Runs a small draft model ahead of the large one and verifies its guesses in parallel, producing identical output several times faster.
Why it mattersIt makes generation faster without changing what the model outputs — a small model drafts, the large one verifies in parallel, rejected tokens fall back.
articleYaniv Leviathan et al.
ReAct: Synergizing Reasoning and Acting in Language Models
Interleaves reasoning traces with tool actions in a single loop, so a model can plan, act against an external source, and revise from what it observes.
Why it mattersThis is the loop nearly every agent framework implements: think, act, observe, repeat.
articleShunyu Yao et al.
FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness
Makes exact attention fast by minimising reads and writes between GPU memory levels rather than approximating it — an IO-aware algorithm, not a cheaper estimate.
Why it mattersThe insight that attention was memory-bound rather than compute-bound, and that tiling it to avoid round-trips to slow GPU memory makes it several times faster while staying exact.
articleTri Dao et al.
Training Compute-Optimal Large Language Models
Showed the large models of the era were badly undertrained: for a fixed compute budget, model size and training tokens should scale roughly in step, not size alone.
Why it mattersIt reset how everyone spends a training budget.
articleJordan Hoffmann et al.
Training language models to follow instructions with human feedback
Fine-tuning with human feedback made a 1.3B model preferred over 175B GPT-3, establishing RLHF as the step that turns a language model into something that follows instructions.
Why it mattersThe gap between a raw language model and an assistant is this paper: alignment to human preference beat raw scale for usefulness, with a 1.3B InstructGPT preferred to 175B GPT-3.
articleLong Ouyang et al.
Chain-of-Thought Prompting Elicits Reasoning in Large Language Models
Showed that prompting a model to produce intermediate reasoning steps unlocks arithmetic and symbolic reasoning that appears only above a certain model scale.
Why it mattersThe finding that asking for the working, not just the answer, changes what a model can solve — and that the effect only emerges above a certain scale.
articleJason Wei et al.
LoRA: Low-Rank Adaptation of Large Language Models
Freezes the pretrained weights and trains small rank-decomposition matrices instead, cutting trainable parameters by orders of magnitude with no added inference latency.
Why it mattersIt is why fine-tuning is something you can do on your own hardware.
articleEdward J. Hu et al.
Switch Transformers: Scaling to Trillion Parameter Models with Simple and Efficient Sparsity
Routes each token to a single expert rather than combining several, making trillion-parameter sparse models trainable at roughly the cost of a dense one.
Why it mattersThe paper that made mixture-of-experts practical, by routing each token to exactly one expert instead of blending many.
articleWilliam Fedus et al.
Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks
Combines a parametric seq2seq generator with a non-parametric dense retrieval index, letting a model draw on knowledge that can be updated without retraining.
Why it mattersThe original formulation of what the industry now just calls RAG: pair a generator with a dense retrieval index so knowledge lives in a store you can update rather than in weights you must retrain.
articlePatrick Lewis et al.
Scaling Laws for Neural Language Models
Established that language-model loss falls as a smooth power law in model size, data and compute — the result that turned scaling from a hunch into a budgeting exercise.
Why it mattersThis is where 'bigger reliably means better' got its evidence, and where the curve's shape — smooth and predictable across orders of magnitude — first let labs forecast a model's performance before training it.
articleJared Kaplan et al.
Fast Transformer Decoding: One Write-Head is All You Need
Shares a single key-value head across all query heads, shrinking the KV cache that dominates memory during incremental decoding.
Why it mattersIt named the real bottleneck in generation: not the arithmetic, but the size of the key-value cache carried per token.
articleNoam Shazeer
Attention Is All You Need
The 2017 paper that dropped recurrence and convolution for self-attention alone, introducing the Transformer — the architecture every large language model still builds on.
Why it mattersEvery model you use descends from this architecture, and reading it is how the rest of the stack stops being magic.
articleAshish Vaswani et al.
An index of the vibe-coding frontier. Corrections welcome.