Activation Steering: One Dial, Two Costs
Activation steering edits a model's internal activations to add or remove a concept at inference time. This explainer maps its one control knob, its two costs, and when it beats prompting.
Loading…
Topic
LLMs
669 posts about LLMs. Every summary links to the original.
- 669 posts
- 49 companies
- 5 explainers
See the idea
LLMs explainers
Antibodies as a Prediction Pipeline: Where AI Models Break Down
Antibody discovery is a three-stage prediction pipeline, and AI models that excel on familiar targets degrade sharply on unfamiliar ones. This explainer maps where that gap appears and what it costs.
Agent Memory: What Outlives the Run
Agent memory is the knowledge that survives a run, not the working state inside one. This explainer separates the two, then maps the write path, the read path, and the database limits that cap recall.
The Good Stuff
Paid picks we use ourselves. Links carry a referral code — a subscription through one earns us a commission at no extra cost to you.
Newest first
Posts
Compose Multiplatform 1.12.0 Released
JetBrains has announced the release of Compose Multiplatform 1.12.0 with targeted capabilities for artificial intelligence integrations, web rendering, and desktop application layouts. The update incorporates an experimental Model Context Protocol server inside Compose Hot Reload, allowing AI agents to trigger reloads, capture screenshots, inspect the semantic tree, and simulate user interactions directly. For web deployments, the framework now provides automatic font fallback by downloading necessary Noto font subsets on demand when unresolved characters occur during rendering. Desktop developers receive an experimental v2 window and dialog application programming interface in the androidx.compose.ui.window.v2 package, which distinguishes requested states from actual window states and permits precise control over positioning, sizing constraints, and multi-screen placement. These combined enhancements improve developer workflows and runtime flexibility across multiple target platforms.
How AI observability works with MLflow
Traditional application monitoring treats AI workflows as black boxes, leaving engineering teams unable to determine whether incorrect responses result from model hallucinations or erroneous upstream tool data. MLflow provides AI observability by capturing distributed traces containing model calls, prompts, retrieved context, execution latencies, and tool interactions. In an example mortgage lending application, trace inspection revealed that an AI assistant accurately summarized raw JSON data returned by an internal pipeline tool rather than hallucinating conflicting metrics. Beyond latency attribution and tool debugging, MLflow is compatible with OpenTelemetry and provides automatic tracing integrations for frameworks such as LangChain and Claude Code. Capturing these traces enables teams to evaluate subsequent application versions, detect model provider shifts, and identify tool regressions before reaching users.
Try the Ansible playbook generation lab with Gemini and OpenAI
The official Visual Studio Code extension for Red Hat Ansible Automation Platform includes an automation coding assistant, formerly called Ansible Lightspeed. Initially integrated with IBM watsonx, the extension now supports Google Gemini and OpenAI-compatible endpoints through Red Hat AI. An updated interactive lab demonstrates these capabilities through an end-to-end scenario involving database installation and HTML landing page deployment across two nodes. Learners write natural language prompts to generate Ansible playbooks and roles, evaluate output, and utilize real-time automated linting and integrated documentation. By serving an open-source model through a preconfigured OpenAI-compatible endpoint, the refreshed environment removes external credential setup steps.
GRPO fine-tuning on Red Hat OpenShift AI: Reinforcement learning from verifiable rewards with Training Hub
Supervised fine-tuning for structured reasoning tasks like tool calling often demands expensive, labor-intensive dataset curation. Group Relative Policy Optimization (GRPO) resolves this by using programmatic reward functions to score multiple candidate responses without requiring human labels or a dedicated reward model. On Red Hat OpenShift AI, developers can implement GRPO using Training Hub, Kubeflow Trainer, and the Kubeflow SDK to fine-tune models like Qwen3-4B. The setup utilizes vLLM for candidate generation alongside LoRA weight updates, sharing storage via ReadWriteMany persistent volume claims. In a practical tool-calling test, five training iterations raised task accuracy from 33% to 67%, teaching the model to emit parseable function invocations rather than fabricated conversational text.
PROOF-Gen: From Optimized Data to Better Distillation
Standard distillation pipelines for tool-calling agents use generate-and-filter supervised fine-tuning on teacher trajectories, discarding failed trials and missing training signals on hard scenarios. On τ 2-bench, 57% of teacher trials fail, with two-thirds being near-misses undone by a single error. PROOF-Gen (Per-scenario Reflective Optimization to Overcome Failed Generation) addresses this loss by employing a reflector that reviews execution traces and evaluation feedback to craft corrective guidance for the teacher. Once passing trajectories are generated, this scaffold guidance is stripped so students train on clean demonstrations. Per-scenario prompt optimization recovers 93% of failed scenarios on τ 2-bench, boosting Qwen3-4B-Instruct-2507 Passˆ1 from 0.132 to 0.529 and lifting deployed on-device model performance across all locales.
IDEA Prune: An Integrated Enlarge-and-Prune Pipeline in Generative Language Model Pretraining
Recent advancements in large language models necessitate efficient deployment options within constrained inference budgets. While structured pruning offers better token efficiency than training target-sized models from scratch, previous work frequently ignores the pretraining of enlarged models. To resolve this gap, researchers developed an integrated enlarge-and-prune pipeline that unifies enlarged model training, pruning, and recovery under a single cosine annealing learning rate schedule. This system incorporates an iterative structured pruning technique to gradually eliminate parameters, redistributing model capacity across surviving neurons and avoiding the knowledge loss seen in naive approaches. Evaluated on compressing 2.8B parameter models to 1.3B across up to 2T pretraining tokens, the approach yields superior downstream model performance.
Restore LLM Inference Capacity in Seconds with Shadow Engine Recovery in NVIDIA Dynamo
LLM engine process failures typically trigger cold restarts that reload weights into HBM, compile kernels, and recapture CUDA graphs, leaving surviving workers to absorb displaced traffic for minutes. Shadow engine recovery, a preview feature in NVIDIA Dynamo, keeps a fully initialized standby on the same GPUs as the active engine. GPU Memory Service (GMS) preserves one physical weight copy across engine processes, while the parked shadow precomputes its CUDA context, graphs, communicators, and mappings but defers KV cache materialization. In a GLM-5.2 test, the shadow resumed service in 7.3 seconds after a worker failure, compared with 283 seconds for a cold restart, reducing post-fault p50 TTFT from 23,815 ms to 1,311 ms and improving decode rate from 12 to 46 tok/s/user. The preview does not cover hardware, node, or multi-node failures and currently starts promoted shadows with empty KV caches.
How Capital Markets Finance Protects Balance Sheet Returns
Capital markets finance must protect returns on a balance sheet exposed continuously to market, funding, and liquidity risk, while funding costs, capital consumption, and liquidity needs can change intraday. Fragmented desk P&L, treasury, and risk data require shared business context, with ontology and governance linking numbers to desks, products, positions, funding, capital, and permissions. Databricks’ Genie One is presented as a data-smart AI coworker that lets authorized finance users investigate governed data, trace emerging funding or profitability issues, and surface the definitions and source evidence behind capital and valuation figures. One top global bank reduced regulatory data processing for liquidity reporting from 10 hours to 8 minutes, while pricing, funding, risk, and capital decisions remain with accountable people.
Granite 4.2 LLMs: How They're Built
Granite 4.2 is IBM’s first family of dense, decoder-only reasoning language models, offered in 3B, 8B, and 30B sizes. The models use a shared design built around Grouped Query Attention, Rotary Position Embedding, SwiGLU, RMSNorm, bfloat16 precision, and separate input/output embeddings; each has a 131,072-token sequence length. Pre-training starts from scratch on approximately 15 trillion tokens across five phases, with the final phase extending the context window to 512K tokens. Supervised fine-tuning uses about 7.2 million samples spanning agentic and non-agentic data, followed by multi-stage reinforcement learning; the 8B and 30B models also receive agentic RL in sandboxed environments for tool use, code execution, terminal control, and web search. All models support thinking, non-thinking, and low-effort thinking modes, native tool calling, and Apache 2.0 licensing.
Quantization-Aware Healing: a compressed, 4-bit model that outperforms its full-precision original
Structural compression and 4-bit quantization can reduce an LLM’s reasoning, mathematical, and coding capabilities, while conventional healing methods either require costly quantization-aware training or distill from an already degraded checkpoint. Quantization-Aware Healing (QAH) instead distills the original, full-size, full-precision model into a structurally compressed student running in MXFP4, using KL divergence over teacher logits. A chunked KL loss allows healing on documents up to 32k tokens within a fixed GPU memory budget. Applied to GPT-OSS 120B compressed to 60B parameters, QAH’s 4-bit model outperformed its 60B bfloat16 counterpart on 7 of 9 benchmarks, including gains of 7.4 points on AA-LCR and 5.6 on AIME 2025. In a separate comparison, QAH reached its peak about seven times faster than QAT and avoided QAT’s later 19-point collapse.
Ideas Worth a Longer Conversation: The JetBrains Research Podcast
The JetBrains Research Podcast investigates foundational software development and computer science questions through discussions with industry researchers. In team psychology, Cat Hicks demonstrates that collaborative culture and organizational belonging reduce developer anxiety around automated tooling while curbing the risks of overproduction pressure. Historical analysis by Tomáš Petříček shows that programming spans five competing cultures rather than pure specification implementation, explaining why automated code generation historically encounters limits. Regarding artificial intelligence evaluation, Ibragim Badertdinov details how SWE-rebench isolates model capability through dataset decontamination, leveraging the strict verifiability of software test execution for training feedback. Additionally, conversations with Alexander Kulikov and Anna Kogan examine how foundational mathematical understanding aids AI oversight and address adoption hurdles for open-source computer vision infrastructure.
Inside LinkedIn's cognitive memory agent for agentic personalization
LinkedIn built a cognitive memory agent to deliver personalized experiences across its recruiter workflows and hiring assistants. Interactions between recruiters and agents often reveal recurring preferences, such as candidate criteria, role adjustments, and task habits. To preserve and manage this state throughout the entire lifecycle, the system organizes user data into a multi-tiered memory architecture. This structure comprises conversational, semantic, episodic, and procedural memory tiers that track everything from ongoing sessions to cross-session behaviors and workflow methods. LinkedIn continues to research memory abstractions, dynamic session compaction, virtual file system storage layers, and robust evaluation approaches for attribution across complex multi-source application agents.
Auth0, Made for Whatever You Are Building
Rapid application development with AI coding tools often produces unreviewed custom authentication logic that handles sensitive Personally Identifiable Information and regulatory requirements like HIPAA. Autonomous AI agents compound these security challenges by significantly widening an application's overall attack surface. Standardizing on Auth0 provides an established identity layer that integrates into agentic workflows via Claude plugins, an Auth0 MCP server, and standardized agent skill packages. This setup exposes Auth0 Management APIs and official documentation directly to AI agents, achieving integration times of three to four minutes according to Agent Experience metrics. Incorporating these pre-built patterns maintains security baselines while supporting scaling requirements across B2B plans for initial user bases up to 1,000 monthly active users.
STARFlow2: Bridging Language Models and Normalizing Flows for Unified Multimodal Generation
Existing multimodal models struggle with structural fragmentation, often sacrificing visual fidelity via discrete tokenization or breaking structural symmetry by pairing causal text generation with diffusion-based denoising. STARFlow2 addresses these limitations by leveraging autoregressive normalizing flows, which share the causal mask, key-value cache mechanism, and left-to-right structure of large language models. Built upon the Pretzel architecture, the system vertically interleaves a frozen pretrained vision-language model stream with a TARFlow stream through residual skip connections under a single causal mask. A deep-shallow flow design combined with a unified FAE latent space allows both text and continuous visual outputs to enter the key-value cache directly without re-encoding. Benchmark experiments validate strong performance across multimodal understanding and continuous image generation tasks.
From Prediction to Action: How to Turn AI Outputs Into Decisions
Salesforce addressed an operational challenge where sellers faced roughly 12,000 dashboards and over 20 applications outputting machine learning predictions without clear next steps. The engineering team reframed machine learning outputs as raw signals rather than standalone answers. To bridge the gap between assessment and action, they built a Next Best Action layer that combines model signals, business logic, and contextual institutional knowledge into actionable recommendations. They integrated this layer with an AI agent using Model Context Protocol (MCP) tool contracts, enabling dynamic discovery and explicit handling of missing data. Finally, rather than introducing a separate dashboard destination, the agent serves on-demand recommendations directly inside Slack where sellers already collaborate.
Your alt text passes automated checks. That doesn’t mean it’s any good.
Automated accessibility checkers reliably flag missing alt text attributes but frequently miss unhelpful descriptions like raw filenames or repetitive labels. To evaluate image description quality without generating excessive false positives, GitHub built an alt text plugin for the GitHub Accessibility Scanner. The tool combines five deterministic, zero-credential rules that evaluate strings and visual layout spacing with an opt-in vision model check for subjective context. Page context including headings and surrounding prose is extracted alongside images to guide the model using structured outputs and explicit anti-nitpick instructions. While deterministic checks catch unwritten text, the model-driven rule serves as an opt-in prompt for human review rather than an absolute verdict.
How Databricks Uses AI to Accelerate Incident Investigation
Databricks describes AI SRE, an AI-powered debugging agent for operating hundreds of microservices across more than 1,500 Kubernetes clusters, 70+ regions, and three clouds. It addresses incident investigations by assembling context from platform health, service telemetry, changes, dependencies, and team-specific runbooks, with automatic triage followed by interactive, natural-language investigation. The platform uses layered primitives, purpose-built APIs, and a core orchestration engine; team-owned agentic runbooks encode domain procedures, while controlled access and evidence links support auditing. The post reports support for more than 150 teams, 250+ weekly active users, and over 2,000 daily investigations, with users saving several hours of debugging time.
Help AI Coding Agents Write Up-To-Date Code With Modern Golang Skills
AI coding agents often generate outdated Go patterns because older syntax dominates training data and new features fall past model cutoffs. To address this gap, the GoLand team released Modern Go Guidelines, an open-source set of skills and CLI tools covering Go 1.0 through Go 1.27. The tool inspects a project's go.mod file or a specific version flag to supply only the language features and standard library additions compatible with that environment. Using a progressive disclosure approach, the CLI provides concise rule identifiers via a list command and expands into before-and-after examples through an explain command. This mechanism minimizes token consumption while helping agents produce up-to-date, compilable code without modifying project files.
How We Optimized the Qwen 3.6 Model for Our Junie Agent
Deploying the Junie coding agent locally on Apple MacBook M5 hardware requires overcoming steep performance bottlenecks during model execution. Engineers optimized the entire stack using Qwen3.6-27B rather than Qwen3.8-27B, which severely degrades without token-heavy reasoning enabled. At the agent layer, Junie appends requests directly into a rolling context and caches initial prompt prefixes to maximize KV-cache reuse across tasks. For model inference, the team disabled reasoning, selected 4-bit quantization, and patched MLX-VLM to execute self-attention prefill matrix operations using faster 8-bit instructions on the M5 processor. Combining these prefill improvements with simultaneous multi-token prediction and n-gram speculative decoding delivered up to a 2x generation speedup.
Junie Can Now Run Entirely on Your Mac – No Credits, No Cloud
JetBrains has introduced Junie Local, a feature that runs the Junie coding agent entirely on local hardware without cloud dependencies, subscriptions, or credit meters. Users execute a single command inside Junie to download a 4-bit quantized Qwen3.6-27B model, requiring an Apple M5 Mac with 64 GB of RAM. The team prioritized prefill throughput over pure generation speed by utilizing 8-bit arithmetic instructions on the M5 Neural Accelerator, which increased prefill throughput by approximately 40%. Performance optimizations also include KV-cache reuse, speculative decoding to double generation speed, and disabling reasoning to preserve performance. In JetBrains' evaluations, the local configuration performed comparably to cloud-based Sonnet 4.5 on everyday tasks while ensuring source code, diffs, and prompts never leave the local environment.
Related topics
All topics →Weekly digest
The best engineering reads, once a week.