Coding Tools

Claude Code v2.1.311 fixes critical session stability bugs

This release targets the most frustrating friction points in Claude Code's daily workflow: infinite hangs and data loss. By fixing subagent MCP tool availability and resolving context compaction errors that previously crashed sessions, Anthropic is smoothing out the rough edges of autonomous coding. The patch also corrects Remote Control session behaviors and improves startup times for Pro users, signaling a shift from feature expansion to reliability engineering.

Claude Code v2.1.312 patches critical session and Slack bugs

This release stabilizes Claude Code’s core reliability by fixing how it handles large context files and session resumption, addressing pain points that previously caused data loss or silent failures. The VS Code extension now properly surfaces organization policy errors instead of crashing silently, while cloud sessions gain a more intuitive Bash editor and clearer effort indicators. Slack integration sees targeted fixes for thread routing and network access, ensuring the agent behaves predictably in enterprise channels. These are quiet but necessary corrections that make the tool less fragile during complex, multi-step workflows.

llama.cpp b11935 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing first-class ROCm 10.0 support to both Linux and Windows. AMD GPU users no longer need workarounds, effectively closing a long-standing parity gap with NVIDIA's CUDA ecosystem. The inclusion of Snapdragon CPU/GPU/NPU builds for Linux is another strategic win, targeting the growing wave of AI PCs on ARM architecture. While KleidiAI on Apple Silicon is disabled in this specific build, the broader platform coverage makes this a critical update for anyone running local models outside the standard CUDA setup.

llama.cpp decouples sparse attention from mask shape

This release quietly fixes a structural bottleneck in llama.cpp's attention mechanism. By decoupling k-pool sparse selection from the dense kq_mask shape, the code now supports newer architectures like Qwen4exp and GLM5-next without forcing them into legacy layout constraints. The change allows dense masks to shift layouts independently, meaning sparse layers no longer break when mask structures evolve. It’s a backend refinement that expands hardware and model compatibility without changing the user-facing API.

llama.cpp b11940 adds deferred tool support

This release quietly fixes a critical gap in local LLM integration by adding support for deferred tools and tool_reference content parts. Previously, complex function calling workflows often broke or required workarounds; this update aligns llama.cpp more closely with standard API behaviors for agentic loops. It ensures that models can properly handle multi-step tool execution without crashing the inference pipeline. For developers building autonomous agents locally, this means fewer edge-case bugs and smoother integration with frameworks expecting standard tool-use patterns.

llama.cpp exposes reasoning effort levels in server

The llama.cpp server now officially supports exposing reasoning effort levels like minimal through max via the chat template. This allows clients to probe and select specific inference depths for models capable of extended thinking, such as those using Chain-of-Thought. By serializing these capabilities into JSON properties, developers can dynamically adjust how much 'thought' a model performs before responding. It turns a previously implicit or hardcoded behavior into a configurable API parameter, giving builders precise control over latency versus reasoning quality.

llama.cpp adds /v1/realtime API for live voice

The b11946 release transforms llama.cpp from a batch inference engine into a real-time voice service. By adding the /v1/realtime endpoint, it now supports streaming conversation and transcription compatible with OpenAI's realtime protocol. This allows local models to handle audio input and output without external orchestration layers. The update fixes slot concurrency issues to prevent mixed outputs during simultaneous sessions. Local inference just gained a native path for live voice agents.

GitHub Copilot adds server-to-server auth for orgs

GitHub Copilot finally decouples AI usage from individual human logins, allowing GitHub Apps to authenticate directly via short-lived installation tokens. This shift moves billing and policy enforcement to the organization level, letting agents operate at scale without hijacking personal credentials or hitting user quotas. It effectively transforms Copilot from a developer assistant into an enterprise-grade infrastructure component that organizations can govern, audit, and budget independently of their workforce.

Firefox Smart Window adds AI form filling and page monitoring

Mozilla is pushing Firefox’s Smart Window into practical utility with two distinct features: AI-driven form filling and passive webpage monitoring. The form filler ingests data from open tabs—like a LinkedIn profile—to populate job applications, routing the context through Google’s Gemini 3.1 Flash Lite for generation. Simultaneously, users can now set up persistent watchers for sales or job listings that trigger desktop notifications when changes are detected. This marks a shift from passive browsing assistance to active task automation within the browser environment.

GitHub Copilot Assisted Permissions GA

GitHub Copilot’s assisted permissions are now generally available across CLI, the app, and VS Code, shifting how AI agents interact with your environment. Instead of manual approval for every command or file access, an LLM evaluates requests to distinguish clearly safe actions from those needing human sign-off. This reduces friction for routine tasks while maintaining a safety net for risky operations like opening URLs or accessing sensitive paths. Enterprise admins retain control to block 'Allow All' modes but can enforce assisted defaults, balancing developer velocity with organizational security policies.

llama.cpp b11880 release with CUDA 13 and ROCm 10

This release quietly cements llama.cpp as the universal inference runtime by adding default builds for CUDA 13.4 and ROCm 10.0 alongside existing CUDA 12 support. Users on NVIDIA's latest drivers and AMD GPUs no longer need to compile from source to get hardware acceleration, significantly lowering the barrier for local deployment. The update also patches a critical security issue where truncated GGUF files could cause crashes, ensuring stability for production workloads. While KleidiAI is disabled here, the broadening hardware support makes this a practical necessity for anyone running models on modern GPUs.

llama.cpp respects no_alloc in memory caches

This release fixes a critical memory management bug where the `no_alloc` flag was ignored in certain internal caches. For users running models on constrained hardware or integrating llama.cpp into larger applications, this ensures predictable memory behavior and prevents unexpected allocations that could crash processes. It’s a stability fix rather than a performance boost, but essential for robust deployment.

llama.cpp b11882 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing first-class ROCm 10.0 support to both Linux and Windows. AMD GPU users no longer need workarounds, effectively closing a long-standing parity gap with NVIDIA's CUDA ecosystem. The inclusion of Snapdragon AI stack binaries for Linux marks a significant step toward on-device efficiency on ARM hardware. While KleidiAI on macOS is temporarily disabled, the broader platform expansion makes this one of the most practical updates for local deployment across varied hardware setups. The addition of CUDA 13.4 builds ensures compatibility with the latest NVIDIA driver stacks on both Ubuntu and Windows. This update addresses fragmentation by standardizing support for major accelerator architectures. ROCm 10.0 support removes the last major barrier for AMD GPU users running local inference. Snapdragon binaries enable optimized AI execution on emerging ARM-based mobile and edge devices.

llama.cpp fixes 4D tensor quantization for MoE models

This release patches a critical bug in llama-quant that silently dropped data when processing 4D tensors, a common shape in modern Mixture of Experts architectures. By switching to ggml_nrows() and using name-based detection for expert layers, the tool now correctly handles complex model structures like MLA projections without special-casing specific implementations. The fix ensures imatrix sizes align with actual tensor dimensions, preventing corruption during quantization. Users running non-expert 4D convolutions or specialized MoE variants can finally trust the output integrity.

llama.cpp b11884 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing ROCm 10.0 to Linux and Windows alongside CUDA 13. AMD GPU users no longer need workarounds for modern stacks, while NVIDIA's CUDA 13.4 builds ensure forward compatibility with the latest drivers. The standout addition is native support for Linux arm64 Snapdragon devices, bridging the gap between mobile NPUs and local LLMs. Apple Silicon KleidiAI is disabled here, a notable step back for Mac users who rely on that specific optimization. For everyone else, this is just another solid step toward hardware-agnostic local AI.

llama.cpp b11886 adds Qwen merge and ROCm 10

This release quietly fixes a critical gap for Qwen model users by merging tensors during conversion, ensuring compatibility without manual intervention. The inclusion of ROCm 10.0 builds alongside CUDA 13 support significantly widens the hardware net for AMD GPU owners running local inference. While KleidiAI on Apple Silicon is temporarily disabled, the core update stabilizes the runtime for a broader range of accelerators and architectures. It’s a maintenance-heavy release that keeps llama.cpp relevant as model ecosystems evolve.

llama.cpp b11887 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing ROCm 10.0 to Linux and Windows alongside CUDA 13.4 builds, effectively closing the gap for AMD GPU users who previously lagged behind NVIDIA. The standout addition is native support for Linux arm64 Snapdragon devices, enabling local AI on mobile-class hardware with CPU, Adreno GPU, and Hexagon NPU acceleration. While KleidiAI on Apple Silicon has been disabled in this build, the expansion to Qualcomm's ecosystem signals a strategic push into edge computing. Readers can now deploy optimized models on a wider variety of non-NVIDIA hardware without compiling from source.

llama.cpp fixes grammar rejection for long tokens

A subtle but critical bug in llama.cpp's grammar engine was silently rejecting valid outputs from models using large vocabulary tokens, such as GLM-4.7 and Laguna-S-2.1. The previous recursive implementation hit a depth limit based on token character count, causing immediate failures for any token exceeding 256 characters. By switching to an iterative stack-based approach, the fix not only resolves these crashes but also speeds up grammar sampling across several major models. This ensures structural constraints like JSON or list formats actually work with modern architectures that use extended vocabularies.

llama.cpp b11889 fixes CUDA warnings

This is a maintenance release for llama.cpp that swaps variable-length arrays for std::string in the CUDA backend. The change silences Clang warnings and modernizes the codebase without altering inference performance or adding new features. It ensures smoother compilation on strict C++ compilers, keeping AMD ROCm and NVIDIA CUDA builds compatible with current standards.

llama.cpp deepseekv4.1 follow-up fixes

This release tightens the DeepSeek V4.1 implementation in llama.cpp by removing redundant F32 memory requests during matmul operations, directly addressing efficiency bottlenecks in router and indexer layers. By moving Engram padding logic into core model parameters, the codebase sheds a dedicated model class, simplifying maintenance for one of the most demanding open architectures. These changes reduce VRAM pressure and improve inference stability without altering the model's capabilities. It is a quiet but necessary optimization for anyone running DeepSeek V4.1 locally.

Claude Code v2.1.309 patches sandbox and git security

This release tightens Claude Code's security posture by fixing critical loopholes in its sandboxing and permission systems on macOS and Linux. The team addressed issues where symlinked paths could bypass write denies and where background commands might lift sandbox restrictions, ensuring isolated sessions remain truly isolated. Git operations also received significant hardening, particularly around worktree isolation and the handling of replace refs, preventing unintended side effects during code reviews. These fixes stabilize the developer experience for teams relying on strict security boundaries in automated or CI environments.

Claude Code v2.1.310 release notes

This update stabilizes Claude Code for enterprise and complex local environments by fixing critical gateway compatibility issues that previously caused request failures. It adds essential monitoring tools for Bedrock, Vertex, and Foundry, giving teams better visibility into telemetry and nonessential traffic. The release also resolves frustrating bugs around file cleanup, permission prompts, and cloud session error handling in VS Code. These changes make the tool more reliable for heavy usage and stricter security configurations.

llama.cpp fixes Qwen4-exp tensor shape bug

A subtle but critical fix for Qwen4-exp models in llama.cpp. The previous implementation failed to reshape the fused query-key selection tensor when multiple streams were active, causing a graph reserve assertion error. This patch aligns the internal layout with the expected kq_mask structure, allowing multi-stream inference to proceed without crashing. It’s a quiet stability win for users running these specific architectures.

llama.cpp b11846 enforces DP4A tile alignment

This release fixes a critical compilation constraint for NVIDIA GPUs using DP4A instructions. By enforcing that MMQ tile heights are multiples of the warp size, it prevents silent failures or crashes on specific hardware configurations. It also disables KleidiAI on Apple Silicon for this build, likely due to stability concerns. CUDA 13 support is expanded with version 13.4 libraries across Linux and Windows. This ensures smoother inference for users relying on newer NVIDIA toolchains without manual workarounds.

llama.cpp fixes AMD RDNA3/4 HIP builds

AMD GPU users on RDNA3 and RDNA4 architectures finally get working local inference with llama.cpp. A subtle type mismatch in the HIP backend prevented compilation for gfx11 and gfx12 chips, effectively locking out modern Radeon cards from ROCm acceleration. This patch aligns the operand vector types with LLVM builtins, restoring hardware support without requiring version-specific workarounds. It’s a quiet but essential fix that widens llama.cpp’s reach beyond NVIDIA and Apple Silicon.

llama.cpp adds Soprano TTS support

Local inference just got a voice. By integrating the Soprano-80M model into mtmd, llama.cpp now runs text-to-speech entirely on-device using a Qwen3 backbone and Vocos decoder. This isn't just another API wrapper; it's a self-contained audio generation pipeline that respects privacy by keeping data off remote servers. The release ships with binaries for CUDA 12/13, ROCm, and Apple Silicon, making high-quality TTS accessible to developers who need offline capabilities without the latency of cloud calls.

llama.cpp aligns mtmd resize with torchvision

Precision drift in image preprocessing has been a silent killer for vision models running locally. This commit fixes that by forcing llama.cpp's mtmd backend to replicate torchvision's bilinear and bicubic resize algorithms exactly. By matching Pillow's weight precision rather than using its default high-precision floats, the output pixel values now align with the reference implementation. This eliminates the 1% error rate that caused subtle mismatches in models like d1-omni and LFM2.5-VL. Local inference for these specific vision architectures is now mathematically consistent with their training pipelines.

Copilot API now tracks non-IDE tool usage

GitHub finally closes the blind spot in Copilot analytics by exposing a totals_by_client array that captures model traffic from external tools like OpenCode and Claude Code. This shift moves visibility beyond IDE telemetry to server-side request counts, allowing admins to see exactly which agents and CLI tools are driving token consumption. It’s a necessary governance update for enterprises where developers increasingly bypass VS Code for specialized coding agents. The data now distinguishes between user-selected models and product-chosen ones, providing the granularity needed to manage costs across a fragmented toolchain.

GitHub Public Monitoring Adds Triage and API

GitHub’s public monitoring for leaked secrets finally gets the operational tools it needed. Instead of just listing exposures, enterprises can now dismiss alerts, track activity timelines, and filter by repository or secret type directly in the dashboard. The addition of REST APIs and webhooks allows security teams to integrate these findings into existing incident response pipelines rather than managing them in isolation. This shifts public monitoring from a passive visibility tool to an active component of enterprise security workflows.

GitHub Apps now installable at enterprise level

GitHub finally closes the gap between organization and enterprise automation by allowing GitHub Apps to be installed directly on enterprise accounts. This move replaces the reliance on classic Personal Access Tokens for high-privilege workflows, granting apps granular control over governance rulesets, security policies like IP allowlists, and administrative settings. It is a critical infrastructure update for enterprises managing complex compliance and security postures across hundreds of organizations. The feature lands in GHES 3.24, enabling more secure, scalable automation without the token sprawl that plagued previous setups.

AI ports disrupt retro gaming preservation

AI coding tools are accelerating retro game ports to a pace that is breaking the collaborative decompilation community. Hobbyists can now rebuild classics like Ocarina of Time for mobile in weeks instead of years, but this speed comes at the cost of deep code understanding and community trust. A major tracking site recently shut down due to hostile forks and bad actors abusing open-source projects. While preservationists fear losing the knowledge of how games were built, industry giants like Xbox are already exploring these possibilities.

GitHub Copilot Visual Studio September Update

The September update shifts GitHub Copilot in Visual Studio toward a more autonomous agent model, requiring the new Agent mode for Bring Your Own Model (BYOM) support. This architectural change breaks backward compatibility with previous Ask and Agent modes, forcing users to reconfigure Ollama and other external providers. Simultaneously, NuGet vulnerability fixes are now automated via MCP servers, allowing Copilot to patch packages directly from the Error List. The move signals a tightening integration between IDE workflows and external model deployments, prioritizing agent-driven automation over simple chat assistance.

Hugging Face launches Trainium compatibility lookup

AWS Trainium has long suffered from a fragmented ecosystem where developers wasted time guessing which models would actually compile. Hugging Face’s new Space solves this by providing a definitive, searchable database of tested TorchNeuron compatibility for popular text and image-text models. It doesn't just list names; it provides the exact run scripts, sharding configurations, and pre-compiled NEFF graphs needed to skip the painful compilation step on trn2 instances. This removes the guesswork from deploying open-source models on AWS hardware, turning a potential integration nightmare into a simple copy-paste workflow.

GitHub Copilot metrics now name custom agents and MCPs

GitHub finally stops hiding internal AI tooling behind generic 'other' buckets. The updated usage metrics API now reports the specific names of custom skills, agents, and MCP servers, letting admins see exactly which internal tools developers are adopting. By expanding the visible list from five to twenty-five entries per record, it captures the long tail of niche integrations that actually drive productivity. This shift transforms Copilot telemetry from a vague usage counter into a genuine adoption dashboard for enterprise AI governance.

GitHub adds public monitoring for data residency regions

GitHub Enterprise Cloud now extends secret scanning to public commits for customers in data residency regions, closing a major blind spot. Because strict tenant isolation prevents sharing enterprise rosters with the main github.com infrastructure, the system relies on verified domain matching to attribute exposed credentials back to the correct organization. This ensures sensitive alerts are encrypted and delivered within the designated geography without leaking membership data across boundaries. It is a practical fix for enterprises that previously had no visibility into their code leaks in public repositories.

Claude Code v2.1.305 fixes critical sandbox and retry regressions

This release patches a significant regression in v2.1.304 where tool search failures on Vertex or Bedrock caused every request to fail; Claude Code now gracefully retries without it. It also expands Linux sandbox capabilities by allowing nested user namespaces, enabling tools like rootless Podman to function within the secure environment. The update resolves several edge cases in subagent worktree management and cloud session scheduling, ensuring more reliable autonomous workflows. These fixes stabilize the agent's interaction with external APIs and complex local environments.

Claude Code v2.1.306 fixes cloud auth and MCP errors

Anthropic quietly patched two specific friction points in Claude Code's cloud environment. The update resolves a regression where the CLI failed to authenticate inside cloud sessions without explicit environment variables, a common hurdle for remote workflows. It also corrects an API error handling issue that incorrectly reported 'prompt is too long' when using many MCP tools, preventing unnecessary context compaction. These are stability fixes rather than feature additions, ensuring the tool behaves as expected in complex setups.

Claude Code v2.1.307 patches stability and API versioning

This release quietly stabilizes the agent runtime by fixing critical race conditions in MCP server connections and retry logic that previously caused silent failures or double-executions. The most significant shift is the explicit /claude-api api-version flag, signaling a move toward structured API contract management rather than implicit behavior. Bug fixes for context window aliases and proxy certificate handling remove friction for enterprise self-hosted runners, while improved error reporting in cloud sessions makes debugging tool calls less opaque. It’s a maintenance-heavy update that prioritizes reliability over new features.

llama.cpp b11799 adds ROCm 10 and CUDA 13 support

This release quietly closes the hardware gap for non-NVIDIA users by adding default builds for ROCm 10.0 on both Linux and Windows, meaning AMD GPU owners no longer need to compile from source to get decent performance. The inclusion of CUDA 13 alongside the existing CUDA 12 builds ensures compatibility with the latest driver stacks without breaking older setups. While Apple Silicon support remains available, KleidiAI optimizations are currently disabled in this specific binary set. It is a pragmatic update that keeps llama.cpp relevant across the widest possible range of consumer and enterprise hardware.

llama.cpp b11800 adds fused top-k mask op

This release tackles a specific performance bottleneck in attention mechanisms by introducing a fused ggml_top_k_mask operation. Instead of building masks with separate fill and add steps, the new kernel handles QSA scoring for models like Qwen4exp and GLM5-Next in one go. It also extends support to DeepSeek V4's CSA build, ensuring consistent behavior across different architectures. The change is available on CUDA 13, ROCm 10.0, and Apple Silicon, making it a practical optimization for developers running these newer model families locally.

llama.cpp b11802 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing first-class ROCm 10.0 support to both Linux and Windows. AMD GPU users no longer need workarounds, effectively closing a long-standing parity gap with NVIDIA's CUDA ecosystem. Equally notable is the new Linux arm64 build targeting Snapdragon chips, which unlocks local LLM execution on high-performance mobile hardware via CPU, Adreno GPU, and Hexagon NPU acceleration. While KleidiAI on Apple Silicon has been disabled in this specific binary set, the expansion into non-NVIDIA desktop and mobile silicon marks a significant shift toward hardware-agnostic local AI.

llama.cpp b11806 adds Prism LoRA and ROCm 10

This release quietly expands llama.cpp's adapter compatibility by supporting prism.hadamard folded weights, a specific optimization that improves efficiency for certain fine-tuned models. The build matrix now includes ROCm 10.0 for both Linux and Windows, signaling better support for AMD GPUs in local inference workflows. CUDA builds have been updated to include version 13.4 libraries alongside the existing 12.x support, ensuring compatibility with newer NVIDIA driver stacks. While no new model architectures are introduced, these updates tighten the ecosystem's ability to run specialized, optimized LoRA adapters across a wider range of hardware accelerators.

llama.cpp b11808 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing ROCm 10.0 to Linux and Windows alongside CUDA 13.4, effectively closing the hardware gap for AMD users who were previously left behind. The standout addition is native support for Linux arm64 Snapdragon devices, enabling local AI on mobile-class silicon with CPU, Adreno GPU, and Hexagon NPU acceleration. While KleidiAI on Apple Silicon has been disabled in this build, the broader expansion to Qualcomm and AMD ecosystems makes it significantly more versatile for heterogeneous hardware setups.

llama.cpp adds WebGPU Q2_0 support

WebGPU finally gets the ultra-low-bit quantization it needed to run models in browsers without choking memory. By implementing row dequantization and matrix multiplication for Q2_0, llama.cpp allows extremely compressed models to execute directly on client-side GPUs. This closes a critical gap for web-based inference, letting developers ship smaller, faster AI experiences that previously required server-side processing. It is a technical win for efficiency in the browser.

GitHub CLI adds expiring OAuth tokens

GitHub CLI v2.103.0 shifts the security baseline by introducing opt-in expiring OAuth tokens that refresh automatically in the background. This moves away from indefinite access tokens, meaning a leaked credential expires within hours rather than remaining valid forever. The implementation relies on git 2.46+ to prevent caching issues and requires scripts to fetch tokens fresh each time they run. It is a quiet but necessary hardening of developer workflows that reduces the blast radius of credential theft without breaking existing setups.

GitHub bulk migrates branch protections to rulesets

GitHub finally solves the tedious migration from classic branch protection to the more powerful ruleset system. The new bulk import feature lets admins convert all repository protections in one go, with a preview step that catches overlaps and split-rules scenarios before they happen. This removes the manual friction of updating policies across dozens of branches or repos, making it significantly easier for teams to adopt granular bypass permissions and pattern matching. It’s a practical quality-of-life update that accelerates the shift toward modern, scalable governance.

GitHub Secret Scanning: Base64 Tokens & Audit Log Changes

GitHub is closing a significant blind spot in secret scanning by detecting Base64-encoded tokens in private repositories, automatically decoding them to trigger revocation. This moves beyond simple regex matching to handle obfuscated secrets that often slip through traditional checks. Simultaneously, the audit log business field shifts from display names to slugs, a breaking change for automation that relies on human-readable identifiers. These updates tighten security posture while forcing developers to harden their integration logic against structural API changes.

Dependabot API adds dependency versions

GitHub finally closes a painful gap in its security automation by exposing the exact installed version of vulnerable dependencies via the REST API. Previously, syncing alerts to external tools required parsing lockfiles or making extra GraphQL calls just to know which specific package version was at risk. Now, the new version_requirement field delivers this data directly in alert responses and webhooks. This removes a significant friction point for teams automating vulnerability remediation across their entire stack.

GitHub launches package firewall for npm

Supply chain attacks are shifting from code injection to dependency poisoning, and GitHub is finally building a dedicated defense. The new package firewall acts as an install-time policy gate, inspecting metadata and downloads before they reach CI runners or coding agents. It currently checks against the GitHub Advisory Database and flags supply-chain anomalies like attestation downgrades for npm packages. This moves security from a post-install scan to a pre-execution block, directly addressing the vulnerability of automated systems that lack human oversight during dependency resolution.

Dependabot adds npm 12, pnpm 11/12, and Bun 1.4 support

GitHub finally caught up with the modern JavaScript ecosystem, adding native support for npm 12, pnpm 11 and 12, and Bun 1.4 to Dependabot. This is a critical infrastructure update for developers who have migrated away from legacy package managers but were stuck without automated security patching. While dependency version updates will work immediately, there is a known limitation with pnpm 12's new dual-document YAML format that currently breaks alert generation and security scanning. Until GitHub resolves this graph detection issue, users of the latest pnpm versions are flying blind on vulnerability notifications.

Claude Code v2.1.304: Security hooks and auto-mode setup

This release tightens the leash on Claude Code's autonomy while making it easier to configure for new projects. The addition of decider permissions for tool checks means mods can no longer bypass permission dialogs, forcing explicit approval for sensitive actions. Auto mode now features a guided setup that reads your project structure to teach the agent about your environment, reducing friction for first-time users. Performance improvements in subagent responsiveness and memory usage address previous bottlenecks in complex coding sessions.

llama.cpp b11739 release with ROCm 10 and CUDA 13

This release quietly cements llama.cpp as the universal inference runtime by adding default builds for ROCm 10.0 and CUDA 13.4 across Linux and Windows, effectively closing the gap with NVIDIA's proprietary stack for AMD users. The inclusion of Snapdragon support on Linux marks a significant step toward ARM-native AI acceleration beyond Apple Silicon. While KleidiAI is disabled on macOS for now, the broader platform expansion means developers no longer need to compile from source to target modern hardware. This is infrastructure work that makes local inference accessible on more diverse and powerful machines without extra effort.

llama.cpp b11740 adds OpenCL i32 support

This release quietly fixes a gap in llama.cpp’s OpenCL backend by adding integer row access and copy conversions. While CUDA and ROCm have long dominated local inference, this patch ensures that OpenCL devices—common on AMD and Intel GPUs outside NVIDIA ecosystems—can handle specific data types without fallbacks or errors. It doesn't introduce new models or speedups, but it stabilizes the runtime for a broader range of hardware configurations. For users relying on non-NVIDIA accelerators, this is a necessary step toward parity.

llama.cpp adds OpenCL cooperative-k DP4A GEMM

This release quietly improves OpenCL performance for specific quantization formats by adding cooperative-k DP4A GEMM kernels. It targets q4_0, q4_k, and q6_k models, which are common choices for balancing speed and quality on non-NVIDIA hardware. The update also fixes alignment issues that could cause crashes or incorrect results on certain OpenCL implementations. While not a massive architectural shift, it tightens the gap between OpenCL and CUDA/ROCm for these specific workloads. Users with AMD or Intel GPUs relying on OpenCL will see more stable and potentially faster inference for these quantizations.

llama.cpp adds Carbon-14B DNA tokenizer support

llama.cpp finally supports the Carbon-14B HybridDNA tokenizer, closing a gap for genomic AI inference. The update handles auto-tagging of untagged DNA runs and fixes special token registration for older Carbon models like the 500M and 3B variants. This means researchers can now run these specialized biological models locally without custom conversion scripts. It’s a niche but critical fix for anyone working with bio-LLMs on edge hardware.

llama.cpp adds P2P server access via --connect

The llama.cpp server gains a peer-to-peer tunneling feature that lets you expose local inference endpoints to the internet without manual port forwarding. By leveraging the existing llama-connect infrastructure, this experimental flag simplifies remote access for developers who need quick, secure connectivity from anywhere. It removes the friction of configuring firewalls or reverse proxies for personal AI projects. While marked as experimental, it signals a push toward more accessible local model deployment.

llama.cpp b11748 fixes SYCL quantization bug

This release is a quiet but necessary patch for Intel GPU users running reordered quantized weights. The core fix addresses a get_rows error in the SYCL backend that previously caused inference failures on specific weight layouts. While Apple Silicon KleidiAI builds are temporarily disabled, the update restores stability for ROCm 10.0 and CUDA 13/12 environments. It’s not a feature drop, but it keeps the local inference stack from breaking for users relying on non-standard quantization schemes.

llama.cpp b11750 adds ROCm 10 and CUDA 13 support

This release quietly closes the hardware gap for local inference by adding default builds for ROCm 10.0 and CUDA 13.4 across Linux and Windows. AMD GPU users finally get parity with NVIDIA in terms of supported driver stacks, while Apple Silicon KleidiAI is explicitly disabled here, likely due to stability concerns. The inclusion of Snapdragon support on Linux marks a significant step toward ARM-based AI acceleration outside of mobile. There are no new model architectures or quantization methods, just broader runtime compatibility for existing weights.

AnyLanguageModel 1.0 unifies local and hosted AI in Swift

Hugging Face’s AnyLanguageModel 1.0 finally solves the fragmentation problem for Swift developers by abstracting away the chaos of multiple inference backends. Instead of writing separate logic for Core ML, MLX, llama.cpp, or cloud APIs like OpenAI and Anthropic, you now use a single Foundation Models-compatible API. This means an iPhone app can seamlessly switch between a local 3GB Gemma model and a hosted 120B parameter model without changing the core session code. It effectively turns Hugging Face into the universal adapter for Apple’s AI ecosystem, lowering the barrier to entry for hybrid intelligence architectures.

GitHub Copilot Model Policy API GA

GitHub finally exposes programmatic control over which AI models are available to enterprise users. The new REST API allows admins to enforce model restrictions at the enterprise, team, app, and organization levels via GET and PATCH endpoints. This shifts Copilot governance from manual UI clicks to automated infrastructure-as-code workflows. Enterprises can now standardize compliance and security postures across thousands of developers without relying on brittle browser automation.

GitHub Copilot deprecates legacy models in Oct 2026

GitHub is quietly retiring its older Copilot models across chat, inline edits, and agent modes. This forces a migration to newer architectures for both individual developers and enterprise admins managing model policies. The move signals that GitHub is consolidating its inference stack, likely to improve performance or reduce costs by phasing out legacy reasoning paths. Users must actively verify their settings to ensure access to supported models before the cutoff.

CodeQL drops macOS 27 and Swift 6.4 support

Apple’s removal of Intel binaries in macOS 27 breaks CodeQL’s traced extraction, effectively killing static analysis for C/C++, Java, and Swift on the latest Xcode. This forces developers to pin workflows to older runner images or switch to build mode none, adding friction to CI pipelines just as Swift 6.4 launches without support. The deprecation of Intel Macs by late 2026 signals a permanent shift in the Apple ecosystem that security tooling must now explicitly manage rather than assume compatibility.

Hugging Face TorchNeuron brings native PyTorch to AWS Trainium

Hugging Face is finally making AWS Trainium feel like a first-class citizen in the PyTorch ecosystem. By replacing the legacy Optimum Neuron compiler with TorchNeuron, they enable eager execution and native distributed primitives like FSDP directly on the hardware. This shift means standard libraries like Transformers and TRL now run on Trainium without custom forks or static shape constraints. With 89% of top text-generation models supported out of the box, developers can use familiar code patterns instead of fighting a compiler.

Claude Code v2.1.300: Mod hooks and agent fixes

This release stabilizes the modding system with critical new hooks like prompt.change and agent.spawn, allowing developers to intercept edits and rewrite workflow agents dynamically. The OpenTelemetry integration deepens significantly, adding GenAI semantic conventions and splitting cache writes by lifetime for precise observability. Bug fixes resolve persistent issues with session resumption, background command handling, and worktree synchronization in Git reftable repositories. These changes make Claude Code a more robust platform for building custom automation layers rather than just a standalone CLI tool.

Claude Code v2.1.301 patches critical agent loops and UX

This release targets the most frustrating friction points in automated coding workflows: infinite retry loops and silent failures. By capping unattended retries when usage limits reset far out, it prevents agents from burning credits on dead ends. The fix for workflow agents skipping steps after reading harness notes directly addresses a reliability gap that made multi-step automation unpredictable. Combined with better OpenTelemetry visibility into classifier decisions, developers can now actually debug why an agent refused a tool call instead of guessing.

vLLM v0.32.0rc1: Humming update and NVFP4 fix

The v0.32.0rc1 release of vLLM addresses specific backend dependencies and hardware workarounds rather than introducing new model capabilities. It updates the Humming integration, likely refining compatibility with underlying libraries, while removing a workaround for NVFP4 scale issues. This suggests ongoing stabilization efforts for NVIDIA's FP4 quantization support within the inference engine. For practitioners using these specific configurations, this patch ensures smoother operation without manual intervention.

llama.cpp b11675 adds mtmd_audio_stream and Voxtral support

This release quietly expands llama.cpp's multimodal capabilities by adding mtmd_audio_stream and native support for the Voxtral-realtime model. The inclusion of CUDA 13 builds alongside CUDA 12 ensures developers aren't blocked by driver version mismatches, while ROCm 10.0 support keeps AMD hardware in the loop. Apple Silicon KleidiAI is disabled here, likely due to stability checks, but the core audio streaming feature lowers the barrier for real-time voice interaction pipelines. It’s a functional update that prioritizes compatibility and new model integration over flashy new features.

llama.cpp fixes Vulkan host memory and AMD perf issues

This release addresses critical stability gaps in llama.cpp’s Vulkan backend, specifically targeting the fragile interaction between CPU and GPU memory. By disabling host memory buffer sharing on AMD hardware, it sidesteps a known performance regression that previously made inference sluggish or unstable on RDNA architectures. MoltenVK is also excluded from shared memory imports to prevent crashes on macOS, while unreachable code paths are replaced with assertions to tighten the build. These changes make local inference significantly more reliable for non-NVIDIA users without altering model capabilities.

GitHub Copilot in Slack/Teams adds multi-repo support

GitHub Copilot’s presence in Slack and Microsoft Teams just crossed a critical usability threshold: it can now reason across multiple repositories within a single conversation. This eliminates the tedious context-switching that previously forced developers to juggle separate threads for frontend versus backend issues. By allowing natural mentions anywhere in a message and leveraging shared Slack threads as context, the tool finally feels like an integrated assistant rather than a siloed bot. Reliability improvements further reduce the friction of interrupted tasks, making cross-project tracking genuinely viable during daily standups or incident response.

ChatGPT Chrome extension gains tab access and control

OpenAI is shifting ChatGPT from a passive chatbot to an active browser agent by granting the Chrome extension permission to read and manipulate open tabs. This update allows users to tag 'Chrome' in prompts, enabling the model to ingest context from multiple sources simultaneously—like comparing sofa prices or drafting emails based on form data currently displayed. The sidebar now offers full conversation history access, while the new control capabilities mirror Google’s Gemini auto-browse feature for filling forms and organizing windows. This marks a significant step toward autonomous web interaction, moving beyond simple text generation to direct interface manipulation.

GitHub AI Scan for PRs generally available

GitHub has moved its AI-powered pull request scanner from preview to general availability, filling a critical gap in their security stack. While CodeQL remains the gold standard for compiled languages, this new tool targets the messy middle: PHP, Shell, Terraform, and Dockerfiles. It runs automatically on PRs, offering explanations and autofix suggestions without blocking merges, which lowers the friction for adoption. This shifts AI security from a manual audit step to an ambient layer that catches infrastructure and scripting vulnerabilities developers often miss.

GitHub Agentic Autofix for Code Scanning GA

GitHub has moved its agentic autofix feature from preview to general availability, marking a shift from manual triage to automated remediation in enterprise security workflows. By assigning alerts to Copilot, the system autonomously explores codebases, proposes fixes, and validates them via CodeQL reruns before opening a pull request. This replaces the older 'Generate Fix' button with a more robust agent that can handle up to 25 alerts simultaneously in a single PR. The move signals GitHub's commitment to embedding autonomous agents directly into developer operations, reducing the friction between finding vulnerabilities and patching them.

GitHub Copilot HydraFusion adds Max tier and new models

GitHub is pushing orchestration deeper into the developer workflow with HydraFusion Max, a high-effort variant of its multi-model system. The update brings Claude Opus 5.5 and GPT-6 variants into the pool, but the real shift is in how these models interact. By tailoring reasoning effort—medium for drafting, high for review—and adding explicit judging steps, GitHub aims to reduce hallucination without burning tokens on every step. This moves Copilot from simple code completion to a structured, multi-agent critique loop available across VS Code and CLI.

GitHub Actions workflow lockfiles enter public preview

Supply chain security in CI finally gets a native solution. GitHub Actions now supports dependency lockfiles, pinning reusable workflows and third-party actions to specific commits rather than volatile tags. This eliminates the risk of tag-movement attacks where a compromised action silently changes behavior without altering your repository history. With Dependabot integration handling updates automatically, teams can adopt this security layer without manual maintenance overhead. It’s a critical infrastructure upgrade for any organization treating CI/CD as a trust boundary.

Claude Code v2.1.299: Idle Compaction & Mod Hooks

This release tackles the biggest friction point in long coding sessions: idle compaction. By automatically compacting conversations left idle for roughly an hour, Claude Code prevents prompt cache expiration from wiping context, keeping your token budget intact without manual intervention. For developers building extensions, new mod hooks like $.prompt.media and $.session.identity() provide deeper access to session state and attached files, moving beyond simple text manipulation. The update also hardens security by fixing sandbox escapes and refining tool permissions, ensuring that managed settings and plugins behave predictably in enterprise environments.

llama.cpp adds configurable Hexagon power modes

This release brings much-needed control over Qualcomm's Hexagon NPU performance and thermal behavior. By exposing a --hex-power-mode flag in the runner, developers can now balance inference speed against battery life or thermals on Snapdragon devices instead of accepting a fixed profile. It’s a small but critical addition for anyone building local AI apps on Android or Windows ARM that need to respect hardware constraints. The change aligns with existing patterns like nhvx, making it easy to integrate into custom workflows.

llama.cpp b11602 fixes arena reallocation bug

This release addresses a critical memory management flaw where subgraphs failed to recreate during arena reallocation. The fix stabilizes inference on large models that previously triggered crashes or corruption under heavy memory pressure. It also reverts specific test cases, suggesting recent changes were unstable. For builders running local LLMs, this patch removes a significant reliability risk without adding new features.

llama.cpp b11606 release adds ROCm 10 and CUDA 13

This release quietly closes the hardware gap for non-NVIDIA users by adding default support for ROCm 10.0 on both Linux and Windows, meaning AMD GPU owners no longer need complex workarounds to run local inference. Simultaneously, CUDA 13 builds are now standard on every supported OS, future-proofing installations against upcoming driver changes. While Apple Silicon KleidiAI is temporarily disabled, the broader shift toward supporting newer backend versions ensures llama.cpp remains the go-to runtime for diverse hardware setups without requiring manual compilation flags. ROCm 10.0 arrives as a default build option, narrowing the AMD/CUDA gap visibly. CUDA 13.4 libraries are now bundled directly, so users skip the dependency hunt entirely. There's no new model architecture here—just llama.cpp quietly becoming the inference runtime for everyone who isn't on NVIDIA. That's the headline.

llama.cpp fixes server crash from long token names

A subtle but critical stability fix lands in llama.cpp. The server previously crashed with a stack overflow when processing request text containing special tokens longer than roughly 30 characters, caused by libstdc++'s regex engine recursing too deeply. Replacing std::regex_replace with a simple loop eliminates the crash without adding external dependencies or slowing down normal inference. This patch stabilizes llama-server for edge cases that previously brought down HTTP threads unexpectedly.

llama.cpp b11609 fixes WebGPU expert routing

This release patches a critical bug in llama.cpp's WebGPU backend where duplicate expert IDs caused failures in Mixture-of-Experts models. While the core inference engine remains stable on CUDA and ROCm, this fix ensures that browser-based inference for MoE architectures actually works without crashing. It’s a necessary maintenance update rather than a performance leap, but it closes a gap for developers testing specialized models directly in the browser.

GitHub Apps: Least Privilege & Management Updates

GitHub is finally addressing the security debt of classic Personal Access Tokens by introducing granular permissions for GitHub Apps. The new repository_creation:write permission allows apps to create repos without inheriting dangerous administration rights, while installation_repositories:write lets admins control app access at the repo level. This shift forces a move away from over-privileged automation, reducing the blast radius of compromised credentials. It also relaxes restrictions on adding approved org-level apps to specific repos, making workflow smoother for repository administrators. The platform now supports the offline_access scope for OAuth refresh tokens and allows apps to fetch details of other private or internal apps within the same organization or enterprise. These changes are rolling out in GitHub Enterprise Server versions 3.23 and 3.24, with a dedicated credentials tab added to simplify key management. Developers can now test token expiration without breaking existing clients, bridging the gap between security best practices and operational convenience.

GitHub adds audit logs for code quality findings

GitHub finally closes a compliance gap by logging manual dismissals and reopenings of code quality findings. This isn't about better detection; it's about accountability. Security teams can now trace exactly who ignored a rule and when, filtering directly from organization or enterprise audit logs. For enterprises with strict data residency requirements, this feature is now generally available on GitHub Team and Enterprise Cloud, bringing necessary transparency to automated security workflows.

Google Play Store integration for AI-generated apps

Google is bridging the gap between experimental coding and real distribution by allowing users to publish 'vibe-coded' apps directly from Google AI Studio. This feature, currently available in the US, lets creators bypass manual installation steps and reach a wider audience while keeping personal projects separate from the public catalog until they choose to graduate. It effectively turns a playful prototyping tool into a legitimate launchpad for indie developers, lowering the barrier to entry for those who want to share their creations without navigating complex enterprise onboarding processes.

GitHub blocks Anthropic keys by default

GitHub has shifted from passive detection to active prevention for Anthropic API keys, automatically blocking commits that contain them. This move significantly raises the cost of credential leakage for developers using Claude, turning a common operational risk into an immediate build failure. Salesforce credentials are now also detected and reported, expanding the scope of automated partner notifications. While this doesn't stop secrets already in history, it effectively hardens the default posture for public repositories against accidental exposure.

Dependabot alerts now signal withdrawal via webhook and API

GitHub has fixed a blind spot in Dependabot automation by explicitly signaling when an alert is withdrawn. Previously, developers and scripts had no reliable way to distinguish between a resolved vulnerability and one that was simply removed from the database. Now, the dependabot_alert webhook includes a 'withdrawn' action, and the REST API returns a 410 Gone status instead of a generic 404. This allows CI/CD pipelines and security dashboards to accurately track alert lifecycles without false positives or stale data.

GitHub adds AI Scan security metrics

GitHub finally gives security teams the data they need to justify AI scanning investments. The new Security Overview metrics track autofix adoption rates and remediation trends across repositories, moving beyond raw finding counts to measure actual developer impact. This shift from volume to efficacy helps enterprises decide whether to roll out AI Scan broadly or keep it restricted. It’s a practical step toward treating AI security tools as measurable operational components rather than experimental features.

GitHub Copilot adds granular enterprise telemetry controls

GitHub is finally addressing the biggest friction point for enterprise AI adoption: privacy. By decoupling user identity from content capture in Copilot's telemetry, admins can now track usage without ingesting sensitive code or prompts. The new OpenTelemetry integration allows fine-grained control over five distinct data classes, giving organizations the auditability they need to justify AI spend while keeping proprietary logic safe. This shifts Copilot from a black box to a manageable enterprise tool.

GitHub adds durable push attribution to commits

GitHub is closing a long-standing security gap by attaching a durable, authenticated identity to every commit push, independent of the mutable author and committer fields. This prevents attackers from forging commits that appear to come from trusted maintainers, effectively neutralizing one method of evading review policies. The feature includes a new repository rule condition that blocks pushes where the committer metadata doesn't match the verified email of the authenticated user. While currently limited to GitHub Enterprise customers in public preview, this shift makes audit trails significantly more reliable for security investigations.

llama.cpp b11555 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing first-class ROCm 10.0 support to both Linux and Windows. AMD GPU users no longer need workarounds, effectively closing a long-standing parity gap with NVIDIA's CUDA ecosystem. The inclusion of Snapdragon AI stack binaries for Linux marks a significant expansion into mobile-edge hardware, while the addition of CUDA 13 builds future-proofs the tool against upcoming driver requirements. By standardizing these complex backend integrations into single downloadable binaries, the project removes friction for anyone deploying local models on non-NVIDIA silicon.

llama.cpp RPC logging overhaul

This release refactors llama.cpp’s RPC backend logging, turning a binary debug flag into a granular verbosity system. Developers can now trace tensor transfers and graph cache evictions with precision, which is critical for debugging distributed inference setups. The cleanup also unifies log handling across client and server sides, reducing noise and fixing format specifier bugs. It’s a maintenance win that makes diagnosing remote inference failures significantly easier.

llama.cpp b11558 fixes OpenCL and adds ROCm 10

This release quietly patches critical stability issues for OpenCL inference on Qualcomm hardware, ensuring q4_k dense bin kernels no longer crash when image limits are exceeded. It also brings ROCm 10.0 support to both Linux and Windows, keeping the project aligned with AMD's latest driver stack. While KleidiAI is temporarily disabled on macOS builds, the core value here is fixing fragmentation for non-NVIDIA users who rely on Vulkan or OpenCL for local LLMs.

llama.cpp b11559 adds Gemma-4 and Snapdragon support

Gemma-4 finally gets proper GPU acceleration in llama.cpp, with Qualcomm engineers enabling E4B and E2B decoding for OpenCL. This closes a major usability gap for running Google's latest model on non-NVIDIA hardware. The release also brings optimized decode paths for DK64 and DK128 GQA patterns, squeezing more performance out of Adreno GPUs. Snapdragon CPU, GPU, and NPU builds are now available on Linux, making local inference on mobile chips significantly easier. It’s a practical update that expands the ecosystem beyond CUDA.

llama.cpp adds Hexagon IM2COL_3D support

This release targets the Snapdragon NPU with a major optimization for 3D convolution operations. By rewriting the Hexagon IM2COL kernel to use a canonical DMA double-buffer pipeline, it removes inefficient scalar FP16 conversions and divisors that previously bottlenecked performance. This isn't just a feature add; it's a structural fix that makes running vision-language models on mobile NPUs significantly more viable. The update also includes CUDA 13 builds and ROCm 10.0 support, keeping the stack current for desktop GPU users.

llama.cpp b11562 fixes Vulkan logging and adds ROCm 10

This release quietly patches a buffer logging bug on 32-bit platforms but the real signal is the inclusion of ROCm 10.0 binaries for both Linux and Windows. By shipping ROCm 10 alongside CUDA 13, llama.cpp continues to solidify its position as the go-to inference engine for AMD GPU users who previously faced compatibility gaps. The build matrix remains exhaustive, covering everything from Apple Silicon KleidiAI to Snapdragon NPU support, ensuring that local LLM deployment stays accessible across diverse hardware without requiring manual compilation.

llama.cpp b11564 Vulkan CM2 optimization

This release quietly sharpens llama.cpp's Vulkan performance by optimizing the quantization block size for CM2 matmul operations. The change avoids inefficient switch lowering in the compiler pipeline, translating to faster inference on compatible GPUs without requiring user configuration. It also expands hardware support with ROCm 10.0 builds and CUDA 13.4 libraries across Linux and Windows. KleidiAI remains disabled on Apple Silicon for now, keeping the focus squarely on Vulkan and AMD/NVIDIA acceleration paths. This is a technical polish update that improves efficiency for developers running local models on non-CUDA or mixed-hardware setups.

Copilot JetBrains update adds model controls and MCP settings

GitHub Copilot for JetBrains is tightening enterprise grip with managed default models, letting admins lock in specific agents while preserving user choice. The diagnostic workflow gets a direct Fix action that bridges inline chat and agent mode, cutting steps between error detection and resolution. Crucially, new MCP controls let users disable automatic server startup, addressing resource concerns around tool-heavy configurations. This release also drops support for IDE 2025.1, forcing an upgrade to 2025.2 or later.

Claude Code v2.1.292 patches security and agent logic

This release tightens the leash on Claude Code's autonomous capabilities while fixing critical sandbox escapes. The new effort parameter for Agent tools lets developers explicitly control sub-agent depth, a necessary guardrail as these systems grow more complex. Security fixes are prominent, addressing how plugins handle network paths and how file permissions persist during session resumption. It’s a stability patch that ensures the tool remains usable in enterprise environments without compromising on the new agent features.

Claude Code v2.1.293 updates Haiku and fixes agent bugs

Anthropic quietly shipped a significant model update alongside routine maintenance. Claude Haiku 5.5 is now the default on the API, offering a 1M context window at $0.10 per million tokens, which lowers the cost floor for high-volume coding tasks. The release also patches critical stability issues in the local agent runtime, specifically fixing memory leaks in HTTP MCP connections and resolving session state corruption during context compaction. These fixes matter because they stabilize the autonomous coding workflow that developers rely on daily. With Haiku 5.5 now standard, teams can deploy cheaper, faster iterations without manual configuration.

Claude Code v2.1.294 fixes hook logic

Anthropic quietly patched a frustrating edge case in Claude Code’s agent hooks. Previously, instructions like 'Block commands that...' were often ignored because the model didn't recognize them as valid blocking criteria. This update ensures those prompts are properly interpreted, while also refining how stop conditions are judged to prevent premature termination. It’s a small but necessary fix for anyone relying on strict guardrails in automated coding workflows.

Claude Code v2.1.295: Stability and Gateway Fixes

This release prioritizes stability over new features, addressing critical reliability issues in Claude Code's backgrounding and MCP integration. The most significant change is the addition of an 'onFailure: block' for hooks, which prevents silent failures from bypassing safety checks—a crucial update for developers relying on automated workflows. Gateway connectivity also sees major improvements with upstream timeout controls and better error handling for Bedrock and Vertex integrations. While there are no headline-grabbing capabilities, these fixes make the tool significantly more robust for heavy daily use.

Claude Code v2.1.296 patches gateway and agent stability

This release stabilizes the Claude apps gateway for enterprise managed environments, fixing critical login regressions and policy enforcement gaps that previously locked out users or ignored settings. It also refines subagent behavior with new auto-compaction windows and model isolation controls, giving developers finer grained control over complex multi-step workflows. Under the hood, numerous edge cases in plugin hooks, transcript logging, and terminal escape sequences are resolved, ensuring headless sessions and IDE integrations behave predictably. The update signals Anthropic's focus on making Claude Code a reliable infrastructure component rather than just a consumer tool.

vLLM v0.31.1rc0 exposes cached prompt tokens by tier

This release adds a critical observability layer to vLLM's KV cache system by exposing prompt token counts broken down by cache tier. For operators running large-scale inference, seeing exactly how much data is served from the GPU versus CPU or disk is essential for tuning memory allocation and cost efficiency. It transforms the cache from a black box into a measurable metric, allowing teams to validate whether their prefill strategies are actually hitting the intended storage layers. This granularity helps prevent over-provisioning and identifies bottlenecks in prompt processing pipelines.

llama.cpp b11532 adds ModernBERT and CUDA 13

This release quietly fixes a critical accuracy gap for ModernBERT encoders by implementing exact GELU activation, ensuring semantic embeddings match the original PyTorch models rather than approximations. It also brings native support for CUDA 13.4 across Linux and Windows, closing the driver compatibility lag that has plagued NVIDIA users on newer hardware stacks. While KleidiAI builds are temporarily disabled on Apple Silicon, the broader expansion to ROCm 10.0 and Snapdragon NPU keeps llama.cpp as the most versatile local inference runtime available today.

llama.cpp b11533 fixes Adreno A6X crashes

This release targets a specific but painful stability issue for Android users running llama.cpp on Qualcomm Adreno A6X GPUs. The kernel compiler was crashing due to argument limits in the iot device backend, effectively breaking local inference on those chips. By skipping the problematic kernel and adding explicit detection for the Adreno 623, the team restores functionality where it previously failed hard. It’s a narrow fix, but essential for anyone trying to run models on mid-range Android hardware without hitting compiler errors.

llama.cpp b11534 optimizes CUDA SSM and adds ROCm 10

This release quietly sharpens llama.cpp’s performance on NVIDIA GPUs by fusing state snapshot copies into the recurrent cache during SSM scans. It also removes redundant CUDA copies in specific non-speculative decoding scenarios, shaving off latency where it counts. On the AMD side, ROCm 10.0 support arrives alongside stable builds for CUDA 12.8 and 13.4, keeping the library competitive across hardware vendors. KleidiAI on Apple Silicon is temporarily disabled, a minor setback for Mac users until that integration is stabilized. The net result is faster inference for SSM-based models without changing the user experience.

llama.cpp UI adds offline context filtering and favorites

This release fixes a major usability gap in llama.cpp's local inference workflow. By reading GGUF metadata directly, the Models Manager now displays trained context length without hitting the Hugging Face Hub API, enabling true offline sorting and filtering. The interface also gains persistent favorite marking with visual cues, making model selection for power users who manage large local libraries significantly less friction-heavy. It’s a quiet but essential polish that makes managing dozens of models easier. Users no longer need an active internet connection to organize their library by context size. The update removes the dependency on external services for basic navigation tasks. This is a practical improvement for anyone running llama.cpp locally.

llama.cpp b11537 fixes embeddings and adds ROCm 10

This release quietly patches the embedding pipeline for Gemma 4, fixing raw path logic and avoiding unnecessary float casts that could degrade vector quality. More visibly, it ships ROCm 10.0 binaries alongside CUDA 13.4 builds, giving AMD users access to newer driver stacks without waiting for separate compilation steps. KleidiAI on Apple Silicon is disabled in this build, likely due to stability checks rather than feature removal. The update reinforces llama.cpp's role as the go-to runtime for diverse hardware, ensuring developers can test new models across CUDA, ROCm, and ARM backends with minimal friction.

llama.cpp b11538 adds ROCm 10 and CUDA 13 support

This release quietly closes the hardware gap for non-NVIDIA users by adding default builds for ROCm 10.0 on both Linux and Windows, meaning AMD GPU owners no longer need to compile from source to get decent performance. Simultaneously, CUDA 13.4 is now available alongside the existing 12.x builds, future-proofing the toolchain for next-gen NVIDIA cards without breaking legacy setups. While Apple Silicon support was toggled off in this specific binary set, the core value here is the broadening of accessible inference hardware. It’s a maintenance-heavy update that significantly lowers the barrier to entry for local AI on diverse GPUs.

llama.cpp b11539 adds ROCm 10 and CUDA 13 support

This release quietly closes the hardware gap for non-NVIDIA users by adding default builds for ROCm 10.0 on both Linux and Windows, meaning AMD GPU owners no longer need to compile from source to get decent performance. The inclusion of CUDA 13.4 alongside the existing 12.x builds ensures compatibility with the latest driver stacks without breaking older setups. While Apple Silicon support is present, KleidiAI optimizations are currently disabled, keeping Intel Macs as the primary focus for ARM-based efficiency gains here. It’s a pragmatic update that stabilizes llama.cpp as the go-to runtime across almost every major accelerator type available today.

Copilot adds sandboxing and Claude Haiku 5.5

GitHub Copilot is tightening the leash on autonomous agents with local sandboxing, a critical step for enterprise security that restricts file, network, and credential access. The update also brings Claude Haiku 5.5 to all paid tiers, expanding the model lineup available within the IDE. Meanwhile, the CLI now integrates seamlessly with local Ollama instances, allowing developers to swap between cloud and local models without leaving their workflow. These changes shift Copilot from a simple autocomplete tool toward a more controlled, multi-model agent platform.

CodeQL 2.27.2 updates analysis and breaks macOS 27 support

CodeQL 2.27.2 tightens security coverage with new C++ regex parsing and SQL-injection models for Comdb2, while refining Rust async data flow. The release also corrects false positives in C# clickjacking and XSS queries, making enterprise scanning more precise. However, the most disruptive change is the abrupt loss of support for macOS 27 and Xcode 27 due to Apple dropping multi-architecture binaries, forcing developers to downgrade their toolchains for compiled language analysis. This update underscores the fragility of static analysis pipelines when underlying OS dependencies shift without warning.

Anthropic launches free AI security scans for open-source

Anthropic is deploying its most powerful models, including Mythos, to automatically scan open-source repositories for vulnerabilities without human review. This move shifts the burden of code auditing onto AI, offering speed and scale that human teams cannot match, but it also risks flooding maintainers with false positives—a problem already straining projects like Linux. By making this service free, Anthropic is effectively subsidizing the security infrastructure of the open-source ecosystem while positioning its models as essential defensive tools. The real test is whether developers can trust automated triage over noisy alerts.

GitHub Copilot Code Review adds org billing controls

GitHub is tightening the leash on enterprise AI spending with new billing and access controls for Copilot Code Review. Organizations can now shift costs from individual member quotas to a central cost center using AI Credits, preventing personal license exhaustion from halting team workflows. Simultaneously, admins can block external licenses from triggering reviews, ensuring only authorized corporate accounts consume resources. This moves Copilot from a perk to a managed utility, giving finance teams actual visibility into AI consumption.

GitHub draft PRs now count toward limits

GitHub finally plugs a loophole that let spammers bypass repository pull request limits by opening endless drafts. Maintainers can now configure these limits to include draft PRs, directly reducing notification clutter and wasted CI runs from low-quality contributions. This is a practical quality-of-life fix for open source maintainers tired of managing spam rather than code. It shifts the burden slightly toward contributors but protects repository health.

ML-Intern: Autonomous AI Agent for Model Training

Hugging Face’s ML-Intern agent proves that autonomous model training is no longer theoretical. By handling dataset curation, hyperparameter tuning, and cost management with a single prompt, it produced six distinct fine-tuned models in days for under $50 total. This shifts the barrier from engineering complexity to prompt precision, allowing developers to iterate on specialized capabilities like camera-angle LoRAs or domain-specific vision without manual infrastructure overhead. The real shift is the democratization of custom model creation, turning what used to be a week-long engineering sprint into a low-cost, automated workflow.

Microsoft Surface RTX Spark Dev Box Preorders Open

Microsoft is selling a dedicated AI development rig for $5,999, targeting developers who need local inference power without building their own hardware. The device pairs Nvidia’s Arm-based RTX Spark platform with 128GB of unified memory, enabling it to run models exceeding 120B parameters on-device. It ships pre-configured with Windows 11 Pro and essential dev tools like VS Code and GitHub Copilot, effectively bundling the software stack with the silicon. This moves local AI from a DIY enthusiast project to a standardized enterprise-grade appliance, albeit at a premium price point that limits it to professional workflows rather than consumer hobbyists.

GitHub deploys fine-tuned model for secret detection

GitHub is replacing its regex-based secret scanning with a purpose-built AI model that understands code context to catch unstructured credentials like passwords without standard token formats. This shift moves security from pattern matching to semantic understanding, catching leaks that traditional tools miss before they hit repository history via push protection. The upgrade is automatic for existing GHSP/GHAS customers, but new opt-in features in Copilot and push protection will consume AI Credits, introducing a usage-based cost layer to what was previously free. This marks a significant pivot in how developers handle security, blending LLM capabilities directly into the CI/CD pipeline.

GitHub Copilot adds local sandboxing for agents

GitHub Copilot finally addresses the security risks of autonomous coding by introducing local sandboxing across its CLI, app, and VS Code extensions. Powered by Microsoft’s MXC technology, this feature creates a strict execution boundary that restricts agent access to files, networks, and credentials based on developer-defined policies. This is a critical step for enterprise adoption, allowing organizations to enforce security controls without blocking the utility of agentic workflows. It shifts Copilot from a passive assistant to a controlled autonomous actor with clear operational limits.

GitHub Copilot CLI v1.0.94 adds local Ollama model discovery

GitHub finally bridges the gap between cloud-heavy Copilot and local inference by letting the CLI discover models from a running Ollama instance. Version 1.0.94-0 introduces a /model command that surfaces supported local weights alongside cloud options, allowing developers to switch contexts without restarting the session. This isn't just a toggle; it requires tool calling and streaming support, forcing a quality baseline for local providers. The move signals GitHub's recognition that enterprise workflows increasingly demand hybrid setups where sensitive code stays on-prem while general assistance remains in the cloud.

GitHub fixes Copilot agent metrics attribution bug

GitHub has identified why your Copilot usage reports are lying: a recent SDK migration in several IDEs broke the link between agent sessions and their source editor. The result? Agent activity was either vanishing from dashboards or falsely inflating CLI metrics, leaving enterprise admins blind to actual developer productivity. The fix is live for VS Code now, with other IDEs following by November 2026. Crucially, this data cannot be backfilled, meaning any gap in your historical reporting is permanent until every affected developer updates their client.

GitHub Stacked PRs Generally Available

Stacked pull requests have graduated from preview to general availability on GitHub, addressing the friction of managing dependent changes. The feature now preserves approvals during rebases and ensures commit signatures remain intact, solving two major compliance headaches for enterprise teams. Merging logic has been refined so stacks land as a single group while maintaining individual merge commits, and auto-merge support is rolling out soon. This shifts large refactors from chaotic branch management to structured, reviewable sequences that actually get merged faster.

GitHub adds AI Scan enablement visibility

GitHub finally gives admins a dashboard view for AI-powered code scanning adoption. Instead of guessing which repos are using the feature, you can now filter by enabled status and export CSVs to track coverage. This closes a major blind spot for security teams trying to enforce or monitor AI-driven security tooling across large organizations.

Claude Code v2.1.290: Plugin hooks and agent stability fixes

This release significantly tightens the security model for Claude Code plugins by exposing server tool IDs and approval ceilings to hook functions, allowing developers to build more granular permission checks. It also stabilizes long-running agent sessions by fixing critical bugs in subagent resume logic and scheduled task persistence after compaction. For plugin authors, the new validation flags ensure gating hooks are properly configured before deployment. These changes make the platform safer for enterprise use while reducing friction for complex automated workflows.

llama.cpp b11424 adds CUDA 13 and ROCm 10.0

This release quietly closes the hardware gap for local inference by adding default support for CUDA 13 and ROCm 10.0 alongside existing CUDA 12 builds. NVIDIA users can now leverage newer driver stacks without manual configuration, while AMD GPU owners finally get first-class parity with the same ease of use previously reserved for CUDA. Apple Silicon KleidiAI is disabled in this specific build, a notable regression for Mac users who rely on that optimization. The inclusion of Snapdragon and OpenVINO binaries further broadens the reach to edge devices and Intel hardware. It’s less about new features and more about llama.cpp solidifying its position as the universal runtime for every major accelerator.

llama.cpp b11425 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing first-class ROCm 10.0 support to both Linux and Windows. AMD GPU users no longer need workarounds, effectively closing a long-standing parity gap with NVIDIA's CUDA ecosystem. The inclusion of Snapdragon AI stack binaries for Linux marks a strategic push into ARM-based edge devices, while the simultaneous addition of CUDA 13 builds ensures compatibility with the latest driver stacks. By standardizing these hardware backends across major operating systems, the project removes friction for developers deploying models on diverse non-NVIDIA hardware.

llama.cpp 0.6.0 adds CUDA 13 and Snapdragon support

The llama.cpp 0.6.0 release quietly expands hardware coverage where it counts most: next-gen NVIDIA GPUs and mobile silicon. By shipping native builds for CUDA 13.4 alongside the existing CUDA 12 binaries, users can finally leverage newer GPU architectures without compiling from source. The inclusion of Linux arm64 support for Snapdragon chips with Adreno GPU and Hexagon NPU acceleration signals a serious push into on-device inference beyond Apple Silicon. While KleidiAI on macOS is temporarily disabled, the broader platform expansion makes this one of the most versatile local inference releases in recent memory.

llama.cpp b11435 fixes data race in shared sequences

This release targets a critical stability bug in llama.cpp's handling of shared sequence contexts. By fixing a k-pool scatter data race on the CPU backend, it prevents corruption when multiple sequences share pooled key-value representations. The update also simplifies memory management by enforcing whole-sequence copies and dropping the 'cache_safe' mode, which removes unnecessary stale-workarounds. For users running concurrent inference tasks or complex prompt chaining, this means fewer crashes and more predictable state management without needing manual intervention.

llama.cpp fixes OpenVINO GPU regressions and CI

This release patches critical stability issues in llama.cpp's OpenVINO backend that were breaking stateful inference on both CPU and GPU. By fixing how the scheduler handles mixed token/embd branches and correcting quantized type handling, models like Qwen3.5 and Gemma-3 now run reliably without crashing or returning empty outputs. The changes also resolve specific GPU plugin defects related to RMS norm ranks and resource allocation errors during testing. This is a necessary maintenance update that restores confidence in OpenVINO as a viable inference path for AMD and Intel hardware.

GitHub Secret Scanning adds Lovable and Supabase detectors

GitHub quietly expanded its secret scanning partnership program to include Lovable Labs, Pydantic Services, and Supabase. This update means credentials from these popular development platforms are now automatically detected in public repositories, allowing the providers to revoke or rotate compromised keys before abuse occurs. For developers using Supabase or Lovable, this adds a critical layer of automated security hygiene without requiring manual configuration. It reflects GitHub's ongoing effort to integrate directly with the modern AI and database tooling stack that dominates current development workflows.

Open-source tool deletes Apple Intelligence data on macOS

Apple removed the simple toggle to disable AI features in macOS 27, leaving 12GB of models lingering on disk even when turned off. RemoveMacAI solves this by automating the cleanup: it disables Siri, Writing Tools, and Genmoji, deletes the underlying models, and blocks future downloads. This restores user control over storage and privacy without requiring manual navigation through scattered settings panes. It’s a practical patch for an ecosystem change that prioritized feature retention over user choice.

Together Link bridges open models to coding agents

Together AI is solving the cost explosion of coding agents by routing tasks through its serverless platform instead of burning cash on premium closed models. The tool integrates directly into Claude Code, Codex, and OpenCode, allowing teams to swap expensive Opus calls for cheaper alternatives like GLM 5.3 or Kimi K3 without changing their workflow. It’s not just a proxy; the router dynamically assigns hard problems to frontier-capable open weights while offloading routine fixes to low-cost flash models. This turns open inference into a drop-in cost-saving layer for existing engineering stacks, making high-performance coding significantly cheaper.

Claude Code v2.1.288 fixes resume and MCP bugs

This release stabilizes the core session management of Claude Code, specifically targeting the fragile state of resumed conversations where context or thinking traces were previously lost. It also patches critical reliability issues in the Model Context Protocol (MCP) integration, ensuring tool calls don't duplicate or hang indefinitely when remote servers misbehave. The addition of $.ui.selection() for mods and better GitHub CLI handling in cloud sessions shows a focus on developer workflow friction rather than new capabilities. These are necessary maintenance updates that make the tool more robust for heavy daily use.

Claude Code v2.1.289 patches sandbox and plugin stability

This release is a classic maintenance patch for Claude Code, focusing on stabilizing the terminal interface and tightening security rules. It fixes critical bugs where deny/ask rules were bypassed in nested shell commands or via symlinks, ensuring sandbox policies actually hold. The update also resolves numerous UI freezes caused by malformed HTML tags and plugin rendering errors, making the agent feel less brittle during complex coding sessions.

llama.cpp b11372 optimizes Qwen4-Exp memory and GPU support

This release tackles the notorious memory hunger of long-context inference for Qwen4-exp models by halving indexer score memory. The optimization works by computing head scores in place rather than materializing separate tensors, a change that significantly reduces VRAM pressure during heavy workloads. Beyond memory efficiency, b11372 expands hardware coverage with CUDA 13 support and Vulkan tiling for the lightning indexer. It also adds ROCm 10.0 binaries, keeping AMD users in step with NVIDIA's latest driver ecosystem. The result is a leaner runtime that handles extended contexts without hitting out-of-memory errors as quickly.

llama.cpp b11374 optimizes OpenVINO MoE performance

This release significantly tightens llama.cpp’s integration with Intel’s OpenVINO backend, specifically targeting Mixture of Experts (MoE) models like Qwen3.5 and Gemma-4. By fusing MoE routing and GDN normalization operations, prefill throughput on Arc GPUs jumps from 66 to over 1,600 tokens per second, effectively removing a major bottleneck for local inference on Intel hardware. The update also fixes critical stateful execution bugs that previously caused crashes or incorrect axis handling during decoding. This makes OpenVINO a far more viable option for running complex MoE architectures on consumer-grade Intel GPUs without relying on NVIDIA CUDA.

llama.cpp b11375 fixes Mamba state graph reallocation

This release resolves a critical crash in Mamba SSM inference when batch cells aren't contiguous. By gathering recurrent states into a single reserve that covers every split, the engine avoids illegal graph reallocations under strict scheduling modes. It’s a quiet but essential fix for anyone running non-standard sequence lengths or complex batching logic with stateful models.

llama.cpp b11376 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing first-class ROCm 10.0 support to both Linux and Windows. AMD GPU users no longer need workarounds, effectively closing a long-standing parity gap with CUDA. Equally notable is the new Snapdragon binary for Linux, which unlocks local LLM execution on ARM-based mobile chips via CPU, Adreno GPU, and Hexagon NPU paths. While KleidiAI builds are temporarily disabled, the expansion to Windows ROCm and mobile silicon signals a strategic shift toward hardware-agnostic accessibility.

llama.cpp fixes JSON schema enforcement in Ling 3.0

The Ling 3.0 parser in llama.cpp previously ignored json_schema constraints, leaving tool calls unconstrained and breaking structured output reliability. This update adds an eager response-format grammar path that takes precedence over standard tools, ensuring strict adherence to defined schemas even when thinking is enabled. By preventing trailing prose after JSON responses, it closes a critical gap for developers relying on deterministic outputs. This makes llama.cpp significantly more robust for production-grade agent workflows requiring precise data extraction.

llama.cpp b11378 adds ROCm 10 and CUDA 13

This release quietly cements llama.cpp as the universal inference runtime by finally supporting AMD's latest ROCm 10.0 alongside NVIDIA's CUDA 13.4 across Linux and Windows. The inclusion of Snapdragon support with Adreno GPU and Hexagon NPU acceleration marks a significant step toward efficient local AI on ARM devices. While KleidiAI is disabled for now, the broad hardware coverage means developers can deploy models on almost any modern architecture without hunting for custom builds.

llama.cpp b11379 fixes server batch abort

A subtle but critical fix in llama.cpp resolves a server-side crash caused by mismatched batch sizes. By capping n_batch to n_ubatch, the release prevents abrupt termination during inference workloads that previously triggered layout aborts. This stabilizes the runtime for users running concurrent requests or larger batches on constrained hardware. It’s not a feature update, but it removes a friction point that could derail production deployments.

llama.cpp b11381 release with CUDA 13 and ROCm 10

This is a routine maintenance build for llama.cpp that quietly solidifies support for the latest NVIDIA and AMD hardware stacks. By shipping binaries linked against CUDA 13.4 and ROCm 10.0, it ensures local inference remains viable on cutting-edge GPUs without requiring users to compile from source. The release also patches a deprecated strdup warning on Windows, smoothing out development friction. While there are no new model architectures or quantization methods here, the consistent expansion of pre-built runtime compatibility keeps llama.cpp as the default choice for heterogeneous hardware setups.

GitHub Copilot Code Review API and Default Effort Change

GitHub finally exposes Copilot code review to external automation via REST and GraphQL APIs, moving it from a manual UI action to an integrable pipeline step. This allows developers to trigger reviews directly from scripts or internal tools rather than relying on the web interface. Simultaneously, the default effort level shifts to Balanced, striking a middle ground between speed and depth for most repositories. While Lite remains available for those prioritizing raw throughput, the API access is the real win here, enabling true CI/CD integration for automated code quality checks.

npm staged publishing now supports new package creation

npm has closed a major gap in its staged publishing workflow by allowing the creation of entirely new packages directly from the staging queue. Previously, developers had to perform an initial public publish before they could leverage the safety net of staged releases for subsequent versions. This update enables automated workflows to initialize scoped and unscoped packages securely using granular access tokens, ensuring that the very first version also undergoes maintainer review before becoming installable. It effectively removes the manual friction from setting up secure, review-gated package lifecycles.

GitHub Copilot deprecates specific models

GitHub quietly retired several underlying models for Copilot Chat and code completions, forcing a shift in the default inference stack. Enterprise admins must now manually enable alternative models via policy settings to maintain access, turning what was once automatic into an administrative task. This signals that GitHub is actively pruning its model portfolio rather than just adding new ones, likely to consolidate costs or improve quality control. Developers relying on specific legacy behaviors may find their workflows broken until policies are updated.

GitHub GraphQL API expands SecurityAdvisory fields

GitHub’s GraphQL API now exposes critical vulnerability metadata directly, eliminating the need to fall back to REST for basic advisory data. Five new fields like cveId and nvdPublishedAt allow developers to pull CVE identifiers and NVD publication times in a single query. The addition of severities and isWithdrawn filters enables server-side narrowing, which significantly reduces client-side processing and rate limit consumption. This consolidation streamlines security integrations by unifying authentication paths and simplifying the construction of triage feeds.

GitHub adds confidential comments to security advisories

Security triage just got a much-needed privacy layer. GitHub now allows maintainers to post confidential comments on repository security advisories, visible only to those with write access. This solves the awkward workflow of moving sensitive investigation details or abuse reports off-platform to keep them away from reporters and external collaborators. The feature respects existing permissions and logs views in the audit trail, making internal coordination seamless without exposing strategic discussions.

GitHub API adds security advisory comments

GitHub finally exposes the discussion layer of repository security advisories via REST API, closing a long-standing gap between web UI and programmatic access. This allows developers to list, add, and edit comments on both public and private vulnerability reports, enabling automated triage workflows that mirror issue management. The inclusion of comment counts in advisory responses lets systems identify active discussions without fetching full payloads, simplifying audit exports and migration tasks. While confidential comments remain excluded and deletion is unsupported, this move brings security data into the same automation ecosystem as code changes.

Claude Code v2.1.286 patches security and session stability

Anthropic quietly fixed a critical credential leakage bug where MCP error messages were exposing raw API keys in plaintext logs. Beyond the security patch, this release stabilizes the notoriously fragile background agent system by fixing subagent hand-offs and connection stalls that previously caused silent failures. The update also tightens session management for cloud environments, ensuring large transcripts actually load instead of hanging indefinitely. It’s a maintenance-heavy release, but essential for anyone running complex, multi-step automated workflows.

Claude Code v2.1.287 adds plugins and fixes

This update shifts Claude Code from a simple CLI wrapper to a more extensible platform by introducing 'Claude Mods,' allowing plugins to modify deeper behavior rather than just adding tools. The inclusion of a built-in 'You should know' side agent that flags potential oversights is a notable step toward autonomous oversight within the coding workflow. Beyond features, the release addresses critical stability issues in remote sessions and significantly improves accessibility for screen reader users, making the tool more robust for enterprise and diverse developer environments.

vLLM v0.31.0rc3 adds Model Runner V2 dummy inputs

The v0.31.0rc3 release of vLLM brings a critical infrastructure tweak to the new Model Runner V2: support for randomized dummy inputs. This isn't a feature for end-users but a developer-facing fix that stabilizes how the runner handles initial tensor shapes during compilation and warm-up phases. By allowing randomized inputs, it reduces the likelihood of shape-mismatch errors when tracing models with dynamic dimensions. For builders running large-scale inference workloads, this means fewer silent failures and more robust model loading sequences in production environments.

llama.cpp b11332 adds ROCm 10 and Snapdragon support

This release quietly expands llama.cpp's hardware reach with two major additions: ROCm 10.0 for AMD GPUs and native support for Linux arm64 Snapdragon devices. The inclusion of ROCm 10 is significant, as it brings AMD users closer to parity with CUDA in terms of supported versions, reducing the friction for local inference on non-NVIDIA hardware. Meanwhile, Snapdragon support opens up a new class of mobile AI acceleration, allowing developers to leverage Adreno GPUs and Hexagon NPUs directly. While Apple Silicon builds have KleidiAI disabled by default, the core value here is the broadening of accessible compute backends without requiring complex custom compilation.

llama.cpp b11333 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing ROCm 10.0 to Linux and Windows alongside CUDA 13.4, effectively closing the hardware gap for AMD users who previously lagged behind NVIDIA. The standout addition is native support for Linux arm64 Snapdragon devices, enabling local AI on mobile-class silicon with CPU, Adreno GPU, and Hexagon NPU acceleration. While KleidiAI on Apple Silicon is currently disabled in this build, the broader expansion to diverse accelerators means developers no longer need to compile from source to target non-NVIDIA hardware. The world now has a single binary ecosystem that runs everywhere from x86 servers to ARM mobile chips.

llama.cpp b11334 fixes Metal buffer leaks

This release addresses a memory management issue in the Metal backend by properly releasing temporary private transfer buffers. While not a feature upgrade, it stabilizes performance on Apple Silicon devices where previous builds might have suffered from memory pressure or fragmentation during inference. The update also includes standard platform binaries for CUDA 13 and ROCm 10.0, ensuring compatibility with the latest NVIDIA and AMD driver stacks. For local LLM users on macOS, this is a quiet but necessary maintenance step to keep inference smooth.

llama.cpp optimizes NVIDIA V100 inference performance

NVIDIA's older Volta architecture has long been an afterthought in local LLM inference, but this patch finally gives Tesla V100 users a tangible speed boost. By routing sm_70 to the Turing MMVQ nwarps table, llama.cpp reduces warp overhead for K-quant batch-1 decoding, delivering a measurable 3% throughput increase on Qwen3.8-27B models without touching perplexity. This isn't just code cleanup; it validates that legacy hardware can still compete efficiently when the runtime respects its specific kernel tuning. The change merges community work from the V100-focused anyei fork, proving that niche optimizations can become mainstream defaults.

llama.cpp b11337 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing first-class ROCm 10.0 support to both Linux and Windows. AMD GPU users no longer need workarounds for modern stacks, closing a long-standing parity gap with CUDA. Equally notable is the inclusion of native binaries for Linux arm64 Snapdragon devices, targeting the emerging edge AI market with CPU, Adreno GPU, and Hexagon NPU acceleration. While KleidiAI on Apple Silicon has been disabled in this build, the expansion into AMD and ARM ecosystems significantly broadens the hardware footprint for local LLM deployment.

llama.cpp b11338 optimizes Hexagon NPU and fixes DMA

This release quietly sharpens llama.cpp’s performance on Qualcomm’s Hexagon NPUs by replacing broken logic with shared strided DMA copies for tensor operations. The fix removes the arbitrary CONCAT_DMA_MIN_ROW threshold, allowing any-dimension concatenations to leverage high-speed DMA transfers instead of falling back to slower methods. It also patches missing queue flushes and adds safety guards that were previously causing instability on these accelerators. For developers running local inference on Snapdragon devices or Linux ARM boards with Hexagon support, this means more reliable and faster NPU utilization without manual workarounds.

llama.cpp b11339 fixes cache reallocation crash

This release patches a critical memory management bug that caused crashes during full-context decoding. When a batch filled the entire KV cache, llama.cpp attempted to allocate tensors larger than reserved, triggering fatal aborts under strict debugging modes. By clamping the re-pool bound to existing pools, the fix ensures stable inference at maximum context lengths without graph reallocation errors. This is essential for anyone running long-context models where hitting the token limit previously caused instability.

llama.cpp b11342 fixes symlink cache bug

This release addresses a specific but annoying edge case where libstdc++ bugs prevented cache directory creation via symlinks. While the fix itself is narrow, the build matrix confirms that ROCm 10.0 and CUDA 13 support remain active across Linux and Windows, ensuring compatibility with newer hardware stacks. KleidiAI on Apple Silicon is explicitly disabled in this binary set, likely due to stability or testing requirements rather than feature removal. For users hitting symlink errors on Linux, this patch resolves the immediate blocker without requiring source compilation.

GitHub rate limits private vulnerability reports

GitHub is finally capping the flood of automated junk hitting maintainers' inboxes. By enforcing daily per-user limits on new private vulnerability reports, the platform stops bad actors from burying legitimate security findings under noise. Admins can now set custom caps or whitelist trusted researchers, ensuring that actual threats get seen. This shifts the burden from manual triage to automated gating, protecting open source maintainers without blocking genuine disclosures.

GitHub enforces structured vulnerability reports

GitHub is killing the free-text black hole for private vulnerability reports by mandating structured fields. Reporters must now provide a summary, details, impact assessment, and a proof of concept with at least 150 characters, forcing signal over noise. The platform allows custom forms via YAML to tailor these requirements, while also introducing an AI disclosure checkbox to track automated submissions. This shift moves security triage from manual parsing of vague text to structured data that can be programmatically reviewed or integrated into existing workflows.

GitHub Copilot adds desktop computer use

GitHub Copilot now controls your mouse and keyboard, bridging the gap between code generation and actual desktop automation. By leveraging accessibility APIs to read screens and click controls, it can navigate legacy GUI software that lacks APIs or CLIs. This moves AI from a coding assistant to an operational agent for tasks like expense reporting in Safari. You retain control with approval gates, but the ability to automate non-API workflows is a significant shift in utility.

GitHub Copilot Agents Automate PR Merges

GitHub is closing the gap between coding and deployment with Agent Merge, letting AI handle review feedback, conflicts, and checks automatically. This moves beyond simple code generation into autonomous workflow execution within VS Code. HydraFusion coordinates multiple models for complex tasks, while cross-app continuity lets developers pick up Codex sessions from ChatGPT directly in their IDE. The focus is on reducing manual handoffs between writing code and merging it.

GitHub Actions retention now covers checks and runs

GitHub finally unified its data retention policies, bringing checks, workflow runs, and statuses under the same umbrella as artifacts and logs. This eliminates the previous fragmentation where CI/CD metadata had different lifecycle rules than build outputs. The change applies across enterprise, organization, and repository levels, with a hard cap of 90 days for public repos. It’s a backend housekeeping move that simplifies compliance and storage management for teams drowning in GitHub Actions history.

GitHub fixes CI failures for new branch coverage uploads

GitHub has patched a persistent friction point in its Code Quality action that forced developers to choose between broken pipelines and premature pull requests. Previously, pushing code to a new branch triggered an immediate failure because the upload API demanded a PR number that didn't exist yet. Now, the action intelligently skips the upload step with a clear notice, allowing developers to iterate freely before opening a PR. This removes the need for complex conditional logic in workflows just to keep CI green during early development.

Shopify Canvas lets merchants build stores via AI chat

Shopify is merging its Sidekick agent with a real-time visual editor to let merchants build stores entirely through conversation. By granting the AI direct access to theme files and simplifying the underlying architecture, Canvas renders actual interactive code rather than static previews. This moves beyond simple text generation into autonomous site construction, effectively removing the need for developers or manual drag-and-drop editing. While currently limited to desktop and basic themes, it signals a shift where no-code platforms become agent-driven workflows.

GitHub Copilot adds dynamic workflows

GitHub is moving Copilot beyond simple chat by introducing dynamic workflows across the CLI, app, and SDK. This feature lets developers define orchestration logic in code, combining automated steps with multi-agent analysis for tasks like incident investigation or parallel PR reviews. By allowing checkpoints and structured result passing, it brings reliability to complex, multi-step AI operations that standard prompts can't handle. It’s a significant step toward treating AI agents as programmable components within a developer's existing workflow.

Claude Code v2.1.284 adds Sonnet 5.5

Anthropic quietly upgrades its local coding agent with Sonnet 5.5 as the new default, bringing a massive 1M context window to developers' terminals. This isn't just a model swap; it fundamentally changes how much codebase history you can keep in memory without manual chunking. The release also patches critical stability issues like malformed image crashes and broken MCP reconnections, making the tool significantly more reliable for complex workflows. For builders, this means deeper context awareness and fewer interruptions during long coding sessions.

Claude Code v2.1.285 patches security and stability

This release prioritizes security hygiene and session reliability over new features. The addition of CLAUDE_CODE_DISABLE_WEB_FETCH is a critical control for enterprise environments needing to restrict external data access. Bug fixes address subtle race conditions in cloud sessions and artifact publishing that could lead to data loss or incorrect state. SSH and plugin installation issues are resolved, ensuring smoother remote workflows. It’s a maintenance update that tightens the tool's operational boundaries.

llama.cpp fixes MoE dispatch inefficiency on Vulkan

This release targets a specific but costly bottleneck in Mixture-of-Experts inference on GPUs. The previous tile selection logic wasted significant compute time by misjudging the active workload per expert during dispatch. By correcting how matmul tiles are assigned, the patch ensures workers stay busy instead of idling. This is a quiet optimization that directly improves throughput for large MoE models running on Vulkan backends.

llama.cpp Vulkan perf boost on Intel Arc

Intel's discrete GPUs have long been second-class citizens in local inference due to inefficient memory access patterns. This patch fixes that by batching F32 matrix loads two at a time, squeezing significant throughput out of the B60 architecture. Benchmarks show raw GFLOPS jumping from 153 to 221 on specific shapes, proving that driver-level optimizations matter as much as model architecture. It’s a quiet but necessary fix for anyone running llama.cpp on AMD or Intel hardware.

llama.cpp b11267 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing first-class ROCm 10.0 support to both Linux and Windows. AMD GPU users no longer need workarounds for modern hardware, effectively closing a long-standing parity gap with NVIDIA's CUDA ecosystem. Equally notable is the new Snapdragon build for Linux, which targets the emerging AI PC market by leveraging Adreno GPUs and Hexagon NPUs directly. While KleidiAI on Apple Silicon has been disabled in this specific binary set, the expansion into non-NVIDIA silicon signals a strategic shift toward hardware agnosticism that benefits anyone running local models outside of standard data centers.

llama.cpp b11268 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing first-class ROCm 10.0 support to both Linux and Windows. AMD GPU users no longer need workarounds, effectively closing a long-standing parity gap with NVIDIA's CUDA ecosystem. Equally notable is the new Snapdragon build for Linux, which unlocks local AI on ARM-based laptops using Adreno GPUs and Hexagon NPUs. While KleidiAI on macOS has been disabled in this specific binary set, the expansion to AMD and Qualcomm hardware makes this one of the most significant platform broadening efforts yet.

llama.cpp b11270 updates ROCm and CUDA builds

This release quietly tightens the gap between AMD and NVIDIA for local inference by adding ROCm 10.0 as a standard build target alongside updated CUDA 13 support. The inclusion of HIP optimizations for byte subtraction suggests a focus on squeezing out performance gains on AMD hardware without requiring manual compilation flags. While KleidiAI remains disabled in this specific binary set, the broader push to support newer driver stacks ensures compatibility with recent GPU architectures. It is a maintenance-heavy update that prioritizes ecosystem breadth over new features.

llama.cpp b11272 optimizes Hexagon NPU and adds CUDA 13

This release quietly sharpens llama.cpp’s performance on Qualcomm’s Hexagon NPUs by optimizing the concat operation, reducing packet overhead in gather/transpose loops, and swapping software division for fast paths. It also formally supports CUDA 13 across Linux and Windows, closing the gap with NVIDIA’s latest driver stack while keeping ROCm 10.0 alive for AMD users. Apple Silicon KleidiAI builds are disabled here, a notable regression for Mac users who rely on that specific optimization path. The update reinforces llama.cpp’s role as the universal inference runtime, prioritizing hardware-specific efficiency over new model support.

llama.cpp adds ModernBERT reranker support

Local retrieval pipelines just got a significant boost with the addition of classifier_pooling for ModernBERT rerankers. This change allows developers to run high-performance semantic reranking directly in llama.cpp without external dependencies, closing a gap in local RAG stacks. By handling pooling types like 'cls' and 'mean' natively, the library ensures these models work out-of-the-box on supported hardware. It’s a practical step toward fully self-contained, high-quality search systems.

llama.cpp b11274 release with CUDA 13 and ROCm 10

This release quietly cements llama.cpp as the universal inference runtime by adding default builds for CUDA 13.4 and ROCm 10.0, effectively closing the gap with NVIDIA's latest driver stack and AMD's ROCm 10 ecosystem. It also brings Snapdragon support to Linux, expanding local AI capabilities beyond x86 and ARM Macs. While KleidiAI on Apple Silicon is disabled here, the broader platform coverage means developers no longer need to compile from source for modern hardware stacks. The real shift is standardization: if you have a new GPU or chip, llama.cpp likely has a binary ready.

GitHub adds repo-level Dependabot runner config

Dependabot finally gets granular control over where its jobs run. Repository admins can now override the organization-level default to target specific self-hosted runners or larger GitHub-hosted environments using custom labels and groups. This closes a long-standing gap for teams managing private registries or specialized build environments, allowing security updates to run in isolated contexts without affecting other workflows. While public repos and Enterprise Server are currently excluded, this is a critical step toward secure, compliant dependency scanning at scale.

GitHub external custom properties public preview

GitHub finally bridges the gap between code and corporate governance with external custom properties. By allowing systems like CMDBs to push read-only metadata—ownership, compliance status, service tiers—directly into repos, it stops developers from manually tagging repositories in silos. The real win is the dedicated namespace and strict read-only enforcement, which prevents data conflicts between GitHub’s UI and your internal source of truth. This turns repository filtering and ruleset targeting into dynamic, business-aware operations rather than static code-level checks.

OpenAI Codex gets persistent cloud environments and security tools

OpenAI is shifting Codex from a disposable sandbox to a persistent workspace, allowing developers to access reusable cloud environments across any device. This move addresses the friction of spinning up isolated sandboxes for every task, enabling shared workspaces with consistent permissions and faster task initiation. The update also bundles security scanning via Codex Security Cloud and integrates code reviews directly into ChatGPT, effectively turning the agent into a continuous infrastructure partner rather than just a coding assistant.

Ollama adds Jev-style decision models

Ollama 0.35 shifts from pure text generation to structured decision-making via the TypeSafe API, enabling local routing and triage without cloud latency. The release ships three specialized models like Bespoke Lab’s nimble, which clocks 91ms per decision on Apple Silicon M-series chips. This turns consumer hardware into a viable inference engine for real-time logic tasks like ticket routing or safety checks. Developers can now run typed queries locally using the new /v1/systemone endpoint, effectively bridging the gap between LLM reasoning and deterministic application logic.

llama.cpp b11213 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing first-class ROCm 10.0 support to both Linux and Windows. AMD GPU users no longer need workarounds for modern hardware, closing a long-standing parity gap with NVIDIA's CUDA ecosystem. Equally notable is the new Linux arm64 build targeting Snapdragon chips, which unlocks local LLM inference on high-performance mobile SoCs via CPU, Adreno GPU, and Hexagon NPU acceleration. While KleidiAI on Apple Silicon has been disabled in this specific binary set, the broader platform coverage signals a strategic shift toward hardware agnosticism that benefits anyone running models outside of standard NVIDIA setups.

llama.cpp b11214 boosts AMD CDNA large batch performance

This release quietly sharpens llama.cpp’s edge on AMD hardware by enabling the fattn-mma kernel for large query dimensions on CDNA architectures. It specifically targets high-throughput scenarios where batch sizes push dkq beyond 256, a common bottleneck in serving workloads. By optimizing these specific matrix multiplication paths, the update reduces latency and improves throughput for enterprise-style inference without requiring code changes. This is another step in making AMD GPUs competitive with NVIDIA for heavy lifting.

llama.cpp b11215 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing first-class ROCm 10.0 support to both Linux and Windows. AMD GPU users no longer need workarounds, effectively closing a long-standing parity gap with NVIDIA's CUDA ecosystem. Equally notable is the new Snapdragon binary for Linux, which unlocks local AI on ARM-based laptops using Adreno GPUs and Hexagon NPUs. While KleidiAI on macOS has been disabled in this build, the expansion to AMD and Qualcomm hardware makes this one of the most significant platform broadening efforts yet.

llama.cpp adds wide SYCL FWHT kernels for Intel GPUs

Intel GPU users running llama.cpp finally get O(n log n) performance for large Hadamard transforms instead of falling back to slow dense matrix multiplication. This PR extends the Fast Walsh-Hadamard Transform kernel to handle block widths up to 8192, a critical optimization for certain quantization and attention mechanisms on SYCL hardware. The implementation uses work-group local memory to shuffle data efficiently, avoiding the quadratic cost that previously bottlenecked these operations. While it doesn't touch CUDA or ROCm, it significantly closes the performance gap for Intel Arc and Data Center GPU users who were left behind by previous narrow-kernel limits.

llama.cpp b11217 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing first-class ROCm 10.0 support to both Linux and Windows. AMD GPU users no longer need workarounds, effectively closing the hardware gap with NVIDIA for local LLM deployment. Equally notable is the new Snapdragon binary, which unlocks CPU, Adreno GPU, and Hexagon NPU acceleration on Linux arm64 devices, expanding the ecosystem beyond traditional desktops. While KleidiAI on Apple Silicon is temporarily disabled, the addition of CUDA 13 builds ensures forward compatibility with newer NVIDIA hardware. The world now has a single, consistent binary set for almost every major AI accelerator.

llama.cpp b11218 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing first-class ROCm 10.0 support to both Linux and Windows. AMD GPU users no longer need workarounds, effectively closing a long-standing parity gap with NVIDIA's CUDA ecosystem. Equally notable is the new Snapdragon binary for Linux, which unlocks local LLM execution on ARM-based mobile chips using CPU, Adreno GPU, and Hexagon NPU acceleration. While KleidiAI builds are temporarily disabled, the inclusion of CUDA 13 alongside CUDA 12 ensures forward compatibility with next-gen hardware. The world now has a single toolchain that runs efficiently on almost any silicon available today.

llama.cpp b11222 release with ROCm 10 and CUDA 13

This release quietly cements llama.cpp as the universal inference runtime by adding default support for ROCm 10.0 and CUDA 13.4 across Linux and Windows, effectively closing the hardware gap for AMD users who previously lagged behind NVIDIA. The inclusion of Snapdragon AI stack binaries marks a significant expansion into mobile edge computing, while the removal of KleidiAI from macOS builds suggests a strategic pivot toward native ARM optimizations rather than external libraries. For builders, this means fewer compilation flags and broader out-of-the-box compatibility with modern GPU architectures without needing to build from source.

llama.cpp enables chunked prefill for causal rerankers

This release fixes a critical bottleneck for using causal LLMs like Qwen3 as rerankers. Previously, the server rejected batches larger than n_ubatch, forcing users to process long documents in tiny chunks or not at all. By exposing runtime attention checks and allowing chunked prefill for RANK pooling, llama.cpp now handles these workloads efficiently. This removes the hardcoded architectural checks that previously broke multimodal reranking. Users can finally run high-throughput retrieval pipelines without hitting artificial batch size limits.

llama.cpp fixes Vulkan inference bugs on strided KV caches

This release patches critical correctness issues in llama.cpp's Vulkan backend that caused wrong results when processing strided tensor views. The bug specifically affected matrix multiplication operations on KV cache slices, leading to corrupted attention heads during inference on both Intel and NVIDIA hardware. By correcting how batch strides are calculated for in-place tensors, the fix ensures accurate computation across diverse GPU architectures without requiring new model weights. This stabilizes local inference for users relying on Vulkan acceleration, particularly those with non-NVIDIA GPUs or specific memory layouts.

Hugging Face unifies RL environment discovery

Hugging Face is solving the fragmentation plague in reinforcement learning by treating environments as standard datasets tagged for compatibility. Instead of siloed registries, researchers can now tag a single repo with Harbor, Verifiers, or NeMo Gym tags to make it instantly discoverable and runnable across frameworks. This eliminates the tedious manual porting of task sets and centralizes bug reporting in one discussion tab. It effectively turns the Hub into the universal backend for RL infrastructure without forcing users to adopt a new runtime.

Claude Code v2.1.282 patches critical session and UX bugs

This release stabilizes Claude Code by fixing a cascade of session-breaking errors that previously caused silent data loss or API drops. The most significant fix addresses resumed conversations re-sending messages in altered forms, which was corrupting reasoning traces and breaking extended thinking workflows. It also resolves persistent login refresh loops and managed setting parsing failures that plagued enterprise deployments. While the changelog is dense with UI tweaks like scrollbar fixes and vim mode corrections, the core value lies in restoring reliability for long-running agent sessions.

Claude Code v2.1.283: Gateway hints and plugin fixes

This release quietly solves a major pain point for enterprise AI workflows by adding gateway hint headers, allowing LLM gateways to correctly group requests per user prompt instead of treating them as isolated events. The new managed settings for availableModelsMatch and deniedModels give organizations precise control over model access, blocking specific versions even when broader allowances exist. Beyond governance, the update stabilizes the plugin ecosystem with rigorous validation checks that prevent silent failures from broken or misconfigured extensions. These changes shift Claude Code from a developer tool to a manageable enterprise component.

llama.cpp b11183 splits Metal FA kernels

This release quietly refactors how llama.cpp handles Flash Attention on Apple Silicon by splitting kernels into per-dtype libraries. It’s a structural optimization that likely reduces memory overhead and improves compilation times for Metal users, though the immediate performance gains are subtle compared to algorithmic leaps. The build matrix remains massive, adding ROCm 10.0 and CUDA 13.4 support while disabling KleidiAI on Apple Silicon for now. This is infrastructure maintenance rather than a feature breakthrough, but it keeps the runtime robust across the expanding landscape of hardware backends.

llama.cpp b11184 expands Metal support to wider blocks

This release tackles a specific performance bottleneck on Apple Silicon by extending Metal FWHT kernels to handle block widths up to 8192. Previously limited to 512, these wider operations now use threadgroup memory instead of registers, enabling faster inference for larger context windows or model architectures that rely on Hadamard transforms. The update also ships binaries for CUDA 13 and ROCm 10.0, keeping the toolkit aligned with the latest NVIDIA and AMD driver ecosystems. It’s a quiet but necessary optimization that improves throughput on M-series chips without changing the user experience.

llama.cpp b11185 adds ROCm 10 and CUDA 13

One of llama.cpp's quietest but biggest releases. With ROCm 10.0 added as a default build, AMD GPU users stop being second-class citizens for local inference — the gap with CUDA narrows visibly. Apple Silicon Macs now compile in KleidiAI by default, meaning every M-series machine gets ARM-tuned GEMM kernels for free, no flag-flipping required. There's no new model and no new quantization here — just llama.cpp quietly becoming the inference runtime for everyone who isn't on NVIDIA. That's the headline.

llama.cpp fixes LFM2 audio transcription accuracy

A subtle but critical fix in llama.cpp’s mtmd module corrects the mel preprocessor for the LFM2 audio model, eliminating transcription errors that affected over half of tested Japanese utterances. By switching to a symmetric Hann window and adjusting normalization epsilon, the build now matches reference implementations with near-zero error rates instead of changing entire words. This resolves a significant reliability gap for local multilingual speech-to-text, ensuring that open-source inference produces results comparable to proprietary baselines without manual intervention.

llama.cpp b11191 fixes Windows paths, adds CUDA 13

This release quietly patches a critical Windows bug where unicode paths failed to create directories, ensuring local inference doesn't crash on non-ASCII file structures. More importantly, it ships native builds for CUDA 13 and ROCm 10.0, giving users access to the latest NVIDIA and AMD driver stacks without manual compilation. While KleidiAI on Apple Silicon is disabled here, the broad support for newer hardware APIs means developers can finally leverage recent GPU optimizations out of the box.

llama.cpp b11192 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing ROCm 10.0 to both Linux and Windows, closing a long-standing gap for AMD GPU users who previously had to rely on older versions or manual builds. The standout addition is native support for Linux arm64 Snapdragon devices, covering CPU, Adreno GPU, and Hexagon NPU paths, which opens up local AI on high-efficiency ARM laptops that were previously ignored. While KleidiAI on Apple Silicon has been disabled in this specific build, the inclusion of CUDA 13 alongside CUDA 12 ensures NVIDIA users have access to the latest driver features without waiting for a separate patch. The world now has a single binary ecosystem covering x86, ARM, and specialized NPUs, making hardware fragmentation less of an issue for local deployment.

llama.cpp b11194 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing first-class ROCm 10.0 support to both Linux and Windows. AMD GPU users no longer need workarounds, effectively closing a long-standing parity gap with NVIDIA's CUDA ecosystem. Equally notable is the new Snapdragon binary for Linux, which unlocks local LLM execution on ARM-based mobile chips using CPU, Adreno GPU, and Hexagon NPU acceleration. While KleidiAI on Apple Silicon has been disabled in this build, the expansion to AMD and Qualcomm hardware makes local inference significantly more accessible across diverse architectures.

GitHub Copilot adds in-product settings validator

GitHub Copilot now validates enterprise managed settings directly in the UI, catching malformed JSON and invalid team mappings before they break policy enforcement. This shifts validation from a silent failure mode to an explicit feedback loop, saving admins from debugging why their AI controls aren't applying. By pointing to specific files and JSON paths, it reduces the friction of managing .github-private repositories at scale. It’s a pragmatic fix for a common enterprise pain point rather than a new capability.

GitHub Copilot metrics now track PR review stages

GitHub finally exposes the hidden latency in pull request workflows through its Copilot usage metrics API. By breaking down merge times into median and p90 durations for ready-to-first-review, first-to-final review, and final-to-merge stages, teams can pinpoint exactly where bottlenecks occur. This granular visibility distinguishes between waiting for initial attention versus lingering in approval queues, allowing for targeted process fixes rather than guessing. Since it ignores bot reviews, the data reflects genuine human collaboration speed, offering a clear signal on team efficiency.

Copilot Agentic Autofix Now Uses Memory

GitHub is connecting its agentic autofix to Copilot Memory, turning isolated bug fixes into institutional knowledge. Instead of patching a security alert once and forgetting it, the agent now records the resolution pattern for future use. This allows the system to preemptively handle similar vulnerabilities across the repository and share secure coding habits with other tools like code review agents. It shifts Copilot from a reactive fixer to a proactive teacher that learns your team's specific security posture over time.

Meta Muse now exposes full cloud VM filesystem

Meta’s Muse AI has shifted from a standard chatbot to a fully accessible cloud Linux environment, allowing users to download their entire root filesystem. This deliberate architectural choice transforms the interface into a remote development machine where you can install software and compile code freely. While Meta claims secrets are stripped, the ability to browse and archive the full VM state marks a significant departure from the walled-garden approach of competitors like ChatGPT. It effectively turns Muse into a sandboxed computer in the cloud rather than just a text generator.

GitHub Copilot adds Claude Opus 5.5 and GPT-6

GitHub Copilot is rapidly consolidating its position as the default AI layer for developers by integrating the latest frontier models directly into the workflow. The addition of Claude Opus 5.5 and GPT-6 Sol to higher-tier plans signals a shift toward model diversity, allowing users to switch contexts mid-conversation without losing thread continuity. Beyond model selection, the introduction of local sandboxing and OpenTelemetry support addresses critical enterprise concerns around security and observability for autonomous agents. This update moves Copilot from a simple autocomplete tool to a managed, auditable agent platform capable of handling complex, multi-step development tasks with reduced risk.

GitHub Copilot Agents Gain Slack and Teams Context

GitHub is finally bridging the gap between chat apps and code by letting Copilot agents read Slack files and Teams threads. This isn't just a UI tweak; it allows the agent to pull actual context from conversations to create issues or write code, solving the 'context switching' tax developers pay daily. The update also stabilizes long-running tasks with better reconnection logic and model switching, making the cloud agent feel less fragile. For teams on Business or Enterprise plans, this turns chat into a functional development workspace.

CodeQL 2.27.1 updates C++ models and Kotlin support

GitHub quietly expanded CodeQL’s static analysis capabilities with this patch, targeting the messy edges of modern development. The release adds specific taint flow models for Boost.Asio and Protocol Buffers in C++, closing gaps where complex network or serialization logic previously slipped past scanners. It also brings official support for Kotlin 2.4.20 and fixes extraction bugs that caused false positives in Android intent queries. For Go developers, new data flow models cover standard library string and SQL operations, tightening security checks on common patterns. This isn't a new engine, but it makes the existing one significantly more accurate for legacy and enterprise codebases.

GitHub Copilot Enterprise Default Policy Shift

GitHub is shifting the default stance for Copilot features in enterprise and organization settings from opt-in to configurable defaults. This change gives admins three choices: enable all eligible features by default, disable them requiring approval, or let individual organizations decide. The policy covers general availability features, Code Review agents, and MCP servers, with a 28-day grace period before enforcement on October 22. Explicit admin choices are preserved, but unconfigured settings will now follow the global default. This marks a significant move toward standardized AI governance in large-scale development environments.

Claude Code v2.1.281 fixes session stability and adds Bedrock guardrails

This release stabilizes Claude Code's core reliability by fixing persistent bugs in session resumption and prompt caching that previously caused data loss or infinite loops. It also tightens enterprise security with new Bedrock upstream support for IAM role assumption and mandatory guardrail application. The update addresses critical edge cases like proxy stream drops and oversized tool calls, ensuring smoother operation in complex development environments.

llama.cpp b11140 optimizes sparse attention on CUDA

This release targets a specific bottleneck in long-context inference by optimizing the sparse flash attention prefill step for NVIDIA GPUs. By templating kernels to unroll loops at compile time, batched sparse operations drop from 586 microseconds to 244 microseconds on 49k context windows. This isn't just a generic speed bump; it makes handling very long documents significantly more efficient for users relying on sparse attention mechanisms. The change is already baked into the standard CUDA builds, requiring no special flags.

llama.cpp b11146 adds CUDA 13 and Snapdragon support

The latest llama.cpp build brings immediate relevance to users on bleeding-edge NVIDIA hardware with native CUDA 13.4 support across Linux and Windows, closing the gap for those testing next-gen GPU architectures. More notably, it finally addresses the mobile inference landscape by including a dedicated build for Linux arm64 Snapdragon devices, covering CPU, Adreno GPU, and Hexagon NPU paths. This moves local AI beyond just desktop GPUs into the realm of high-performance edge computing on Qualcomm silicon. While Apple Silicon builds have KleidiAI disabled in this specific release, the expansion to ARM-based mobile NPUs marks a significant shift in where llama.cpp can run efficiently.

llama.cpp b11147 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing first-class ROCm 10.0 support to both Linux and Windows. AMD GPU users no longer need workarounds, effectively closing a long-standing parity gap with NVIDIA's CUDA ecosystem. Equally notable is the new Linux arm64 build targeting Snapdragon chips, which unlocks local LLM execution on high-performance mobile hardware via CPU, Adreno GPU, and Hexagon NPU acceleration. While KleidiAI on Apple Silicon has been disabled in this specific binary set, the broader platform expansion signals a shift toward heterogeneous computing that extends well beyond traditional desktop GPUs.

llama.cpp adds vision target support for DFlash/Dspark

This release fixes a critical gap in llama.cpp's handling of multimodal models by allowing vision targets to map correctly to their text vocabularies during conversion. It also resolves a double rope reorder bug affecting LFM2 and LFM2.5 drafters, ensuring stable inference for these specific architectures. These are niche but essential fixes for anyone running complex multimodal or speculative decoding setups locally. The library continues to refine its backend stability without adding new features.

llama.cpp v0.5.0: Backend performance and multi-address server

This is a foundational infrastructure update for local inference, not a flashy new model release. The real story is the backend optimization work: CUDA conv2d acceleration via implicit GEMM and Metal MoE/SSM fusion optimizations directly squeeze more throughput out of existing hardware. For developers running distributed setups, the server now binds to multiple addresses, solving a long-standing routing limitation. It also brings broader model support like HRM-Text and Qwen4Exp, but the performance gains for AMD and Apple Silicon users are the tangible win here.

GitHub Actions drops Node 20, mandates Node 24

GitHub has permanently removed Node 20 from its hosted runners, forcing all JavaScript actions to run on Node 24. The safety net of the unsecure node opt-out is gone, meaning workflows relying on older action versions will break immediately. This shift eliminates legacy runtime support and introduces compatibility constraints for macOS 13.4 and ARM32 architectures. Maintainers must update their action metadata now, while workflow users need to upgrade dependencies to avoid CI failures.

NVIDIA Warp and MjWarp guide for robotics simulation

NVIDIA is pushing hard to make GPU-accelerated physics the standard for robot learning. This deep dive into MuJoCo Warp (MJWarp) shows how to scale a single SO-101 arm simulation to 2,048 parallel environments on CUDA hardware. The real value isn't faster single-step latency, but massive aggregate throughput for reinforcement learning data collection. By leveraging Warp's kernel compilation and CUDA graph capture, developers can batch thousands of physics steps simultaneously, turning the GPU into a high-throughput experience generator rather than just a fast simulator.

GitHub Copilot adds local sandboxing

GitHub Copilot is finally addressing the security risks of AI agents running on your machine with a new local sandboxing feature. By default off, this preview allows developers to strictly limit what the AI can read, write, or access over the network for specific projects. It enforces these policies at the OS level, failing safely if restrictions cannot be applied rather than silently ignoring them. This shifts Copilot from a trust-based assistant to a tool with explicit, configurable boundaries, reducing the blast radius of accidental commands.

GitHub Copilot adds OpenTelemetry for enterprise agent monitoring

GitHub Copilot finally gives enterprises visibility into their AI agents with native OpenTelemetry support. Administrators can now route agent traces to existing monitoring tools, tracking model requests and tool usage without forcing developers to configure telemetry individually. This closes a critical gap in observability, allowing teams to investigate unexpected behavior through step-by-step execution flows. Prompt content remains excluded by default, balancing transparency with privacy concerns for sensitive code.

Copilot JetBrains 1.18 adds agent controls and shared skills

GitHub Copilot for JetBrains is tightening the leash on autonomous coding with assisted approvals that auto-accept low-risk tool calls while flagging higher-risk actions. The update brings organizational governance to individual IDEs, allowing teams to deploy shared skills and custom instructions across both local and agent sessions. Codex agents now offer a plan mode, letting developers review strategies before implementation begins. This shift moves the plugin from simple code completion toward managed, enterprise-grade automation.

Together AI: Fine-tune Jev-like classifier for $17

Together AI proves that specialized classification models no longer require massive budgets or custom infrastructure. By fine-tuning Qwen3.5 4B on a curated 38k-sample dataset, they deliver a Jev-style classifier in just 25 minutes for roughly $17. This approach democratizes high-speed intent detection and sentiment analysis, allowing developers to deploy dedicated HTTP endpoints without the overhead of managing large foundation models. The real shift is moving from generic LLM prompting to cheap, deterministic, task-specific inference.

Claude Code v2.1.280 adds Opus 5.5 and fixes agent stability

Claude Code just got its first major model upgrade with Opus 5.5 as the new default, bringing a 1M context window and aggressive pricing that reshapes local inference economics. Beyond the headline model swap, this release quietly stabilizes the background subagent system, fixing critical issues where tool lists were rebuilt instead of cached and reports were silently lost during compaction. The UI layer also sees significant polish, with mouse support in fullscreen mode and fixes for Windows terminal rendering that had plagued power users. This is less about new features and more about making the agent runtime reliable enough for heavy, multi-step workflows.

GitHub Copilot CLI adds whole codebase indexing for C++

GitHub Copilot CLI finally solves the slow C++ intelligence problem by introducing whole codebase indexing. Instead of rediscovering project structure on every request, it now builds a persistent symbol index using compilation info, making definition lookups and reference searches significantly faster. This shift from ephemeral to persistent context is crucial for large repositories with millions of lines of code. While the initial build takes time and memory, subsequent interactions benefit from immediate reuse. It’s a necessary infrastructure upgrade that makes C++ development in Copilot actually usable at scale.

llama.cpp b11104 adds multi-addr server binding

The llama-server now binds to multiple addresses, a practical upgrade for anyone running local inference behind reverse proxies or complex network setups. This change removes the previous single-address limitation, allowing flexible routing without external workarounds. While the release includes standard binaries for CUDA 13 and ROCm 10.0, the networking feature is the real differentiator here. It makes self-hosted deployments slightly more robust for power users who need granular control over traffic flow.

llama.cpp b11105 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing full ROCm 10.0 support to both Linux and Windows, closing a long-standing gap for AMD GPU users who previously had to rely on workarounds or older versions. The inclusion of CUDA 13 builds alongside CUDA 12 ensures compatibility with the latest NVIDIA driver stacks without forcing users into beta territory. Perhaps most notably, the addition of native Snapdragon support on Linux marks a significant step toward efficient AI inference on ARM-based mobile and edge devices, expanding the hardware ecosystem beyond traditional x86 and NVIDIA dominance.

llama.cpp b11108 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing ROCm 10.0 to both Linux and Windows builds. The real surprise is the inclusion of a setup guide for Linux arm64 on Snapdragon devices, bridging the gap between mobile silicon and local LLMs. CUDA 13 support is now standard across platforms, ensuring compatibility with the latest NVIDIA stacks. While KleidiAI on macOS is disabled in this specific build, the broader platform coverage means developers no longer need to compile from source for most hardware configurations.

llama.cpp b11109 fixes precision bugs

This release addresses a critical correctness issue in the MUL_MAT_ID operation across Metal, CUDA, and Vulkan backends. When source tensors used F32 precision, these accelerators incorrectly accepted operations that should have been rejected, potentially leading to silent numerical errors or crashes. By gating this behavior behind ggml_prec checks, the update ensures strict adherence to supported precision levels on hardware like Apple Silicon and NVIDIA GPUs. This is a necessary stability patch for developers relying on mixed-precision inference workflows.

llama.cpp b11110 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing first-class ROCm 10.0 support to both Linux and Windows. AMD GPU users no longer need workarounds, effectively closing a long-standing parity gap with NVIDIA's CUDA ecosystem. Equally notable is the new Snapdragon build for Linux, which targets the emerging ARM-based AI laptop market with CPU, Adreno GPU, and Hexagon NPU acceleration. While KleidiAI on Apple Silicon is temporarily disabled, the expansion into Qualcomm hardware signals a strategic shift toward heterogeneous edge computing.

llama.cpp b11112 adds vision to function calling

This release quietly bridges a critical gap in local multimodal workflows by allowing input images to be passed directly into function_call_output. Previously, the server struggled to handle visual context within structured tool calls, forcing workarounds that broke automation chains. With this fix, agents can now process screenshots or diagrams and feed them into downstream logic without manual intervention. It’s a small patch with outsized utility for anyone building autonomous vision-capable systems on edge hardware.

llama.cpp b11113 adds ROCm 10 and Snapdragon support

This release quietly cements llama.cpp as the universal inference runtime by finally bringing first-class ROCm 10.0 support to both Linux and Windows. The real surprise is the inclusion of a setup guide for Linux arm64 on Snapdragon devices, bridging the gap between mobile SoCs and local LLMs via CPU, Adreno GPU, and Hexagon NPU acceleration. While KleidiAI on Apple Silicon has been disabled in this build, the simultaneous support for CUDA 13 and ROCm 10 means developers no longer need to choose between NVIDIA and AMD ecosystems for their local stacks. It is a pragmatic consolidation of hardware compatibility rather than a leap in model capability.

llama.cpp b11114 fixes server race conditions

This release targets a critical stability flaw in llama.cpp's server mode where model eviction races could crash inference or drop requests. By forcing every model load through a centralized queue, the system now properly synchronizes state transitions, preventing requests from hitting models that are simultaneously stopping or unloading. It also blocks admission into dying model instances, ensuring traffic is routed to healthy replicas instead of failing silently. For anyone running multi-model servers or hot-swapping weights, this eliminates a class of hard-to-debug concurrency bugs that previously made production deployments unreliable.

llama.cpp b11115 adds AMD ROCm 10 and Snapdragon support

This release quietly expands llama.cpp's hardware reach with two significant additions. The inclusion of ROCm 10.0 builds for both Linux and Windows finally brings modern AMD GPU support to the default binaries, closing a long-standing gap with CUDA. Simultaneously, adding Snapdragon support on Linux arm64 signals a serious push toward local inference on ARM-based AI PCs. While KleidiAI is temporarily disabled on Apple Silicon, the broader platform coverage makes this a practical update for anyone running diverse hardware.

OpenAI expands GPT-6 family with Sol and Luna for Copilot

OpenAI is widening the GPT-6 lineup inside GitHub Copilot by adding two distinct models: Sol for complex agentic coding and Luna for fast, cheap tasks. This moves Copilot away from a single default toward a tiered strategy where developers can explicitly choose between heavy reasoning and lightweight efficiency. Sol targets multistep validation in Pro+ and Enterprise tiers, while Luna opens up to the broader Pro user base as the lowest-cost option. The gradual rollout across IDEs like VS Code and JetBrains means teams can now tune their coding assistants for specific workload profiles rather than accepting a one-size-fits-all approach.

GitHub Deprecates All-Platform CodeQL Bundle

GitHub is killing the convenience of a single download for CodeQL CLI. Starting with version 2.27.0, the monolithic all-platform bundle is deprecated and will vanish by March 2027. Users must now switch to platform-specific archives, a move that forces CI/CD pipelines to manage separate artifacts for Linux ARM64, x86_64, and macOS. This ends the era of 'one size fits all' distribution for static analysis tooling on GitHub, requiring developers to explicitly target their build environment's architecture.

llama.cpp adds env var control for server args

This release solves a real operational headache: configuring llama-server parameters like temperature and penalties via environment variables instead of command-line flags. By supporting LLAMA_ARG_* prefixes, it enables clean integration with systemd EnvironmentFile directives, making deployment on Linux servers significantly more robust and reproducible. The update also refreshes documentation using llama-gen-docs to keep the readme accurate. While no new inference engines are added, this is a practical step toward treating local LLM serving as standard infrastructure rather than a manual script.

llama.cpp b11090 fixes CUDA Volta build

This release quietly repairs a regression in the CUDA backend that broke compilation on older Volta GPUs. By generalizing the tile shape logic in the load_ldmatrix kernel, the maintainers restored support for devices like the Tesla V100 without sacrificing newer architectures. It is a necessary patch for anyone running inference on legacy hardware, ensuring the codebase remains usable across the full spectrum of NVIDIA cards rather than drifting toward only the latest silicon.

llama.cpp b11093 adds CUDA 13 and ROCm 10.0

This release quietly closes the hardware gap for local inference by adding default support for CUDA 13 and ROCm 10.0 alongside existing CUDA 12 builds. Users with newer NVIDIA GPUs or AMD accelerators no longer need to compile from source to get hardware acceleration, effectively making llama.cpp the universal runtime for consumer and enterprise AI chips. The simultaneous availability of both major driver stacks means developers can target the latest hardware without maintaining separate build pipelines. This standardization removes a significant friction point for anyone deploying models on modern, non-CUDA-12-only infrastructure.

llama.cpp b11094 adds CUDA 13 and ROCm 10 builds

This release quietly closes the hardware gap for local inference by adding native support for CUDA 13.4 and ROCm 10.0 across Linux and Windows. For AMD users, ROCm 10 finally brings parity with NVIDIA's latest driver stack, removing a major friction point for high-end GPU acceleration. The inclusion of CUDA 13 ensures compatibility with the newest RTX hardware without waiting for downstream updates. While Apple Silicon builds are present, KleidiAI is disabled here, keeping the focus squarely on expanding x86 and ARM Linux/Windows support. This is infrastructure maintenance that keeps llama.cpp relevant as hardware vendors push new APIs.

llama.cpp b11097 adds CUDA 13 and ROCm 10.0 support

This release quietly closes the hardware gap for local inference by adding native support for CUDA 13 and ROCm 10.0 alongside existing CUDA 12 builds. Users with newer NVIDIA GPUs or AMD accelerators no longer need to compile from source to get hardware acceleration, as these binaries are now pre-packaged. The inclusion of both major driver stacks side-by-side ensures compatibility across a wider range of enterprise and consumer graphics cards without forcing users into legacy versions. This standardizes the experience for developers who previously had to manage complex build environments to support modern AI hardware.

GitHub PR page GA with bulk actions

GitHub’s redesigned pull requests interface has moved from preview to general availability, shifting the focus from basic listing to active triage. The update brings bulk actions like closing or labeling multiple PRs simultaneously, a feature long requested by maintainers drowning in review queues. Advanced search now supports nested logic and AND/OR operators, while collapsible sidebars and compact modes help developers scan more context without endless scrolling. This isn't a new AI model, but it directly addresses the workflow bottleneck of code review management for millions of developers.

Together AI automates model rollouts with metric gates

Together AI solves the high-stakes problem of swapping foundation models in production by introducing automated canary deployments that enforce strict performance gates. Instead of relying on manual traffic shifting or risky hard swaps, their system automatically scales new replicas, validates health, and pauses if metrics like p95 latency regress beyond a defined threshold. This shifts the safety mechanism from human vigilance to platform logic, allowing engineers to test new checkpoints against live traffic with zero downtime and instant rollback capabilities. It effectively de-risks the rapid iteration cycle that defines the current open model ecosystem.

Transformers adds native GGUF support for Apple Silicon

Hugging Face has bridged the gap between its Python ecosystem and local inference by adding native GGUF loading to Transformers. By reusing llama.cpp’s underlying ggml kernels, the library now runs quantized models on Apple Silicon with performance nearly matching the dedicated runtime. This allows developers to use standard PyTorch workflows—like hooks and custom layers—on lightweight GGUF checkpoints without leaving the familiar API. It effectively merges the convenience of local tools like Ollama with the flexibility of the Hugging Face stack.

GitHub Enterprise adds credential inventory exports

GitHub finally gives enterprise admins a centralized view of every active credential across their organization. By exporting a complete inventory of SSH keys, tokens, and app permissions, security teams can instantly map their attack surface during an incident. This moves credential management from scattered manual checks to a single, auditable CSV or API endpoint. It’s a critical infrastructure upgrade for compliance and rapid response, closing a long-standing visibility gap in enterprise security operations.

Grok 4.7 arrives in GitHub Copilot for agentic coding

xAI’s Grok 4.7 has landed in GitHub Copilot, shifting the IDE experience from simple autocomplete to complex, multistep reasoning workflows. This isn't just another model swap; it targets agentic coding tasks that require holding context across multiple files and steps. Available across all major IDEs including VS Code, JetBrains, and Xcode, it brings xAI’s latest capabilities directly into the developer’s primary workspace. The gradual rollout means most users will see it soon, with enterprise admins able to manage access via policy settings. This marks a significant step in making non-OpenAI reasoning models a first-class citizen in the dominant coding environment.

Hugging Face tokenizers v1 delivers massive speed gains

Hugging Face has rewritten its core tokenization library to eliminate the CPU bottleneck that often starves GPUs during inference. By replacing generic regex engines with hand-written SIMD splitters and eliminating memory allocations in the merge loop, version 1 encodes text up to 30 times faster than v0.23 on Apple Silicon. The rewrite preserves exact output compatibility while scaling efficiently across multiple threads. This shift ensures data pipelines no longer idle waiting for tokenization, a critical optimization for high-throughput serving environments.

llama.cpp b11050 adds CUDA 13 and ROCm 10.0 support

This release quietly closes the hardware gap for local inference by adding native support for CUDA 13 and ROCm 10.0 across Linux and Windows builds. Users with newer NVIDIA GPUs or AMD accelerators no longer need to compile from source to get performance, as these binaries are now pre-packaged. The inclusion of OpenVINO and SYCL variants further broadens the pool of compatible hardware beyond just NVIDIA and AMD. While Apple Silicon support is present, KleidiAI has been disabled in this specific build, likely due to stability checks. This is a practical update that keeps llama.cpp relevant as hardware vendors push new driver standards.

llama.cpp b11052 adds CUDA 13 and ROCm 10 builds

This release quietly extends llama.cpp's hardware support to the latest NVIDIA and AMD driver stacks. By shipping native binaries for CUDA 13 and ROCm 10, it removes the friction of manual compilation for users on bleeding-edge GPUs. Apple Silicon KleidiAI is explicitly disabled here, a deliberate choice that likely prioritizes stability over new acceleration features for this specific build. The real value lies in the breadth: with Vulkan, OpenVINO, and SYCL options across Linux and Windows, it remains the most versatile local inference runtime available. Users on newer hardware can finally run pre-built binaries without hunting for custom compile flags.

llama.cpp b11054 adds Hexagon TOP_K support

Qualcomm Hexagon DSP users finally get TOP_K sampling in llama.cpp, closing a functional gap for local inference on Snapdragon devices. This release also bumps CUDA and ROCm versions, keeping the runtime compatible with the latest NVIDIA and AMD drivers without requiring manual compilation flags. It’s a quiet but necessary update that ensures mobile AI workloads don’t fall behind desktop capabilities. The focus remains on stability and hardware parity rather than new model architectures.

llama.cpp b11055 adds CUDA 13 and ROCm 10 builds

This release quietly extends llama.cpp's hardware support to the latest NVIDIA and AMD stacks. By shipping native binaries for CUDA 13 and ROCm 10, it ensures compatibility with newer GPU architectures without requiring users to compile from source. The inclusion of both CUDA versions side-by-side is a pragmatic move for developers managing mixed environments. While no new model optimizations are highlighted, this update keeps the runtime relevant as hardware vendors push their latest drivers.

llama.cpp b11056 adds CUDA 13 and ROCm 10.0

This release quietly closes the hardware gap for local inference by adding default builds for CUDA 13 and ROCm 10.0. NVIDIA users on newer driver stacks can finally run without workarounds, while AMD GPU owners get parity with the latest ROCm version. Apple Silicon KleidiAI is disabled here, shifting focus entirely to broadening backend support across Linux and Windows. It’s not a feature update, but it makes llama.cpp the go-to runtime for anyone managing mixed or modern GPU fleets.

llama.cpp adds Ling 3.0 parser support

llama.cpp finally catches up to the fragmented landscape of Chinese reasoning models with a dedicated parser for Bailing V3 (Ling 3.0). Previous generic parsers failed because this model pre-opens its thinking block, causing tool calls to be misclassified as reasoning content and breaking agent loops. This fix mirrors the logic used in vLLM and SGLang, ensuring that local inference handles these complex turn structures correctly. It’s a necessary plumbing update for anyone running multi-step agents with newer Chinese models.

llama.cpp b11059 optimizes Metal FWHT for Apple Silicon

This release tightens llama.cpp’s performance on Apple Silicon by enabling F16 inputs directly in the Fast Walsh-Hadamard Transform kernel. By removing unnecessary type conversions and replacing conditional branches with branchless SIMD arithmetic, the update delivers a measurable 3% speedup on M-series chips during specific matrix operations. It also fixes build failures on macOS ARM64 by restructuring shared headers, ensuring the Metal backend remains stable as it handles more complex tensor shapes without aborting.

llama.cpp b11060 fixes Mamba memory layout

This release quietly patches a critical memory layout bug in the Mamba state-space model implementation that could cause crashes or silent corruption. By ensuring time-step projection inputs are contiguous and skipping unnecessary copies after normalization, performance improves without changing the API. It also updates CUDA libraries to versions 12.8 and 13.3 across Linux and Windows builds, keeping pace with NVIDIA's latest driver requirements. KleidiAI on Apple Silicon is temporarily disabled, likely due to regression testing needs. For users running Mamba variants locally, this is a necessary stability fix rather than a feature leap.

Claude Code v2.1.277 fixes critical bugs and adds AGENTS.md

This release stabilizes Claude Code by patching a cascade of crashes and session hangs that plagued recent versions. The most notable functional shift is the fallback to AGENTS.md when CLAUDE.md is absent, aligning with broader industry standards for agent configuration. Gateway improvements allow better proxy handling for egress-bound environments, while numerous fixes address edge cases in file editing, plugin management, and resume functionality. It’s a maintenance-heavy update that restores reliability rather than introducing new capabilities.

Claude Code v2.1.278 optimizes auto-mode billing

Anthropic quietly fixed a cost leak in Claude Code’s auto mode. By defaulting to the server-side classifier for API and enterprise users, the update eliminates charges for classifier overhead that previously bled into session costs. This shift means developers no longer pay double for the same logic, while still retaining the ability to opt out via environment variables if needed. The change is a subtle but necessary correction to pricing transparency in automated coding workflows.

llama.cpp b11036 adds CUDA 13 and ROCm 10.0

This release quietly closes the hardware gap for local inference by adding default builds for CUDA 13 and ROCm 10.0. NVIDIA users on newer driver stacks can finally run without workarounds, while AMD GPU owners get parity with the latest ROCm version. Apple Silicon support is explicitly disabled in this build, a notable regression for Mac users who need to wait for the next patch. The inclusion of OpenVINO and SYCL builds further cements llama.cpp as the universal runtime for diverse hardware, ensuring no major accelerator is left behind.

llama.cpp b11037 fixes GPU inference bugs

This release prioritizes stability over new features, addressing critical correctness issues in vector handling for GET_ROWS operations. By fixing vec4 alignment checks and updating CUDA libraries to versions 12.8 and 13.3, it ensures reliable performance across NVIDIA hardware on both Linux and Windows. The inclusion of ROCm 10.0 builds further solidifies AMD GPU support without requiring complex configuration. While no new model architectures are added, these fixes prevent silent corruption in local inference tasks that could otherwise go unnoticed.

llama.cpp b11039 fixes SWA pattern roundtrip

This release finally closes a gap in how llama.cpp handles sliding window attention patterns during model conversion. Previously, loaders silently ignored array-based SWA configurations from models like OLMo2 and Gemma3n, relying on hardcoded defaults that masked potential precision loss. The new Model-Saver now explicitly writes per-layer SWA flags and MLA geometry, ensuring bit-exact roundtrips for a dozen architectures including Plamo3 and Cohere2. This matters because it guarantees that converted GGUF files preserve the exact inference behavior of their original checkpoints, eliminating silent degradation for complex attention mechanisms.

llama.cpp b11040 release with CUDA 13 and ROCm 10

This is a routine maintenance release for llama.cpp, prioritizing stability over new features. The most notable technical shift is the addition of CUDA 13 builds alongside existing CUDA 12 support, giving users access to newer NVIDIA driver stacks without waiting for major version bumps. ROCm 10.0 support remains available for AMD GPU inference, maintaining parity with previous releases. KleidiAI on Apple Silicon has been explicitly disabled in this build, likely due to stability concerns or testing requirements. There are no new model architectures or quantization methods introduced here.

llama.cpp b11042 adds ROCm 10 and CUDA 13 builds

This release quietly closes the hardware gap for local inference by adding default support for ROCm 10.0 and CUDA 13 across Linux and Windows. AMD GPU users finally get first-class runtime parity with NVIDIA, while those on the latest CUDA toolchains can run without manual compilation flags. The update also stabilizes OpenCL binary kernels for specific quantization layouts, reducing friction for non-NVIDIA accelerators. It is a maintenance-heavy release that ensures llama.cpp remains the go-to inference engine regardless of which GPU vendor you trust.

llama.cpp b11043 adds HMX flash-attention for non-standard head dims

This release quietly fixes a compatibility gap that previously blocked models like SigLIP from running efficiently on llama.cpp. By allowing HMX flash-attention to handle head dimensions not divisible by 64, the update removes a significant barrier for vision-language and multimodal architectures. It also refreshes CUDA libraries to versions 12.8 and 13.3 across Linux and Windows builds, ensuring better hardware support without requiring manual compilation. This is less about raw speed and more about expanding the universe of models that can run locally with high performance.

llama.cpp b11044 updates Hexagon and CUDA builds

This release quietly improves performance on Qualcomm Hexagon NPUs by refining IM2COL operations, a critical optimization for running vision models efficiently on mobile devices. The update also solidifies support for newer CUDA versions (12.8 and 13.3) across Linux and Windows, ensuring compatibility with the latest NVIDIA driver stacks without requiring manual library management. By addressing these specific backend kernels, llama.cpp continues to narrow the gap between local inference and specialized hardware acceleration, making it easier for developers to deploy complex models on edge devices and modern GPUs.

llama.cpp b11045 adds CUDA 13 and ROCm 10.0 builds

This release quietly closes the hardware gap for local inference by adding native support for CUDA 13 and ROCm 10.0 across Linux and Windows. Users with newer NVIDIA GPUs or AMD accelerators no longer need to compile from source to access these backends, as pre-built binaries are now available. The inclusion of OpenVINO and SYCL builds further broadens the toolkit for heterogeneous hardware. While Apple Silicon KleidiAI is disabled in this specific build, the expansion into modern CUDA and ROCm versions makes llama.cpp the most accessible runtime for diverse GPU ecosystems.

llama.cpp b11046 adds OpenCL flash attention

This release quietly extends llama.cpp's hardware support to OpenCL GPUs via a new bin kernel for flash attention. By enabling flash_attn_f32_f16_bin on OpenCL, AMD and Intel GPU users gain access to faster inference without relying solely on CUDA or Vulkan backends. The update also includes guarded prefill optimizations for OpenCL, improving performance on specific workload patterns. While not a new model architecture, it solidifies llama.cpp's position as the most versatile local inference runtime across diverse hardware ecosystems.

llama.cpp fixes CUDA argsort corruption bug

A subtle but critical memory aliasing bug in llama.cpp's CUDA backend caused data corruption during top-k selection on large vocabularies. The issue stemmed from CUB's radix sort overwriting its own input when keys and values shared the same buffer, leading to intermittent garbage indices and downstream crashes. This patch ensures distinct buffers for all six call sites, stabilizing inference on NVIDIA hardware with CUDA 12/13. It’s a quiet fix that prevents silent model failures in production environments.

GitHub Copilot Code Review GA with Auto-Resolution

GitHub Copilot’s code review tool has reached general availability, shifting from experimental to a core part of the pull request workflow. The biggest leap is auto-resolution: Copilot now validates whether its own suggestions were actually fixed by subsequent commits and closes them out automatically, saving developers from manual cleanup. It also groups findings into clear states like 'Resolved' or 'Previously missed,' giving a real-time health check of the PR rather than just a static list of errors. This reduces context switching significantly, letting engineers focus on new issues while the AI handles the administrative burden of closing old ones.

GitHub REST API now manages code coverage rulesets

GitHub finally exposes the code coverage ruleset option via its REST API, closing a long-standing gap between UI configuration and programmatic control. This change allows teams to enforce minimum line coverage or maximum tolerable drops directly within infrastructure-as-code workflows, eliminating the need for manual web interface adjustments across multiple repositories. By bringing this enforcement mechanism into the automation pipeline, organizations can now treat code quality gates with the same rigor as security policies. It is a practical step toward consistent, scalable quality management on GitHub Enterprise Cloud and Team plans.

GitHub Copilot adds model tiers and Sentry integration

GitHub is finally giving users control over the cost-performance trade-off in Copilot with new efficiency, balance, and intelligence tiers. This moves beyond blind API calls, letting developers explicitly choose speed versus quality across VS Code and the CLI. The real workflow shift comes from the Sentry canvas, which turns crash reports into actionable pull requests directly within the IDE. Combined with agent metrics now being generally available, Copilot is transitioning from a simple autocomplete tool to a measurable, enterprise-grade development platform.

GitHub Copilot Deprecates Legacy Models in October 2026

GitHub is quietly pruning its model lineup by deprecating selected legacy models across all Copilot experiences on October 19th, 2026. This forces a migration to newer alternatives for both Enterprise and Business customers, with automatic enablement unless administrators have explicitly disabled global defaults. The move signals a strategic consolidation of the underlying inference stack, reducing maintenance overhead while pushing users toward more capable or cost-effective options. Developers relying on specific older model behaviors in their workflows need to audit their integrations now rather than waiting for the cutoff.

npm introduces stage-only tokens for safer automation

npm is closing a critical security gap in CI/CD pipelines by introducing granular 'stage-only' tokens. This feature restricts automated workflows to submitting versions for review rather than publishing them directly, forcing a human with 2FA to approve the final release. It serves as a vital migration path away from bypass-2FA tokens before that capability is removed in January 2027. Developers can now enforce strict separation of duties without switching to trusted publishing immediately.

Claude Code v2.1.275 patches stability and sync

This release stabilizes Claude Code by fixing crashes that occurred when resuming sessions with malformed transcripts or memory files. It also improves the developer experience by syncing skills and plugins from your claude.ai account to terminal sessions, ensuring consistency across environments. Security is tightened by preventing install scripts from running on npm-sourced plugins, while usability sees gains in artifact publishing and image handling. The update addresses critical edge cases that previously broke workflows, making the tool more reliable for daily use.

Claude Code v2.1.276 fixes proxy regression

Anthropic quietly patched a critical regression in Claude Code that broke all API requests for users routing traffic through proxies or gateways. The issue stemmed from an invalid input tag 'advisor_20260301' introduced in the previous version, effectively locking out enterprise and custom infrastructure setups. This fix restores basic functionality for developers who cannot connect directly to Anthropic's endpoints, highlighting the fragility of recent CLI updates.

llama.cpp b11017 adds CUDA 13 and ROCm 10 builds

This release quietly extends llama.cpp's hardware support to the latest NVIDIA and AMD stacks. By shipping native binaries for CUDA 13 and ROCm 10, it ensures compatibility with newer GPU architectures without requiring users to compile from source. The inclusion of both CUDA versions side-by-side is a pragmatic move for enterprise environments managing mixed infrastructure. While no new model formats are introduced, this update keeps the runtime relevant as hardware vendors push their latest drivers.

llama.cpp b11018 adds CUDA 13 and ROCm 10 builds

This release quietly cements llama.cpp as the universal inference runtime by finally supporting NVIDIA's latest CUDA 13 stack alongside AMD's ROCm 10. For the first time, users on cutting-edge hardware can run local models without being forced into legacy driver versions or waiting for vendor-specific optimizations. The inclusion of both CUDA 12 and 13 binaries side-by-side removes a major friction point for developers managing mixed environments. While no new model architectures are added, this infrastructure update ensures compatibility with the fastest consumer and data center GPUs hitting the market right now.

llama.cpp b11019 fixes embedded GGUF loading bugs

This release patches a subtle but critical bug where embedding a GGUF file inside another container caused tensor data corruption due to misaligned memory mapping. The fix ensures the data section is aligned relative to the GGUF header rather than the outer file offset, preventing silent errors that could ruin inference results. It also adds support for loading LoRA adapters via FILE pointers and disables mmap with a warning when alignment issues are detected. This stabilizes llama.cpp for complex packaging scenarios where models are bundled within larger archives or custom formats.

llama.cpp b11020 adds DeepSeek V3.2/V4 parser support

This release fixes a critical parsing gap for DeepSeek's latest models in llama.cpp. By adding message delimiters to the V3.2 and V4 parsers, it ensures chat history is handled correctly during inference. The update also ships binaries for CUDA 13.3/13.4 and ROCm 10.0, keeping hardware support current. KleidiAI on Apple Silicon remains disabled in this build, a notable omission for Mac users seeking optimized performance. It’s a necessary maintenance release that keeps local DeepSeek usage stable.

llama.cpp b11022 adds CUDA 13 and ROCm 10 support

This release quietly closes the hardware gap for local inference by adding native support for CUDA 13 and ROCm 10.0 across Linux and Windows builds. For AMD users, ROCm 10.0 finally brings parity with NVIDIA's latest driver stack, while CUDA 13 ensures compatibility with the newest GPU architectures without waiting for downstream updates. Apple Silicon builds remain available but have KleidiAI disabled in this specific binary set, a notable regression for performance-tuned Mac users. The inclusion of openEuler support for Huawei's Ascend chips further broadens the ecosystem beyond standard x86 and ARM hardware. This is less about new features and more about keeping llama.cpp relevant as underlying compute libraries evolve rapidly.

llama.cpp b11024 updates OpenVINO and CUDA builds

This release quietly tightens the local inference ecosystem by upgrading to OpenVINO 2026.4 and adding explicit support for CUDA 13 across Linux and Windows. The inclusion of ROCm 10.0 binaries further solidifies AMD GPU compatibility, while KleidiAI on Apple Silicon is now explicitly disabled in this build, likely due to stability or performance trade-offs that require separate handling. For practitioners running heterogeneous hardware, the simultaneous availability of CUDA 12 and 13 builds removes version guessing games, ensuring smoother deployment on newer NVIDIA stacks without sacrificing legacy support.

llama.cpp b11026 fixes Qwen3-MoE support

This release is a targeted fix for Qwen3-MoE models that previously failed to load when MTP tensors were fused but not loaded. By skipping gate_up_exps when TENSOR_SKIP is set, llama.cpp finally supports this specific architecture configuration without crashing. It also updates CUDA and ROCm binaries to their latest minor versions, keeping the runtime compatible with recent driver stacks. While not a feature leap, it closes a critical gap for users running large mixture-of-experts models locally.

llama.cpp b11027 adds CUDA 13 and ROCm 10 builds

This release quietly closes the hardware gap for local inference by adding native support for CUDA 13 and ROCm 10.0 across Linux and Windows. Users with newer NVIDIA GPUs or AMD accelerators no longer need to compile from source to get performance; they can simply download the pre-built binaries. The inclusion of CUDA 13.3/13.4 libraries alongside existing CUDA 12 builds ensures backward compatibility while future-proofing the stack. Apple Silicon KleidiAI is explicitly disabled here, a notable omission for Mac users who previously relied on this optimization. This update signals that llama.cpp is aggressively maintaining parity with the latest driver stacks from NVIDIA and AMD.

llama.cpp b11028 adds CUDA 13 and ROCm 10.0 support

This release quietly closes the hardware gap for local inference by adding native support for CUDA 13 and ROCm 10.0 across Linux and Windows builds. For NVIDIA users, this means access to the latest driver stack without waiting for downstream distro packages, while AMD GPU owners finally get first-class ROCm 10 compatibility on par with their CUDA counterparts. The inclusion of OpenVINO and SYCL backends further solidifies llama.cpp as the universal runtime for heterogeneous hardware. There are no new model architectures here, just a critical infrastructure update that keeps the toolchain current with modern GPU ecosystems.

Fintech scales coding agents with self-serve inference

A global fintech solved the bottleneck of spiky AI coding traffic by moving to Together's Dedicated Model Inference, shifting from static capacity planning to real-time self-service scaling. By running GLM-5.2 on 56 B200s with a focus on concurrency rather than raw throughput, they eliminated multi-minute queuing during engineering peaks. The key win is operational autonomy: engineers now manage endpoints and tuning via API without waiting for platform tickets, turning infrastructure coordination into an immediate configuration change.

GitHub Copilot adds feature-level engagement metrics

GitHub is finally giving enterprise admins the granular data needed to measure actual AI adoption rather than just license utilization. The new dashboard and API breakdowns distinguish between passive code reviews triggered automatically and active agent edits or CLI usage, revealing which tools developers actually integrate into their daily workflows. By tracking rolling 28-day populations per adoption phase, organizations can now pinpoint exactly where training is needed instead of guessing based on broad engagement numbers. This shift from counting seats to measuring specific feature interaction marks a maturation in how AI productivity is quantified at scale.

GitHub Copilot CLI adds agentic usage metrics

GitHub is finally giving enterprise admins visibility into how developers actually use Copilot CLI customizations. The new API fields track interaction counts and distinct usage for skills, custom agents, MCP servers, slash commands, and plugins across per-user and aggregate reports. This moves beyond simple seat utilization to measure which automations are gaining traction and where enablement gaps exist. It’s a necessary step for justifying AI infrastructure spend, though the privacy-preserving anonymization of customer-defined names limits granular auditing.

Claude Code relaunches Projects for multi-agent coordination

Anthropic is turning Claude Code into a command center for parallel AI development. The revamped Projects feature lets users spawn multiple cloud-based threads that work on separate branches simultaneously, coordinated by a central agent that manages goals and shared memory. This moves beyond simple chat interactions into structured, multi-step automation where subagents handle complex tasks in loops. While merge conflicts still require human intervention when threads touch the same code, the ability to run parallel sessions significantly accelerates large-scale refactoring or feature development.

GitHub Actions ubuntu-latest migrates to Ubuntu 26.04

The default runner for GitHub Actions is shifting from Ubuntu 24.04 to 26.04, a move that will silently update workflows using the ubuntu-latest label between October and November 2026. This isn't just a patch; it's a full OS upgrade that removes or updates core tools, meaning builds relying on specific package versions could break without warning. Developers need to proactively pin their runners to ubuntu-24.04 if they aren't ready, or test against the new image now to avoid mid-migration failures. The window is wide, but the risk of silent breakage makes this a mandatory maintenance task for any active CI/CD pipeline.

GitHub Actions execution protections GA

GitHub is hardening CI/CD pipelines by making workflow execution protections generally available, targeting the notorious pull_request_target vulnerability. The update adds granular control via workflow file targeting, allowing teams to lock down specific deployment scripts while leaving CI open. A new REST API enables policy-as-code management at scale, and automated enforcement for public repos begins in November 2026. This shifts security from manual configuration to a structured, auditable governance layer.

Claude Code v2.1.265 patches agent stability and plugin loading

This release stabilizes the core agent loop by fixing critical bugs in prompt caching and subagent resume logic that previously broke context reuse. Plugin management gets a significant upgrade with dynamic folder scanning, allowing developers to hot-load tools without restarting the session. The update also hardens security around symlink traversal and refines telemetry routing for enterprise gateways. While not feature-heavy, these fixes make Claude Code more reliable for complex, multi-step coding workflows.

Claude Code v2.1.266 fixes gateway regression

Anthropic quietly patched a regression in Claude Code that broke LLM-gateway and proxy setups. The previous version incorrectly forced Cloud-gateway sign-in when the CLAUDE_CODE_USE_GATEWAY variable was set, even with API keys or custom auth headers configured. This update restores the expected behavior where the variable is ignored unless specific Anthropic credentials are present. Developers relying on custom authentication flows can now resume their workflows without configuration changes.

Claude Code v2.1.267 fixes prompt cache and session resume

This release targets the most painful friction points in long-running coding sessions: broken prompt caching and lost context during resumption. By fixing how MCP tools and system prompts are recorded and replayed, Anthropic ensures that switching models or reconnecting doesn't wipe your conversation history or force redundant tool definitions. The addition of a maxEffortLevel setting gives developers precise control over compute costs across all cloud providers, while specific fixes for VS Code and remote sessions stabilize the daily driver experience. It’s a maintenance-heavy update that quietly restores reliability to complex workflows.

Claude Code v2.1.273 patches security and stability

This release quietly fixes critical permission bypasses that could have allowed dangerous shell commands to slip through the safety net. By tightening how Bash permissions are analyzed and correcting memory directory handling, Anthropic is hardening the tool against accidental data leaks or destructive operations. The update also resolves persistent authentication failures on enterprise cloud platforms like Bedrock and Vertex, ensuring smoother workflows for teams relying on managed settings. These fixes stabilize the agent environment without adding new features.

vLLM v0.29.0rc6 fixes hybrid model caching

This release candidate addresses a critical configuration gap for hybrid models in vLLM by enabling the dense prefix cache by default. Previously, these mixed-precision or multi-head architectures likely suffered from inefficient memory usage or required manual flags to achieve optimal performance. By automating this optimization, the update ensures that users running complex model topologies get better throughput out of the box without tweaking internal parameters. It is a quiet but necessary step toward making vLLM robust for heterogeneous hardware setups.

llama.cpp b10993 adds ROCm 10 and CUDA 13 builds

This release quietly extends llama.cpp's hardware support to the latest driver stacks, adding official binaries for ROCm 10.0 and CUDA 13 across Linux and Windows. For AMD users, this means native compatibility with newer GPU architectures without manual compilation tweaks, while NVIDIA users gain access to the latest CUDA runtime optimizations. The inclusion of WebGPU in CI signals ongoing work toward browser-based inference, though it remains a background effort for now. There are no new model formats or quantization methods here, just broader infrastructure coverage that keeps llama.cpp relevant as hardware evolves.

llama.cpp fixes Metal NaN bug for large activations

A critical precision bug in llama.cpp’s Apple Silicon backend has been patched, resolving total inference failures on models with high-activation ranges like Mistral Small 4. The issue stemmed from f16 saturation during matrix multiplication, which turned entire output tensors into NaN values for inputs exceeding ~32 tokens. By implementing an exact, power-of-two rescaling mechanism in the Metal kernel, the fix restores correctness without significant performance penalties. This ensures local inference on M-series chips remains viable for complex MoE architectures that previously crashed.

llama.cpp b10995 Vulkan and ROCm updates

This release quietly improves inference stability on AMD GPUs by unconditionally enabling the BN/2 tail for MUL_MAT_ID operations in Vulkan. It also adds ROCm 10.0 builds for both Linux and Windows, keeping llama.cpp competitive with CUDA across hardware vendors. Apple Silicon KleidiAI builds are disabled here, likely due to regression testing, but the core CPU and NVIDIA paths remain robust. For local inference users, this means fewer edge-case crashes on AMD setups without needing custom compilation flags.

llama.cpp adds RDNA3.5 GPU support

AMD's new RDNA3.5 architecture was previously left out of llama.cpp's optimized MoE kernels, forcing users to fall back to slower generic paths. This patch corrects that by broadening the tile heuristic to include gfx1151 chips like the Radeon 8060S. The result is a tangible 16% speed boost for Mixture-of-Expert models on these specific GPUs without touching dense logic. It’s a small code change with a big impact for anyone running local inference on the latest AMD hardware.

GitHub Copilot Enhances Custom Property Suggestions

GitHub Copilot is now assisting enterprise and organization admins by suggesting allowed values for custom properties in repositories. This feature, available in public preview for Copilot Business and Enterprise plans, tackles the issue of inconsistent metadata by offering relevant suggestions tailored to the property being defined. For example, when setting up a property like 'FedRAMP', Copilot proposes compliance-related values, making it easier to establish a consistent governance framework. This development accelerates the creation of custom property taxonomies, improving the application of governance rules across extensive repository collections.

Claude Code v2.1.261 Update Released

The latest update to Claude Code, version 2.1.261, introduces several enhancements and fixes aimed at improving user experience and functionality. Notable changes include the addition of settings to increase command output limits and a new feature to identify unused skills, helping users optimize their setups. The update also addresses various bugs, such as character input issues and session management glitches, ensuring smoother operation across different environments. These improvements make Claude Code more robust and user-friendly, particularly for developers using it in complex workflows.

Claude Code v2.1.271 Release

The latest update to Claude Code, version 2.1.271, introduces several enhancements and fixes that improve user experience and functionality. Notably, a fast mode has been added for remote sessions, allowing for quicker operations where permitted. Mouse support in the configuration panel enhances usability, and new command options provide more control over plugin installations. Numerous bug fixes address issues like session management and tool usage, ensuring smoother operation across different environments. This release solidifies Claude Code's position as a robust tool for developers, offering more efficient and reliable coding sessions.

GitHub Copilot Introduces Auto Model Selection Tiers

GitHub Copilot's new auto model selection feature allows users to choose from three tiers—efficiency, balance, and intelligence—each optimizing for different priorities like cost, quality, and response time. This flexibility means users can tailor Copilot's performance to suit tasks ranging from simple to complex. The feature is rolling out across Visual Studio Code, Copilot CLI, and the GitHub Copilot app, offering a more customizable experience. This marks a significant step towards giving users more control over AI model selection, enhancing both usability and cost-effectiveness.

Claude Code v2.1.268 Release

The latest update to Claude Code, version 2.1.268, introduces several enhancements and fixes that improve user experience and system reliability. Notably, it addresses issues with high CPU usage during idle sessions and resolves HTTP 400 errors on third-party endpoints. The update also enhances the gateway management by adding startup warnings and managed settings for public IPv4 blocks. These changes make Claude Code more robust and user-friendly, ensuring smoother operations and better resource management for developers.

Claude Code v2.1.269 Release

The latest update to Claude Code, version 2.1.269, introduces several enhancements and fixes that improve the tool's functionality and user experience. Notably, the update adds a new plugin evaluation feature that provides scored, reproducible results, and enhances output style management. It also addresses numerous bugs, such as issues with terminal compatibility and session management, ensuring smoother operation across different environments. These changes make Claude Code more robust and user-friendly, particularly for developers working in varied terminal setups.

GitHub Copilot adds VS Code Agents metrics

GitHub finally gives enterprise admins visibility into the dedicated VS Code Agents window, separating it from general editor usage. The new API fields track daily active users and message counts, solving the black-box problem of measuring agent adoption. This allows organizations to distinguish between standard autocomplete and actual autonomous agent workflows. It is a necessary administrative update for teams trying to justify Copilot spend on agentic features.

GitHub Copilot Enhances Code Review Automation

GitHub Copilot's latest updates streamline the code review process by automatically resolving comments once addressed and generating smart commit messages. This enhancement allows developers to focus on unresolved feedback, improving workflow efficiency. By leveraging a broader set of shell tools and an ensemble of agents, Copilot now provides more thorough and accurate reviews, especially at the Lite effort level. These changes not only enhance the quality of feedback but also reduce the cost of reviews, making Copilot a more effective tool for developers.

GitHub Copilot Adds Jira Integration and HydraFusion

GitHub Copilot's latest update introduces significant enhancements, including Jira integration and adaptive model orchestration with Project HydraFusion. The Jira integration allows users to seamlessly turn issues into actionable tasks, enhancing workflow efficiency. Project HydraFusion, now in experimental, offers automated semantic routing between different model types, optimizing performance and cost. These updates, along with new agent automation features in Visual Studio Code and expanded enterprise controls in JetBrains, mark a step forward in making AI-driven development more integrated and efficient.

GitHub Unveils Enhanced Pull Request Page Preview

GitHub has launched a public preview of its revamped repository-level pull request page, offering users enhanced filtering and search capabilities. This update introduces a compact presentation mode, allowing more pull requests to be viewed simultaneously, and advanced search options with AND and OR keywords. While some features like milestones and bulk updates are still in development, the preview aims to streamline the pull request process. Users can provide feedback to help refine the experience or switch back to the classic view if preferred.

GitHub Launches AI Scan API for Pull Requests

GitHub has rolled out a public preview of its AI Scan for pull requests, now accessible through REST API endpoints. This feature allows teams to automate the enablement of AI-powered security detections for pull requests at both the organization and repository levels, removing the need for manual configuration in the GitHub UI. Available to GitHub Advanced Security customers, this preview does not extend to GitHub Enterprise Server. By integrating AI-powered detections into the development workflow, GitHub is making it easier for developers to maintain secure codebases without additional manual effort.

GitHub Introduces Cache-Mode for Actions

GitHub has rolled out a new feature called cache-mode for GitHub Actions, allowing users to apply least-privilege access to caches at the workflow or job level. This enhancement aims to prevent unnecessary cache restores or saves, thereby protecting workflows from potential cache poisoning. Users can now specify cache access levels such as read, write, write-only, or none, with job-level settings taking precedence over workflow-level settings. This update is available across all GitHub plans, offering developers more control and security over their CI/CD processes.

CodeQL 2.27.0 adds support for Linux ARM64

CodeQL 2.27.0 marks a significant update for developers using GitHub's static analysis tool, now supporting Linux ARM64. This release enhances security query capabilities, notably with a new Rust query for command-line injection and improved Java/Kotlin framework coverage. Developers can now run CodeQL natively on Linux ARM64, expanding its accessibility. The update also refines analysis accuracy across multiple languages, making it a more robust tool for identifying security vulnerabilities in code.

GitHub Introduces Managed Permissions for Copilot

GitHub has rolled out a new feature for its Copilot Business and Enterprise users, allowing administrators to centrally manage permissions for agent operations. This update provides fine-grained control over shell commands, file access, and network domains, ensuring sensitive operations are securely managed without disrupting workflows. The managed permissions are robust, as they cannot be overridden by individual user settings or previous approvals. This enhancement is available across the GitHub Copilot app, CLI, and Visual Studio Code, offering enterprises tailored security policies for different teams.

GitHub Enhances Security with New Pull Request Rule

GitHub has introduced a new rule for repository rulesets that blocks pull requests from merging if they trigger secret scanning alerts. This feature adds an extra layer of security by ensuring that any secrets introduced in a pull request are resolved before merging. Available in public preview for users with GitHub Secret Protection or Advanced Security, this rule complements existing push protection by catching secrets that might not be detected at the push stage. Developers can configure this rule to target specific branches and secret types, enhancing the security of their codebase.

Enterprise-managed sandbox in Copilot for JetBrains

GitHub's latest update for Copilot in JetBrains IDEs introduces enterprise-managed sandbox policies, allowing administrators to centrally control development environment settings. This ensures consistent boundaries by locking certain IDE controls and prioritizing organizational settings over user preferences. The update also enhances cross-file navigation for edit suggestions, integrates terminal sessions with JetBrains IDEs, and improves model selection and chat experiences. These changes aim to streamline workflows and maintain alignment with enterprise policies, offering a more cohesive development experience.

Dependabot Gains Automatic Access to GitHub Registries

GitHub has improved Dependabot by enabling it to access private GitHub Packages registries without needing a personal access token. This update allows Dependabot to utilize the GITHUB_TOKEN for package reads, which aligns its permissions with those used in GitHub Actions workflows. This change reduces the complexity of managing tokens manually, making it easier for developers to handle dependencies. Initially released in June 2026, the feature faced a temporary rollback due to conflicts but is now back with enhanced authentication handling. This development is particularly beneficial for developers using GitHub-hosted registries, as it simplifies the integration process. By removing the need for personal access tokens, GitHub has made dependency management more efficient and secure.

1Password Boosts Productivity with Codex Integration

1Password has achieved a notable 21% increase in engineering productivity by incorporating Codex into their development workflow. This AI tool enables engineers to efficiently create new features and internal tools, reaching production-ready status while upholding their rigorous security protocols. The integration of Codex illustrates how AI can enhance development processes, allowing teams to concentrate more on innovation rather than repetitive coding tasks. This adoption marks a significant step in how companies are using AI to improve efficiency and maintain high-quality standards in software development.

GitHub Copilot Expands Model Options and Features

GitHub Copilot's latest update introduces new model options and enhanced content protections, marking a significant step in its evolution. With the addition of Claude Fable 5.1 and Gemini 3.8 Flash, users across various tiers can now access more powerful AI models. The update also includes content exclusions to safeguard sensitive code and a public preview of Agent Merge, which aids in resolving pull request issues. These enhancements, along with experimental features like multi-root workspaces and customizable chat backgrounds, aim to improve user experience and workflow efficiency.

npm Enhances Trusted Publishing Configurations

npm has introduced multiple trusted publishing configurations per package, allowing maintainers to manage workflows for stable, prerelease, or staging versions more effectively. This update eliminates the need for workaround solutions or long-lived tokens, as each configuration operates independently with its own criteria. Additionally, staged packages now require malware scanning completion before approval, enhancing security. These changes streamline the publishing process and provide maintainers with greater control and transparency over their package versions.

GitHub Actions: September 2026 Updates Released

GitHub Actions has introduced updates that enhance workflow management with improved visibility and control. A new REST API allows users to track the deprecation timelines of runner versions, aiding in timely upgrades. The introduction of a read-only permission for Dependabot alerts aligns with least-privilege security practices. Additionally, reusable workflows now have enhanced runtime identity features, providing more precise context for job execution. These updates collectively streamline workflow management and security for developers using GitHub Actions.

CodeQL 2.26.4 Enhances Security Detection

CodeQL 2.26.4 brings significant improvements to GitHub's code scanning, enhancing its ability to detect security issues. With the addition of support for Go 1.27 and more precise alert locations for Rust data flow queries, developers can expect a more accurate analysis of their code. The update also refines security checks across C#, Java/Kotlin, and GitHub Actions, potentially leading to an increase in alerts and better protection. These changes make it easier for developers to identify and address vulnerabilities, reflecting GitHub's ongoing efforts to improve code security. The new features are automatically deployed to GitHub code scanning users, ensuring they benefit from the latest advancements.

Claude Code v2.1.259 Release

The latest update to Claude Code, version 2.1.259, brings significant improvements and fixes that enhance its functionality and user experience. With the addition of managed MCP servers and a new permission prompt mode for headless hosts, organizations can now manage their operations more efficiently. The update also resolves various bugs, such as issues with concurrent sessions and prompt cache invalidation, leading to smoother performance. These enhancements make Claude Code more reliable and user-friendly, especially for developers dealing with complex workflows and integrations.

Hugging Face Introduces Funes for Agent Memory

Hugging Face has launched Funes, a tool that provides a durable memory layer for coding agents like Claude Code and Codex. This innovation allows agents to index, retrieve, and rank session logs, enabling them to recall past decisions and rationales during their workflow. Funes operates locally, ensuring privacy and control, and can also sync with a private Hugging Face dataset for broader accessibility. This development enhances the functionality of coding agents by allowing them to seamlessly integrate past knowledge into current tasks, making them more efficient and context-aware.

GitHub Copilot Adds Enterprise Model Customization

GitHub has introduced a new feature allowing enterprises to set default Copilot models for their teams, enhancing customization and workflow alignment. This update enables organizations to assign specific models as defaults based on team membership, providing flexibility in how AI tools are integrated into their development processes. By allowing model preferences to be set at the enterprise level, GitHub is making it easier for businesses to tailor AI assistance to their specific needs. This change is available across GitHub Copilot Business and Enterprise, as well as in the Copilot CLI and Visual Studio Code.

GitHub Copilot Adds Content Exclusion Feature

GitHub has rolled out a content exclusion feature for its Copilot app and CLI, enhancing security for enterprise and organization administrators. This new capability allows administrators to configure policies that prevent sensitive files from being used as context, thereby protecting proprietary code in agentic workflows. Available to Copilot Business and Enterprise customers, this update aims to provide a more secure environment for developers dealing with sensitive information. By implementing these exclusion policies, GitHub Copilot is making strides in offering AI assistance that doesn't compromise security. This development is a clear step towards ensuring that AI tools can be both powerful and safe for enterprise use.

Claude Code v2.1.257 Release

The latest update to Claude Code, version 2.1.257, introduces several enhancements and fixes that improve user experience and functionality. Notably, the new Claude Fable 5.1 model becomes the default, offering a 1M context at competitive pricing. The update also adds new time format settings and a containment escape rule to enhance security. Numerous bug fixes address issues like session management, background processes, and permission handling, making the platform more robust and reliable. This release signifies a step forward in refining the tool's usability and performance for developers.

GitHub Copilot Can Now Approve Pull Requests

GitHub Copilot has introduced a new feature allowing it to assess and approve pull requests, providing developers with an automated judgment on code readiness. This feature is configurable at various administrative levels, including enterprise, organization, and repository, and is available in public preview for certain GitHub plans. While Copilot's approval doesn't automatically fulfill merge requirements, it offers a quick assessment that can be acted upon by developers. This enhancement signifies a step towards more automated and efficient code review processes, though human oversight remains crucial.

GitHub CLI v2.99.0 Adds Media Attachments

GitHub CLI's latest update, v2.99.0, introduces a significant enhancement by allowing users to attach images and videos directly from the command line using the new --attach flag. This feature streamlines the process of adding visual context to issues, pull requests, and comments, eliminating the need to switch to a browser for media uploads. By supporting various media formats like PNG, JPEG, and MP4, this update enhances the efficiency of documenting and reviewing code changes. The update is available to all GitHub users, making it easier to communicate visual information alongside text in a seamless manner.

GitHub Copilot Models Deprecated

GitHub has deprecated several models across its Copilot experiences, affecting features like Copilot Chat and code completions. While Claude Sonnet 4.6 remains available for individual subscribers on annual plans, enterprise users must adjust their settings to access alternative models. This change requires administrators to update workflows and integrations to ensure continued functionality. The move signals a shift in GitHub's model offerings, prompting users to adapt to the new landscape.

GitHub Copilot Enhancements in VS Code August 2026

GitHub's latest updates to VS Code bring significant enhancements to how developers interact with AI agents. The new features make it easier to organize and navigate agent sessions, with options to arrange chats side by side and open side-conversations. Developers can now switch model providers within sessions and continue agent sessions across different applications. The integrated browser and dictation features have also been improved, supporting multiple languages and providing more intuitive feedback mechanisms. These updates aim to streamline the coding process, making AI assistance more accessible and efficient for developers.

Claude Code v2.1.251 Release

The latest update to Claude Code, version 2.1.251, introduces several enhancements and fixes aimed at improving user experience and system reliability. Notable additions include new hook events for model switching and live streaming of tool calls for Remote Control clients. The update also addresses numerous bugs, such as issues with file tools and session management, ensuring smoother operation across various scenarios. These changes make Claude Code more robust and user-friendly, particularly for developers managing complex AI workflows.

GitHub Copilot August Update Enhances Control

GitHub Copilot's August update for Visual Studio 2026 introduces significant enhancements, giving developers more control over AI model usage and reasoning. Users can now adjust the 'thinking effort' of models to better suit their tasks, whether simple or complex. Organization-level custom agents allow for tailored AI assistance across teams, while improved model management lets users pin favorites and manage capabilities more effectively. These updates aim to streamline the coding process, offering more personalized and efficient AI support for developers.

GitHub Copilot Enhances Customization and Performance

GitHub Copilot's latest updates empower developers with enhanced control and flexibility in their coding environments. The introduction of the Customize tab allows users to manage MCP servers, plugins, and skills in a unified interface, simplifying their workflow. The Copilot CLI has been upgraded with a native Rust runtime, delivering a noticeable boost in performance. These enhancements, along with improved session management and integration with tools like Azure DevOps, make Copilot a more effective assistant for developers. The updates aim to refine the user experience, making it easier to manage and personalize AI-driven coding assistance.

Claude Code v2.1.247 Update Released

The latest Claude Code update, version 2.1.247, brings significant improvements to user interaction and functionality. A notable addition is the SendFeedback tool, which allows users to easily draft feedback reports when issues occur, enhancing the feedback process. The update also introduces a cost-optimization feature for Claude API users, enabling them to better manage expenses through various cost levers. Numerous bug fixes have been implemented to improve stability, such as resolving session management and keyboard shortcut issues. These enhancements collectively make Claude Code a more reliable and efficient tool for developers, offering a smoother experience.

Claude Code v2.1.248 Update Released

The latest update to Claude Code, version 2.1.248, introduces several enhancements and fixes aimed at improving user experience and functionality. Notably, it adds a restricted mode to limit command execution and introduces a cache TTL for agent prompts, enhancing performance in long sessions. The update also addresses various bugs, such as prompt-cache misses and session management issues, ensuring smoother operation. These changes make Claude Code more robust and user-friendly, particularly for developers managing complex workflows.

GitHub Copilot Expands Code Review Capabilities

GitHub's Copilot code review has expanded its capabilities, now able to handle pull requests authored by bots and very large pull requests without previous limitations. This update allows organizations to use Copilot code review even without individual Copilot licenses, billing usage directly to the organization. Additionally, users can now specify reasons for resolving Copilot code review comments, providing valuable feedback to improve the tool. These enhancements make Copilot code review more versatile and user-friendly, especially for large-scale projects and automated workflows.

loveholidays Empowers Teams with OpenAI Codex

loveholidays is leveraging OpenAI Codex to democratize software development within their organization. By integrating Codex, they enable non-developers to contribute to the software creation process, effectively turning ideas into products more swiftly. This approach not only accelerates development timelines but also fosters innovation by involving a broader range of perspectives in the product development cycle. The move signifies a shift towards more inclusive and agile development practices, making software creation more accessible to diverse teams.

GitHub Rule Insights Dashboard Now Available

GitHub's rule insights dashboard is now generally available, offering a comprehensive view of how repository rulesets are evaluated and enforced. This tool allows users to easily identify trends and report on governance without the need for manual data compilation. The dashboard provides aggregated metrics and identifies top repositories by bypasses, enabling users to focus their reviews effectively. With filtering options for evaluation status, branch, ruleset, and date range, users can conduct detailed analyses. This release empowers governance and compliance teams to efficiently monitor and report on repository activities, making it a valuable asset for organizations prioritizing compliance and governance.

GitHub Copilot App Adds Customize Tab

GitHub has introduced a new Customize tab in its Copilot app, aiming to enhance user experience by integrating MCP servers, plugins, skills, and canvases into a single interface. This update allows users to explore and implement customizations more efficiently, aligning Copilot with their existing workflows and tools. By offering featured customizations and a streamlined browsing experience, GitHub makes it easier for teams to tailor Copilot to their specific needs. This development signifies a step towards more personalized and context-aware coding assistance, potentially increasing productivity for developers.

GitHub Push Rules Now Support Path Exceptions

GitHub has introduced a new feature allowing developers to configure push rules with path exceptions, providing more granular control over repository management. This means that specific file paths can be exempted from general rules, such as blocking certain file types or enforcing size limits, without relaxing the rules for the entire repository. This update is particularly useful for maintaining strict repository standards while accommodating necessary exceptions. The feature is currently in public preview, allowing users to test and provide feedback.

Claude Desktop Integrates with Ollama Gateway

Ollama has introduced support for Claude Desktop, allowing developers to configure it as a third-party gateway provider. This integration enables users to run open models directly on their computers or utilize cloud models for more extensive tasks, offering flexibility in model usage. The setup is straightforward, with the ability to switch between local and cloud models seamlessly. This development enhances Claude Desktop's versatility, making it easier for developers to leverage different models without compromising data privacy, as Ollama maintains a Zero Data Retention policy.

Gradio Introduces AI Workflow Automation

Gradio's new feature, gr.Workflow, transforms AI workflows by allowing users to create complex pipelines with a simple drag-and-drop interface. This innovation enables users to build, run, and deploy AI applications seamlessly, turning each workflow into a REST API with minimal effort. By integrating with Hugging Face Inference Providers and Gradio Spaces, users can execute multi-step processes and access intermediate results in real-time. This development significantly lowers the barrier for developers to create and deploy sophisticated AI applications, making it easier to experiment and iterate on ideas.

Claude Code v2.1.239 Update Released

The latest update to Claude Code, version 2.1.239, brings a host of fixes and improvements aimed at enhancing user experience and functionality. Notably, the update addresses issues with cloud sessions, proxy handling, and session management, ensuring smoother operation across various environments. It also introduces new features like the fullscreen renderer offer on previously excluded setups and improved cost estimation for US-only inference. These changes make Claude Code more robust and user-friendly, particularly for developers working in diverse technical setups.

GitHub Copilot Integrates with Slack in Public Preview

GitHub has introduced a public preview of its Copilot integration with Slack, allowing teams to leverage AI-driven coding assistance directly within their communication channels. This integration enables users to plan changes, investigate issues, and manage coding tasks seamlessly from Slack, enhancing collaboration and productivity. By mentioning @GitHub in Slack, teams can initiate agent sessions that utilize GitHub context to answer questions, triage bugs, and even open pull requests. This move brings AI capabilities into the flow of team conversations, making it easier for developers to learn from each other and maintain oversight while using AI tools.

Slack introduces collaborative coding feature

Slack is transforming coding into a collaborative effort with its new feature, Slack Code. This innovation allows team members, regardless of their technical expertise, to participate in software development directly within Slack channels. By integrating AI agents like ChatGPT and GitHub, teams can guide and monitor coding sessions in real-time. This move positions Slack as a central hub for AI-human collaboration in software development, making it easier for diverse teams to contribute and oversee projects without leaving the messaging platform.

AI Tools Boost TypeScript's Dominance on GitHub

The rise of AI coding tools has unexpectedly reinforced the dominance of the JavaScript family, particularly TypeScript, on GitHub. Contrary to predictions that AI would make language choice irrelevant, the focus has narrowed to languages like TypeScript due to their compatibility with AI-generated code. This shift is driven by the need for reliable, type-safe code that AI tools can produce efficiently, making TypeScript a preferred choice for developers. As a result, the bottleneck in software development has moved from code generation to code verification, highlighting the importance of type systems in modern coding practices.

Windows 11 arm64 VS2026 image now available

GitHub has rolled out the Windows 11 arm64 image with Visual Studio 2026 for its hosted runners, offering developers the latest tools for their GitHub Actions workflows. This update allows workflows to be configured to run on the new image, which will become the default by the end of September 2026. Developers should be aware that this change might disrupt workflows that rely on Visual Studio 2022, prompting necessary adjustments. By providing access to the latest Visual Studio version, GitHub is ensuring that developers have access to cutting-edge development environments.

GitHub Adds Mitigated Alert Dismissal for Code Scanning

GitHub has introduced a new feature for its code scanning tool, allowing developers to dismiss alerts with a 'Mitigated' reason. This update is significant for teams managing vulnerabilities, as it distinguishes between issues that are actively mitigated by external controls and those simply marked as 'Won’t fix'. By aligning dismissals with formal risk-acceptance processes, GitHub reduces the need for external tracking of these decisions. This change streamlines vulnerability management directly within the platform, enhancing workflow efficiency for developers.

GitHub Introduces Separate Path for Code Quality

GitHub has introduced a dedicated workflow path for CodeQL actions, distinguishing code quality runs from code scanning runs. This update allows users to better track and manage their workflow run history and Actions usage reports. The change does not require reconfiguration of existing code quality setups, but users who have built on the old path need to update their scripts and reports. This separation enhances clarity and management for developers using GitHub's code quality tools.

GitHub Adds Code Quality Audit Log Events

GitHub has enhanced its audit log capabilities by introducing new events that track changes to Code Quality settings on repositories. This update allows users to see when Code Quality is enabled, disabled, or modified, along with details about who made the changes and when. This transparency is crucial for organizations managing billing based on active committers, as it provides clear visibility into when repositories are included in billing calculations. By integrating these events into the audit log API, GitHub offers a more comprehensive tool for monitoring and managing repository settings.

Slack introduces collaborative vibe-coding channels

Slack is stepping into the collaborative coding space with its new Slack Code feature, allowing teams to work alongside AI agents in dedicated channels. This innovation enables users to tag AI agents like Anthropic's Claude or Cognition's Devin to assist in coding tasks, offering real-time code diffs and HTML previews. The channels are designed to archive automatically after task completion, ensuring a streamlined workflow. This move positions Slack as a hub for coding collaboration, integrating seamlessly with popular AI agents and enhancing team productivity.

Claude Code v2.1.229 Release Enhances Stability

Claude Code's latest update, version 2.1.229, brings a focus on enhancing stability and user experience for developers. The release introduces server-supplied Claude Code hook support for self-hosted runner sessions, aligning them with managed environments. SSE keepalive pings have been added to prevent idle-timeout disconnects during long pauses. A new plugin marketplace command allows for seamless plugin integration without requiring a restart. The update also addresses numerous bugs, such as terminal crashes and API errors, making the platform more robust. These improvements reflect Claude Code's dedication to refining its tools and providing a smoother coding experience.

Claude Code v2.1.234 Update Released

Claude Code's latest update, v2.1.234, introduces several enhancements and fixes that improve user experience and security. Notably, it adds a new environment variable for project directory naming and a keybinding action for clearing text selections. The update also addresses security concerns by rejecting certain Windows NT-namespace paths, reducing the risk of credential leaks. Additionally, it improves session management by automatically continuing sessions when usage limits reset and refining permission handling. These changes make Claude Code more robust and user-friendly, particularly for developers managing complex projects.

Claude Code v2.1.235 Update Released

The latest Claude Code update, version 2.1.235, brings a range of enhancements designed to improve both functionality and user experience. A new spellcheck feature now underlines misspelled words in real-time, utilizing libraries such as aspell and hunspell. This version also resolves several bugs, including issues with prompt input highlights and markdown list alignment, ensuring smoother operation. Additionally, memory and CPU usage have been optimized during cloud sessions, making the tool more efficient for developers. These updates collectively make Claude Code a more robust and reliable tool for handling complex prompts and sessions.

Claude Code v2.1.236 Update Released

The latest update to Claude Code, version 2.1.236, introduces several enhancements and fixes that improve user experience and functionality. Notably, the update adds a new environment variable, ANTHROPIC_DEFAULT_MODEL, allowing users to set default models for new sessions. It also improves the handling of idle notifications and fixes various bugs related to session management and rendering issues. These changes make the platform more robust and user-friendly, particularly for developers working across macOS and Linux environments.

Claude Code v2.1.237 Update Released

Claude Code's latest update introduces a 'Concise' output style, allowing users to receive results directly without unnecessary preamble. This feature is designed to streamline the user experience by focusing on delivering results efficiently. Additionally, the update addresses prompt caching issues for sessions using an LLM gateway or custom base URL, enhancing reliability. These changes make Claude Code more user-friendly and efficient, particularly for developers seeking quick and direct outputs.

CodeQL 2.26.3 Enhances GitHub Actions and JavaScript Modeling

The latest update to CodeQL, version 2.26.3, brings significant improvements to GitHub Actions queries and JavaScript modeling. By refining the recognition of untrusted data in GitHub Actions and enhancing JavaScript and TypeScript source modeling, this update aims to improve the accuracy of security scans. Notably, it introduces flow models for Vue's Composition API and recognizes Vue Router's useRoute() as a client-side remote flow source. These enhancements are designed to help developers more effectively identify and address security vulnerabilities in their codebases.

GitHub Adds Code Quality Trends Dashboard

GitHub's new Trends tab in the Code Quality dashboard offers a fresh way to monitor code quality evolution over time. This feature allows users to see whether open findings are increasing or decreasing and identifies which repositories are contributing to these changes. Available to users on GitHub Enterprise Cloud and Team plans, it ranks repositories by improvement or need for support, enabling teams to focus their efforts where needed. This update empowers organizations to manage code quality more strategically, providing a proactive approach to maintaining high standards across projects. By offering a dynamic view of code quality trends, GitHub enhances the ability to address issues before they escalate.

Replit Launches Free Mode with GPT-5.6 Luna

Replit's introduction of Free Mode, powered by GPT-5.6 Luna, marks a significant step in making software development more accessible by removing token costs. This initiative could open doors for aspiring developers and hobbyists who previously faced financial barriers. By integrating GPT-5.6 Luna, Replit enhances its platform, offering a seamless experience for users to transform their ideas into working software. This move is a testament to Replit's commitment to fostering a more inclusive environment for innovation and creativity in the coding community. With Free Mode, Replit is not just expanding its user base but also encouraging a new wave of software creators.

GitHub Copilot Adds Enterprise Controls for JetBrains

GitHub Copilot for JetBrains now offers enterprise-level managed settings, allowing administrators to enforce consistent plugin governance and server access across their organizations. This update introduces centralized control over which plugins can be enabled or disabled, and restricts marketplace access to approved sources only. Additionally, administrators can manage OpenTelemetry configurations to ensure telemetry data is routed to designated collectors, enhancing data governance. These features provide enterprises with greater control over their development environments, ensuring compliance and security standards are met.

GitHub Enhances Credential Revocation Controls

GitHub has introduced more granular controls for credential revocation, allowing enterprise owners and admins to revoke specific types of tokens during security incidents. This update means that instead of revoking all user credentials at once, administrators can now target specific credential types like personal access tokens or SSH keys. This refinement helps contain security breaches more effectively by limiting the impact to only compromised credentials. The update also extends these capabilities to the organization level, providing a more flexible and precise response to security threats.

Warp Introduces Warp Factories for AI Development

Warp has launched Warp Factories, a system designed to make AI software factories more accessible for smaller companies. This infrastructure layer provides a pre-configured environment for deploying and managing AI agents, simplifying the software development process. By automating stages like triage and verification, Warp Factories enhances productivity while still requiring human oversight for complex tasks. The system integrates with popular tools like Slack and Jira, allowing it to fit seamlessly into existing workflows. This development could democratize access to advanced AI capabilities for companies lacking extensive resources, enabling them to compete more effectively in the AI space.

Asana Accelerates Engineering with OpenAI Codex

Asana's use of OpenAI Codex to revamp its testing system is a compelling example of AI's ability to revolutionize software development timelines. The task, initially projected to take five years, was completed in just two weeks, showcasing Codex's power to automate and speed up complex coding tasks. This not only saved significant time but also cost Asana only $12,000, illustrating the economic benefits of integrating AI into development processes. The achievement marks a shift in how companies might tackle large-scale engineering challenges, with AI tools like Codex providing a powerful alternative to traditional methods. By leveraging AI, Asana has demonstrated a new way forward for addressing extensive technical projects.

Claude Code v2.1.233 Release

The latest update to Claude Code, version 2.1.233, brings significant improvements and fixes that enhance both functionality and reliability. With the addition of GitLab merge request URL support and opt-in memory cgroup support for Linux, developers can expect smoother operations and reduced risk of session stalls. The update also resolves issues such as cloud sessions being incorrectly marked as lost and idle sessions consuming excessive CPU resources. These enhancements make Claude Code more robust and efficient, particularly for developers working with complex projects. Overall, this release aims to streamline the development process and improve user experience.

GitHub Enhances OAuth App Security Features

GitHub has introduced significant updates to its OAuth and GitHub App platforms, focusing on security and flexibility for developers. OAuth apps can now use expiring access tokens and refresh tokens, enhancing security by limiting token lifespan to eight hours with a six-month refresh period. Additionally, developers can register up to 10 redirect URIs, simplifying support for multiple environments. Wildcard matching for redirect URIs is now available, allowing more flexible URL configurations, though caution is advised to prevent misuse. These updates aim to streamline app development while maintaining robust security measures.

Claude Code v2.1.232 Release

Claude Code's latest update, v2.1.232, introduces several enhancements and fixes that improve user experience and security. Subagent forking is now enabled by default, allowing for more efficient session management. GitLab support has been expanded, making it easier to clone repositories and manage credentials securely. The update also addresses various permission bypass issues and improves the handling of remote control sessions, ensuring smoother operation across different environments. These changes make Claude Code more robust and user-friendly, particularly for developers managing complex workflows.

GitHub Copilot Enhances Flexibility with New Features

GitHub Copilot's latest updates introduce significant enhancements that boost its adaptability and usability across different development environments. The rollout of the Kimi K3 and MAI-Code-1.1-Flash models brings improved coding quality and native image understanding, elevating the developer experience. With Agent Plugins 1.0, developers can now create a plugin once and deploy it across multiple tools, streamlining their workflow. These updates aim to provide a more cohesive and efficient coding experience, making Copilot a more versatile tool for developers using editors like VS Code and the Copilot CLI.

Agent Plugins 1.0 Launches for VS Code and Copilot

Agent Plugins 1.0 introduces a unified approach to plugin development, allowing a single plugin to be utilized across various agent clients like VS Code and GitHub Copilot. This open standard, backed by industry leaders such as AWS, Microsoft, and Google, aims to streamline the development process by reducing the need for duplicate efforts. By standardizing the integration of skills and MCP servers, developers can more easily maintain and distribute their plugins. The initiative promises a more cohesive ecosystem, simplifying plugin management and ensuring compatibility across different environments. Existing plugins remain supported, ensuring a seamless transition for current users.

GitHub Launches Organization-Level Rule Insights Dashboard

GitHub has expanded its rule insights dashboard to the organization level, now in public preview. This new feature provides a comprehensive view of how repository rules are evaluated and enforced across all repositories within an organization. It allows governance and compliance teams to easily spot trends and report on governance without manually compiling data. Users can filter results by various criteria and export data for reporting, making it a powerful tool for auditing and incident response. This update builds on the repository-level insights introduced earlier, offering a more holistic approach to organizational compliance management.

GitHub Copilot for JetBrains Enhances Features

GitHub Copilot for JetBrains has introduced several enhancements, including persistent memory and local model access, which streamline developer workflows. The update allows Copilot to retain context across chat sessions, reducing repetitive input from users. Additionally, the integration of Ollama as a BYOK provider offers more flexibility in model selection. These improvements, along with enhanced enterprise controls and reliability fixes, make Copilot a more robust tool for developers using JetBrains IDEs. The changes aim to simplify setup and improve the overall user experience.

GitHub Enables Easy Migration to Repository Rulesets

GitHub has introduced a new feature that allows users to convert existing branch protection rules into repository rulesets directly from their repository settings. This streamlines the transition to GitHub's more flexible policy framework, eliminating the need to manually recreate each rule. The new rulesets provide enhanced capabilities, such as applying rules across multiple branches and managing them at an organizational level. This update signifies GitHub's ongoing investment in improving repository governance, making it easier for users to maintain and enforce policies efficiently.

GitHub Adds Token Breakdown to AI Usage Reports

GitHub has enhanced its AI usage reports by providing a detailed per-model token breakdown. This new feature allows users to see the specific input, output, cache read, and cache write tokens that contribute to their AI credits. Previously, users could only see the total AI credits consumed, making it difficult to understand or reduce costs. Now, with this transparency, users can better manage their AI expenses and communicate these details to stakeholders. This update is available to admins on Copilot Business and Enterprise, as well as individual Copilot users.

GitHub Copilot Chat Enhances User Controls

GitHub has enhanced its Copilot Chat on the web, making it more user-friendly with new conversation controls. Users can now minimize the chat window to continue browsing GitHub while waiting for responses, and easily access recent conversations. Additionally, token spend indicators provide transparency on usage, helping users manage their Copilot token budget effectively. These updates are available to all Copilot plans, offering a more seamless and informed user experience.

Claude Code v2.1.225 Update Released

The latest update to Claude Code, version 2.1.225, brings significant improvements and fixes to enhance user experience. With the addition of gateway spend-limit support, users now receive detailed warnings about their usage caps. The update also resolves persistent OAuth token errors on macOS, ensuring smoother authentication processes. Enhancements in session handling for headless modes improve reliability, while the Remote Control feature now allows initiating conversations across machines by name, making communication more seamless. These updates collectively aim to provide a more stable and efficient coding environment.

Meetily Offers Free Meeting Transcription and Summarization

Meetily is making waves by offering a free, open-source meeting transcription and summarization tool that doesn't require a subscription. Unlike many paid services, Meetily allows users to transcribe meetings in real-time without uploading sensitive data to the cloud, addressing privacy concerns. The tool is compatible with various videoconferencing platforms like Zoom and Google Meet, and even supports offline use for pre-recorded audio or video files. While the free version lacks speaker identification, it provides a practical solution for those seeking cost-effective meeting management without compromising confidentiality.

Claude Code v2.1.224 Update Released

Claude Code's latest update, v2.1.224, introduces significant enhancements for developers using self-hosted environments. Users can now run Claude Code sessions on their own machines, expanding flexibility for Team and Enterprise plans. The update also simplifies plugin installation with a new archive plugin source, allowing installations from a zip over HTTPS. Additionally, cross-session messaging capabilities have been improved, enabling seamless communication between sessions on different machines. These changes enhance the usability and integration of Claude Code, making it a more robust tool for developers.

GitHub Copilot Enhances Workflow with New Features

GitHub Copilot's latest updates bring a suite of enhancements aimed at improving workflow efficiency and user interaction. The updates include the ability to see which AI model handled requests, manage multiple sessions with ease, and explore changes without disrupting ongoing work through the new /worktree command. The integrated browser now allows for element-level feedback, and dictation supports multiple languages on-device. These features collectively enhance the user experience by providing more control and flexibility in managing tasks and reviewing changes.

GitHub Copilot Dashboard Adds ROI Section

GitHub has enhanced its Copilot impact dashboard by introducing a 'Potential return on investment' section. This new feature allows organizations to directly correlate their spending on Copilot with the output in terms of pull requests, offering a clearer picture of the tool's financial impact. By comparing different user adoption phases, administrators can now better justify investments and tailor enablement programs. This update provides a more comprehensive view of Copilot's value, helping decision-makers optimize their AI tool usage based on actual cost and productivity metrics.

GitHub Copilot Code Review Levels Now Available

GitHub has made its Copilot code review effort levels, Lite and Balanced, generally available. These levels allow developers to tailor the depth of code reviews to the complexity and risk of pull requests. Lite is suited for straightforward changes, while Balanced is designed for more complex or sensitive code. This feature is available across various Copilot plans, enabling organizations to set default review levels that can be inherited by repositories. This development enhances the flexibility and precision of code reviews, making it easier to manage review depth across projects.

GitHub Expands Secret Scanning Coverage

GitHub has enhanced its secret scanning capabilities, adding more secrets to its push protection and partnering with Lovable Labs. This update means that when a Lovable Labs secret is detected in a public repository, GitHub will notify Lovable Labs for action. Additionally, the update introduces richer metadata on alerts, providing details like secret ownership and expiry dates, which helps users assess the impact without leaving the alert interface. This expansion makes secret scanning more robust, offering developers better tools to manage and protect sensitive information in their repositories.

Claude Code v2.1.221 Update Released

The latest update to Claude Code, version 2.1.221, introduces several enhancements and fixes aimed at improving user experience and security. Notably, a new Focus view in VSCode allows users to streamline their workflow by hiding tool activity, while a new 'mask' mode for sandbox credential files enhances security on Linux and WSL. The update also addresses various bugs, including permission-check bypasses and session management issues, ensuring smoother operation across different environments. These changes make Claude Code more robust and user-friendly, particularly for developers working with complex toolchains.

Claude Code v2.1.223 Release

The latest update to Claude Code, version 2.1.223, introduces several important fixes and enhancements aimed at improving security and usability. Notably, it addresses permission bypass issues in Bash commands and workflow scripts, ensuring stricter adherence to security protocols. The update also refines the handling of model IDs and session management, providing more robust error handling and session continuity. These changes make Claude Code more reliable and secure for developers, particularly in managing complex workflows and permissions.

GitHub Enhances Code Scanning Customization

GitHub has introduced a new feature that allows developers to apply custom configuration files to the CodeQL code scanning setup, enhancing security analysis across repositories. This update provides granular control over security scans without the need to maintain separate GitHub Actions workflows for each repository. Organizations can now centralize their security configurations, ensuring consistency while allowing flexibility for individual repositories to tailor settings as needed. This feature is now available on GitHub.com and will be included in GitHub Enterprise Server 3.23, marking a significant step in scalable security management.

GitHub Automates Code Coverage Setup with AI

GitHub is making it easier to set up code coverage by introducing an AI-driven feature in its Code Quality settings. This new capability allows users to automatically generate a coverage workflow, significantly cutting down the time and effort usually required. By initiating a pull request for review, GitHub ensures that users can seamlessly integrate this feature into their repositories. This development is currently in public preview for GitHub Code Quality users on github.com, enhancing the efficiency of code quality management without the need for manual workflow authoring.

CodeQL 2.26.2 adds Swift and Kotlin support

The latest update to CodeQL, version 2.26.2, enhances its static analysis capabilities by adding support for Swift 6.3.3 and Kotlin 2.4.10. This means developers using these languages can now leverage CodeQL's security scanning features more effectively. The update also refines several queries, improving the detection of path injection and URL redirection vulnerabilities. These changes aim to provide more accurate results, helping developers identify and fix potential security issues in their codebases. This release is automatically available to GitHub code scanning users, ensuring immediate access to these improvements.

GitHub Copilot Adds Customizable Reasoning Levels

GitHub Copilot's cloud agent now allows users to customize the reasoning level of AI models, offering more control over task execution. This feature enables users to adjust how much the model reasons before responding, which can enhance the quality of answers for complex problems. However, higher reasoning levels consume more tokens and credits. This new capability is available across all paid Copilot plans, providing users with a tailored AI experience that balances depth of reasoning with resource consumption.

GitHub Copilot Automations Triggered by Comments

GitHub has introduced a new feature for Copilot users, allowing automations to be triggered by comments on issues or pull requests. This enhancement enables developers to streamline workflows by automating tasks such as documentation generation, error investigation, and follow-up task creation directly from comments. By specifying trigger text, users can customize these automations to fit their specific needs. This feature is available to Copilot Pro, Pro+, Max, Business, and Enterprise users, with certain configurations required for business accounts. This update enhances the integration of AI-driven automation in the development process.

GitHub Introduces Self-Repository Syntax for Actions

GitHub has streamlined the process of referencing actions and workflows within the same repository by introducing a new self-repository syntax. This update eliminates the need for checkouts or hardcoded versions, reducing maintenance burdens and ensuring consistency with commit SHA pinning. By using the self-repository syntax, developers can now easily maintain internal references that automatically align with the current commit. This change not only simplifies workflow management but also supports enterprise policies requiring full-length commit SHA pinning.

GitHub Launches Stacked Pull Requests in Preview

GitHub's new stacked pull requests feature is now in public preview, offering developers a streamlined way to manage large code changes. By breaking down big changes into smaller, reviewable pull requests, teams can maintain quality and speed up the review process. This feature integrates seamlessly with existing GitHub tools, allowing for parallel reviews and efficient merging. The introduction of stacked pull requests promises to reduce bottlenecks in code review, making it easier for teams to manage complex projects without overwhelming reviewers.

GitHub Copilot July Update for Visual Studio

GitHub's latest update for Copilot in Visual Studio introduces a new agent built on the Copilot SDK, enhancing task efficiency with fewer interactions. This update also integrates built-in skills from the .NET and Azure teams, allowing developers to customize workflows more effectively. Additionally, a new feature enables code review directly within the editor, providing inline comments and suggestions. Organization-level custom instructions streamline Copilot's responses across teams, though some features require specific Copilot plans. These enhancements aim to make Copilot more adaptable and efficient for developers.

GitHub Copilot Enhancements in VS Code July 2026

GitHub's latest updates to Visual Studio Code bring significant enhancements to the Copilot experience, particularly in managing and interacting with AI agents. The new Agents window, still in public preview, offers a redesigned layout and improved workflows for handling multiple sessions. Users can now engage in multi-chat sessions with Claude, allowing for more dynamic and parallel conversations. Additionally, the integration of Copilot vision enables users to add images and PDFs directly into chat, expanding the scope of collaboration. These updates make VS Code a more powerful tool for developers, enhancing both productivity and flexibility in coding environments.

GitHub Copilot Enhances Code Review with Agent Skills

GitHub has expanded its Copilot code review capabilities, making agent skills and MCP server integration available to Pro, Business, and Enterprise users. These features allow teams to embed their internal tools and coding standards directly into the code review process, providing more tailored and context-rich reviews. By linking to third-party platforms like issue trackers and documentation systems, Copilot can draw in relevant information to enhance the review process. This update marks a significant advancement in AI-assisted code reviews, offering a more customized and informed approach for development teams using GitHub.

CodeQL 2.26.1 Enhances Analysis Accuracy

The latest update to CodeQL, version 2.26.1, brings significant improvements to the static analysis engine used in GitHub code scanning. This release enhances framework coverage for languages like Go, Java/Kotlin, and JavaScript/TypeScript, while also reducing false positives in Rust analysis. Notably, it introduces better modeling for Go's structured logging and recognizes Angular decorators in JavaScript/TypeScript. These updates mean developers can expect more accurate security issue detection and remediation, making CodeQL a more reliable tool for maintaining secure codebases.

GitHub Copilot Expands Usage Metrics Reporting

GitHub has enhanced its Copilot usage metrics API, now offering more granular insights into individual user activity within the Copilot app. Previously, Copilot app usage was only visible at an enterprise or organization level, but now it includes detailed breakdowns by feature, model, and language. This allows enterprise owners and billing managers to better understand how the Copilot app is being used, who is using it, and what it produces. The update makes it easier to compare Copilot app activity with other surfaces like IDEs and coding agents, providing a comprehensive view of AI-assisted coding within organizations.

GitHub Expands Dependabot Alerts with OpenSSF Data

GitHub has enhanced its Dependabot alerts by integrating malware advisories from the OpenSSF malicious-packages repository. This update significantly broadens the scope of malware data available, covering ecosystems like npm and PyPI. Users with malware alerting enabled will automatically receive alerts for dependencies matching this expanded set of advisories. This integration means developers can now benefit from a more comprehensive security coverage without additional setup, making it easier to identify and mitigate potential threats across various ecosystems.

GitHub Copilot for JetBrains Enhances Model Management

GitHub Copilot for JetBrains has rolled out an update that enhances model management and telemetry configuration, offering developers more control over their workflows. The update allows for the configuration of OpenTelemetry export settings, aligning plugin behavior with organizational observability requirements. Developers can now manage token limits and enable or disable built-in models, providing better cost control and governance. Additionally, the integration of MCP servers and custom agents into Claude agent flows offers increased flexibility for specialized workflows. These improvements aim to streamline the development process and enhance user experience within the JetBrains IDE environment.

GitHub Copilot App Gains Enterprise Managed Settings

GitHub has expanded its enterprise managed settings to include the Copilot app and Copilot cloud agent, allowing organizations to enforce consistent governance across all Copilot clients. This update means enterprise owners can define a single set of policies, such as plugin usage and approval prompts, which are automatically enforced across the Copilot ecosystem. This ensures that developers adhere to the same security and compliance standards, regardless of the platform they use. By integrating these settings, GitHub aims to provide high-trust environments for teams adopting Copilot, enhancing security and consistency in development workflows.

Claude Code v2.1.218 Update Released

The latest update to Claude Code, v2.1.218, introduces several improvements and fixes that enhance user experience and functionality. Notably, the /code-review feature now operates as a background subagent, preventing conversation clutter and improving workflow efficiency. The update also addresses various bugs, such as Windows path corruption and session stability issues, ensuring smoother operations. These changes make Claude Code more robust and user-friendly, particularly for developers relying on its tools for code review and management.

GitHub Mobile Integrates Copilot for Fixing Actions Checks

GitHub Mobile now allows developers to fix failing GitHub Actions checks directly from their mobile devices using Copilot. This feature enables users to select 'Fix with Copilot' when a check fails, prompting Copilot to create a new pull request with a proposed fix. This integration streamlines the process of addressing CI failures on the go, making it easier for developers to maintain workflow momentum. The feature is available on the latest versions of GitHub Mobile for both iOS and Android, enhancing mobile development capabilities.

GitHub Issues Adds Agent Automation Controls

GitHub has introduced new agent automation controls in GitHub Issues, allowing users to manage how issues are labeled, typed, assigned, and closed. The update includes features like Approvals, Confidence, and Rationale, which provide users with the ability to review changes before they are applied. This means users can now decide the level of automation they want, with high-confidence changes applying automatically and others held for review. This enhancement aims to streamline issue management while maintaining user oversight, especially useful for busy repositories needing careful change management.

GitHub Launches Copilot Impact Dashboard for Enterprises

GitHub has introduced a new Copilot metrics impact dashboard designed for enterprise administrators and organization owners. This tool provides a detailed view of how Copilot is being used within organizations, moving beyond simple active-user counts to show adoption depth and impact. By categorizing users into different AI adoption phases, the dashboard offers insights into user engagement and provides actionable steps to enhance adoption. This release empowers organizations to better understand and optimize their use of Copilot, potentially increasing productivity and efficiency.

GitHub Code Quality Now Generally Available

GitHub has launched its Code Quality tool for general availability on GitHub Enterprise Cloud and GitHub Team, addressing the challenge of maintaining code quality in the age of AI-accelerated development. By combining CodeQL's deterministic analysis with AI-assisted detection, it helps developers catch and fix maintainability and reliability issues before merging pull requests. This tool is now a standalone paid product, offering organization-wide dashboards and quality gates, and is designed to complement GitHub Advanced Security. With over 10,000 enterprises having tested it during the public preview, Code Quality is set to enhance code trustworthiness across teams.

Claude Code v2.1.214 Update Released

The latest update to Claude Code, version 2.1.214, brings a host of fixes and enhancements aimed at improving security and functionality. Notably, it addresses permission-check bypasses in Windows PowerShell and enhances Bash permission checks to handle complex commands more securely. The update also introduces the EndConversation tool, allowing Claude to terminate sessions with abusive users, and adds new logging attributes for better message-level correlation. These changes make the platform more robust and user-friendly, particularly for developers working in complex environments.

GitHub Copilot Adds Repository-Level Usage Metrics

GitHub has expanded its Copilot usage metrics to include detailed repository-level insights, a significant step forward for developers and organizations using AI-assisted coding. This new feature allows users to track pull request activity driven by Copilot's coding agent and code review capabilities on a daily basis. By offering this granular level of detail, GitHub enables teams to better understand where AI is impacting their codebase, potentially optimizing AI deployment and improving productivity. This development marks a shift from broader organization-level metrics to more precise, actionable insights at the repository level.

GitHub Copilot app now in usage metrics API

GitHub has expanded its Copilot usage metrics API to include data on the GitHub Copilot app, providing enterprise and organization admins with new insights into app adoption and activity. This update allows admins to track distinct active users, session and request volumes, and token consumption, offering a clearer picture of how the app is being utilized. Previously, the Copilot app's activity was not represented in usage reports, making this a significant enhancement for those managing Copilot deployments. This change enables more comprehensive monitoring and management of Copilot's impact within organizations.

GitHub Copilot Enhances Code Review Customization

GitHub's Copilot code review has introduced significant customization and configurability improvements, allowing developers and administrators more control over their review processes. By reading custom instructions from the head branch, teams can now test and iterate on instructions without merging them first. The introduction of a copilot-code-review.yml file enables configuration of the runtime environment, including dependency installation and runner setup. Additionally, Copilot code review now operates behind a configurable firewall, enhancing security by restricting network access during reviews. These changes make Copilot code review more adaptable to specific team needs and security requirements.

GitHub Mobile Adds Copilot Fix Feature

GitHub Mobile has rolled out a feature that lets users address pull request comments using the Copilot cloud agent. This addition allows developers to quickly respond to review feedback with a single tap, making it easier to incorporate changes while on the move. By embedding this capability into both the main view and individual review comments, GitHub Mobile enhances its functionality for developers who need to manage pull requests away from their desks. Now available on the latest versions for iOS and Android, this feature aims to keep projects progressing efficiently by enabling rapid responses to pull request comments.

Claude Code v2.1.212 Update Released

The latest update to Claude Code, version 2.1.212, introduces several enhancements and fixes aimed at improving user experience and system reliability. Notably, the update allows users to fork conversations into new background sessions, enhancing multitasking capabilities. It also sets session-wide limits on WebSearch tool calls and subagent spawns to prevent runaway processes. Additionally, the update addresses various bugs, such as fixing issues with shell mode command execution and improving error messages for large request failures. These changes collectively enhance the stability and usability of the platform.

GitHub Projects Adds Advanced Search Feature

GitHub has enhanced its Projects feature by introducing advanced search capabilities, allowing users to create precise views using logical operators like AND and OR. This update simplifies project management by eliminating the need for multiple views for different queries. Additionally, a new filter for pull request review states has been added, improving the ability to track review progress. A 90-day retention policy for deployment statuses has also been implemented, ensuring that only recent data is available through APIs. These changes streamline project workflows and data management for developers.

Xcode 27 Runner Image in Public Preview

GitHub has launched a public preview of the Xcode 27 runner image, allowing developers to build and test Apple applications using the latest Xcode toolchain on GitHub-hosted macOS runners. This update introduces a new support model where each macOS image is tied to a major Xcode version, simplifying the process of targeting specific toolchains. The new image is available only on arm64 macOS runners, not on Intel, and includes updated tools and versions. This release helps developers catch compatibility issues early and maintain up-to-date CI/CD pipelines.

DoorDash Launches Command-Line Tool for Developers

DoorDash has introduced a command-line interface (CLI) tool, dd-cli, allowing developers to order food directly from the command line. This move opens up DoorDash's platform to AI agents, enabling developers to integrate food ordering into their own applications. While the concept may seem humorous, it represents a step towards agentic commerce, where AI can automate everyday tasks. By providing this tool, DoorDash is expanding its service capabilities beyond traditional apps, allowing for more creative and customized uses of its platform.

OpenAI's Creative Team Leverages Codex for Innovation

OpenAI's creative team is transforming their workflow by using Codex to develop custom creative tools and speed up the ideation process. With Codex's context-aware capabilities, they can prototype more efficiently, making it an invaluable partner in their projects. This collaboration shows how AI can be more than just an automation tool, serving as a catalyst for creativity and innovation. By integrating Codex, the team is able to push the boundaries of what's possible in creative development, demonstrating AI's potential to enhance productivity in non-traditional coding applications.

GitHub Enhances Secret Scanning and Monitoring

GitHub has rolled out significant improvements to its secret scanning and public monitoring features, enhancing security for developers. By partnering with Resend, GitHub now scans for their tokens, ensuring exposed secrets are promptly addressed. The update also introduces new secret types from APIclub and Resend, and blocks VolcEngine secrets by default. Additionally, the secret_scanning_alert webhook now includes a secret_category field, allowing users to distinguish between default and generic detections. These enhancements provide developers with more robust tools to prevent data leaks and manage security alerts effectively.

Claude Code v2.1.208 Update Released

The latest update to Claude Code, version 2.1.208, introduces several enhancements and bug fixes aimed at improving user experience and system stability. Notably, a new screen reader mode has been added to assist visually impaired users, and vim mode now supports custom insert-mode remaps. The update also addresses numerous bugs, such as memory leaks and session crashes, ensuring smoother operation. These changes make Claude Code more accessible and reliable, particularly for developers relying on its agent and background service functionalities.

Claude Code v2.1.210 Release

The latest update to Claude Code, version 2.1.210, introduces several fixes and improvements aimed at enhancing user experience and system stability. Notably, a live elapsed-time counter has been added to prevent long-running tool calls from appearing stuck, and various bugs related to session management and command execution have been addressed. These changes make the platform more reliable, especially for developers relying on its tools for complex tasks. While no groundbreaking features are introduced, the update solidifies Claude Code's position as a dependable tool for developers.

GitHub Copilot June Update for Visual Studio

GitHub's latest update for Copilot in Visual Studio 2026 introduces several enhancements aimed at improving user experience and trust. The update includes a new usage tracking system that provides real-time alerts for usage limits, ensuring developers are aware of their billing status. A trust validation feature for MCP servers enhances security by requiring user approval for changes. Notably, the modernization agent for C++ is now generally available, offering automated and guided upgrade paths. These updates make Copilot more integrated and user-friendly, especially for C++ developers looking to modernize their codebases.

GitHub Copilot for JetBrains Enhances Customization

GitHub Copilot for JetBrains IDEs has expanded its customization capabilities, allowing developers to tailor the tool more closely to their workflows. The update introduces 'bring your own key' support, enabling the use of custom OpenAI-compatible endpoints with API keys. This flexibility is complemented by a more comprehensive plugin management experience, making it easier to integrate team-specific tools. Additionally, new features like local sandboxing and a built-in debugger skill for CLI sessions are now in public preview, enhancing the development environment's adaptability and debugging capabilities.

SpaceXAI's Grok Tool Uploaded User Code to Cloud

SpaceXAI's Grok Build AI tool was discovered to be uploading entire user codebases to Google Cloud, including files that were supposed to be excluded and sensitive information. This practice went beyond typical data retention norms, raising significant privacy concerns. After the issue was reported by Cereblab, SpaceXAI disabled the feature, and Elon Musk assured users that all previously uploaded data would be deleted. This situation underscores the critical need for robust data privacy measures in AI tools, especially those handling proprietary and sensitive data. The incident serves as a reminder of the potential risks associated with excessive data retention in AI development environments. SpaceXAI's response and Musk's commitment to data deletion reflect the importance of transparency and user control over data.

GitHub Adds AI Security Detections to Pull Requests

GitHub's latest feature brings AI-powered security detections directly into pull requests, enhancing its code scanning capabilities. This development broadens vulnerability coverage to include languages and frameworks not previously supported by CodeQL, allowing developers to catch potential issues earlier in the development cycle. By embedding these detections into the pull request process, developers can address security concerns before code is merged, making the review process more efficient. Currently in public preview, this feature requires a GitHub Copilot license and is available to users with GitHub Code Security, marking a significant advancement in proactive code security management.

Dependabot Adds Default Package Cooldown

GitHub's Dependabot now introduces a default three-day cooldown period for version updates, aiming to mitigate the risk of supply chain attacks. This delay allows the community to identify and address any issues with new releases before they are automatically integrated into projects. While security updates remain immediate to ensure critical fixes are not delayed, developers can customize or opt out of this cooldown through their configuration files. This change enhances security without sacrificing control, providing a buffer against potentially compromised updates.

GitHub Copilot App Adds Security Review Feature

GitHub has introduced a new security review feature in its Copilot app, allowing developers to run AI-driven vulnerability scans directly within their coding environment. This feature, available in public preview, uses the /security-review command to identify high-confidence security issues and provide actionable suggestions. By integrating this tool into the Copilot app, GitHub aims to help developers catch and address vulnerabilities early in the development process, enhancing code security without disrupting workflow. This addition complements existing GitHub security tools, offering a more seamless and proactive approach to code safety.

GitHub Adds REST API for Secret Scanning Patterns

GitHub has introduced a new REST API feature that allows security teams to manage secret scanning custom patterns programmatically. This update enables users to create, edit, and delete custom patterns at various levels, including repository, organization, and enterprise. While the API supports basic CRUD operations, some actions like dry runs and final publishing still require the UI. This development streamlines the management of secret scanning, making it more accessible and efficient for developers and security teams.

Claude Code v2.1.206 Update Released

The latest update to Claude Code, version 2.1.206, introduces several enhancements and fixes that streamline developer workflows. Notably, directory path suggestions have been added to the /cd command, and a new /doctor check helps manage CLAUDE.md files more efficiently. The update also improves the handling of git operations and background agent upgrades, reducing downtime. These changes aim to enhance the user experience by addressing common issues and optimizing performance, making Claude Code a more robust tool for developers.

Claude Code v2.1.207 Update Released

Claude Code's latest update, v2.1.207, brings a host of bug fixes and improvements, enhancing user experience and system reliability. Notably, Auto mode is now accessible without opt-in on major platforms like Bedrock and Vertex AI, simplifying user access. The update also addresses several critical issues, such as terminal freezing during long responses and spurious prompt-injection warnings. These changes make Claude Code more robust and user-friendly, particularly for developers relying on its seamless integration and performance.

CodeQL 2.26.0 Enhances Security with AI Detection

CodeQL 2.26.0 marks a significant step forward for GitHub's static analysis engine, particularly in addressing security vulnerabilities. This release expands its capabilities to include Kotlin 2.4.0, while also adding a crucial query for identifying AI prompt injection risks in JavaScript and TypeScript. By refining existing queries and introducing new ones across languages like C#, Go, and Python, the update reduces false positives and enhances detection accuracy. These improvements make CodeQL a more powerful tool for developers focused on securing their code, especially in AI-driven contexts. The update is automatically available to GitHub code scanning users, ensuring immediate benefits for those on the platform.

GitHub REST API Enhances Multi-User Budget Tracking

GitHub has streamlined budget management for enterprises by introducing a REST API endpoint that allows for efficient tracking of individual user consumption against multi-user budgets. Previously, checking each user's budget usage required separate API calls, making the process cumbersome for large organizations. Now, enterprise owners and billing managers can quickly identify users nearing their budget limits, thanks to new filtering and sorting capabilities. This update simplifies financial oversight and reduces the need for custom scripts, making budget management more accessible and efficient.

Profiling PyTorch Attention: Insights and Optimizations

Hugging Face's latest blog post delves into the intricacies of profiling attention mechanisms in PyTorch, revealing the impact of different implementations on performance. By comparing naive and in-place operations, the article demonstrates how a minor adjustment can eliminate unnecessary memory operations, enhancing efficiency in large models. The post also evaluates PyTorch's built-in Scaled Dot Product Attention, which simplifies coding but may lead to unexpected performance variations depending on the backend. This exploration highlights the critical role of understanding underlying operations for deploying models effectively.

GitHub Launches New Pull Requests Dashboard

GitHub has officially launched its new pull requests dashboard, providing a centralized hub for developers to manage and prioritize their pull requests. This feature, previously in public preview, now offers enhanced filtering and search capabilities, allowing users to create custom views and utilize advanced search queries. The dashboard aims to streamline the workflow for both individual contributors and managers by surfacing critical pull requests that require attention. This update marks a significant improvement in how developers can interact with and manage their contributions across multiple projects.

GitHub Introduces Granular Code Quality Targeting

GitHub has rolled out a new feature allowing organization owners to selectively enable or disable Code Quality on specific repositories, rather than applying it universally. This enhancement provides greater control, enabling users to target repositories based on custom properties, visibility, or fork status. The ability to enforce these settings ensures that Code Quality remains consistent across selected repositories, preventing unauthorized changes by repository administrators. This feature is currently in public preview for GitHub Enterprise Cloud and GitHub Team plans, offering a more tailored approach to code management.

GitHub Copilot Offers Repository Overviews

GitHub Copilot now provides users with a high-level overview of repositories they are exploring for the first time. This feature allows developers to quickly understand a repository's purpose, technologies, and contribution guidelines without prior contributions. If a repository lacks a README, Copilot can generate one, offering insights into the project's technologies and functions. This enhancement is available to all GitHub Copilot plans, making it easier for developers to get acquainted with new projects efficiently.

Claude Code v2.1.202 Release Enhances Workflow Management

The latest update to Claude Code, version 2.1.202, introduces several improvements aimed at enhancing workflow management and stability. Notably, a new 'Dynamic workflow size' setting allows users to better control the scale of dynamic workflows, offering flexibility without imposing strict limits. The update also enhances telemetry by adding attributes that help reconstruct workflow activities, improving debugging and analysis. Numerous bug fixes address issues ranging from session management to command execution, ensuring a smoother user experience. This release marks a step forward in making Claude Code more robust and user-friendly.

Claude Code v2.1.205 Update Released

The latest update to Claude Code, version 2.1.205, introduces several important fixes and improvements. Notably, it addresses issues with session transcript file tampering and resolves multiple bugs affecting background agents and task notifications. The update also enhances the auto mode and agent view, providing clearer task states and reducing memory usage during updates. These changes aim to streamline user experience and improve the reliability of the platform, making it more robust for developers.

Managed Copilot Settings Now Deployable via MDM

GitHub has expanded its Copilot management capabilities, allowing enterprise administrators to deploy settings directly to devices using mobile device management (MDM) tools. This update means that settings can be consistently applied across VS Code and Copilot CLI, regardless of user sign-in methods. By integrating with tools like Microsoft Intune and Jamf, organizations can enforce governance more effectively. This development simplifies the management of Copilot settings, ensuring uniformity and compliance across different environments.

GitHub Copilot Enhancements in VS Code June 2026

The latest updates to Visual Studio Code significantly enhance the GitHub Copilot experience, focusing on agent-driven development. With a smarter integrated browser, developers can now manage web workflows directly within VS Code, including agent-driven validation and remote browsing. The updates also introduce improved session management, allowing for parallel tasks and clearer cost visibility. These changes make it easier for developers to discover and customize models, while Autopilot enhancements allow agents to complete tasks more independently. Overall, these updates streamline the development process, offering developers more control and efficiency.

setup-java v5.5.0 enhances JDK security and Maven use

The setup-java v5.5.0 release introduces significant improvements for Java developers, notably adding cryptographic signature verification for JDK downloads. This ensures that only verified JDKs are installed, enhancing security for Temurin and Microsoft distributions. The update also supports the new Tencent Kona JDK distribution, allowing developers to integrate it seamlessly. Additionally, Maven users benefit from quieter build logs and improved toolchain management, making the development process smoother and more efficient. These changes collectively enhance the reliability and usability of Java development workflows.

npm v12 Enhances Security with New Defaults

npm v12 introduces significant security enhancements by making install-time security defaults mandatory. This release requires explicit permission for running dependency lifecycle scripts and resolving Git or remote URL dependencies, which were previously automatic. Additionally, npm is phasing out the use of 2FA-bypass granular access tokens for sensitive operations, pushing for more secure practices. These changes aim to bolster security and require developers to adapt their workflows to comply with the new standards, marking a shift towards more secure package management.

GitHub Mobile Adds Copilot for Merge Conflicts

GitHub Mobile now empowers developers to resolve merge conflicts using the Copilot cloud agent directly from their mobile devices. This feature allows users to initiate the Copilot workflow from the pull request merge box, making conflict management more accessible while on the move. By selecting 'Fix with Copilot', developers can automatically generate a comment to address conflicts, significantly simplifying the process. This enhancement boosts the mobile app's capabilities, enabling developers to tackle issues like failing workflows and code review comments without relying on a desktop setup.

GitHub Mobile Adds Live Notifications for Copilot CLI

GitHub Mobile has introduced live notifications for remote Copilot CLI sessions, enhancing connectivity for developers on the move. This feature allows users to receive real-time updates on their mobile devices, keeping them informed about session progress and when their input is needed. By integrating live activities on iOS and live update notifications on Android, developers can easily track and manage their coding sessions remotely. This update extends the functionality of GitHub Mobile, making it a more versatile tool for developers who need to monitor their work outside of traditional environments.

Codex and Agent Enhancements in JetBrains IDEs

JetBrains IDEs have introduced Codex as a new agent provider, offering developers more flexibility in choosing the right tool for their tasks. This update also brings Hooks support and enhanced MCP server management, allowing for more customized and efficient workflows. With the inclusion of custom model support for GitHub Copilot Business and Enterprise users, administrators can now configure models directly within GitHub settings. These enhancements, alongside performance improvements, make the JetBrains environment more robust and adaptable for developers.

Claude Code v2.1.196 Update Released

The latest update to Claude Code, version 2.1.196, introduces several enhancements and fixes aimed at improving user experience and system reliability. Notably, organization default models can now be set by admins, and file attachments in chat are clickable for easier access. The update also addresses multiple bugs, such as issues with background job handling and session status reporting, ensuring smoother operation. These changes make Claude Code more robust and user-friendly, particularly for developers managing complex workflows.

Claude Code v2.1.199 Update Released

The latest update to Claude Code, version 2.1.199, brings a series of bug fixes and improvements aimed at enhancing the stability and functionality of the platform. Notably, it addresses issues with SSL certificate errors and improves the handling of streaming responses during server errors. The update also resolves problems with subagents and background-agent daemons, ensuring more reliable performance across different operating systems. These changes make the platform more robust, particularly in handling errors and managing resources efficiently.

Claude Code v2.1.200 Release

The latest update to Claude Code, v2.1.200, introduces several important fixes and changes that enhance stability and usability. Notably, the update addresses issues with background sessions and agent daemons, ensuring smoother operation and preventing crashes. The default permission mode has been changed to 'Manual' across various interfaces, providing users with more control. Additionally, improvements have been made for screen-reader output and installation processes, making the tool more accessible and user-friendly. These changes collectively aim to provide a more reliable and efficient experience for developers using Claude Code.

GitHub Copilot Enhances Usage Metrics Accuracy

GitHub has refined its Copilot usage metrics API, enhancing the accuracy and completeness of its reports. The updates include the Copilot CLI now reporting suggested lines of code, which previously went untracked, and more precise identification of users' IDEs through server-side telemetry. Additionally, AI credit consumption is now more accurately attributed, resolving previous discrepancies where some users' usage was not reflected. These improvements mean enterprise administrators and organization owners can now rely on more comprehensive and trustworthy data to understand Copilot's impact and usage patterns.

GitHub Copilot CLI Now Uses GITHUB_TOKEN

GitHub has streamlined the use of Copilot CLI in GitHub Actions by allowing it to authenticate using the built-in GITHUB_TOKEN instead of requiring a personal access token. This change reduces the security risks associated with managing long-lived tokens and simplifies the setup for developers. Organizations can now directly bill AI credits consumed by Copilot CLI to their accounts, provided they enable the necessary policies. This update makes it easier for developers to integrate Copilot CLI into their workflows without additional secret management, enhancing both security and convenience.

GitHub Copilot Agent Session Streaming in Public Preview

GitHub has launched a public preview for Copilot agent session streaming, allowing Enterprise Cloud customers to access detailed session data across all Copilot clients. This feature provides visibility into AI usage, enabling enterprises to manage prompts, responses, and tool calls effectively. Users can access this data via a streaming endpoint or REST API, integrating with tools like Microsoft Purview for seamless auditability. This development enhances enterprise control over AI interactions, offering a new level of transparency and management capability.

GitHub Issue Fields Now Generally Available

GitHub's issue fields feature is now accessible to all organizations, enhancing the way issues are managed with structured metadata. This update allows users to see priority and effort directly on the issues list, making project management more transparent. Integration with GitHub's MCP server enables AI tools like Copilot to interact with these fields, potentially automating issue handling. The feature now supports international characters and offers visibility controls for public projects, expanding its usability. Organizations can customize these fields, ensuring consistent issue tracking across repositories. This release marks a significant step in improving project management capabilities on GitHub.

Claude v2.1.198 Release Enhances Agent Functionality

The latest Claude update, version 2.1.198, brings notable advancements in agent capabilities and user experience. Background agents now have the capability to autonomously commit, push, and open draft PRs, which enhances the coding workflow by reducing manual intervention. The update also introduces a new /dataviz skill, providing guidance for chart and dashboard design, thus broadening Claude's application in data visualization. Additionally, improved error handling with automatic retries for transient network errors minimizes disruptions. These enhancements make Claude a more robust tool for developers, offering increased efficiency and reliability.

GitHub Launches Public Monitoring for Secret Leaks

GitHub has introduced a new public monitoring feature for enterprises, aimed at detecting secret leaks across the entire public surface of GitHub. This tool allows organizations to identify and address vulnerabilities in real-time, even if the leaks occur outside their tracked repositories. By leveraging GitHub's identity layer and verified domains, enterprises can quickly attribute exposed secrets back to their source. This proactive approach helps prevent potential abuse by bad actors, offering a significant enhancement in security for GitHub Enterprise Cloud customers.

GitHub Copilot Enables Auto Model Selection for Enterprises

GitHub has introduced a new feature for enterprise users of Copilot, allowing administrators to set auto model selection as the default for new conversations. This change is implemented through the managed-settings.json file, enabling a more streamlined setup for organizations using Copilot Business or Enterprise. While this feature automates model selection, users retain the flexibility to switch models per conversation. This update simplifies the management of AI model settings, making it easier for enterprises to maintain consistency across their teams.

Microsoft C++ Language Server Plugin for Copilot CLI

Microsoft's new C++ Language Server plugin for the Copilot CLI marks a significant improvement for developers by automating the generation of the compile_commands.json file. This file is essential for the language server to accurately interpret code, and its creation previously required manual effort. The plugin integrates directly with CMake and MSBuild, reducing the complexity of project setup and ongoing maintenance. By allowing developers to install the plugin directly through Copilot CLI, it ensures they can easily keep their projects updated and configured correctly. This development makes Copilot CLI more accessible and efficient for C++ developers, enhancing their coding experience across various platforms.

GitHub Copilot Vision Now Generally Available

GitHub has made Copilot Vision generally available, allowing users to attach images and PDFs directly to chat prompts. This feature enables Copilot to reason about visual content alongside code, enhancing its utility for developers. Previously, this capability required specific policy settings for business and enterprise users, but it is now enabled by default for all Copilot subscribers. This move simplifies access and broadens the tool's applicability, making it a more versatile assistant for coding tasks.

GitHub Copilot Adds AI Credit Session Limits

GitHub Copilot has introduced a new feature allowing users to set AI credit session limits in both its CLI and SDK. This feature is particularly beneficial for automation tasks where continuous monitoring isn't feasible, as it caps the AI credit usage for a session. Once the limit is reached, the agent concludes its tasks and notifies the user, preventing unexpected overuse. This update is available in public preview for various Copilot plans and aims to provide better control over AI resource expenditure without interrupting ongoing tasks.

GitHub Copilot Browser Tools Now Generally Available

GitHub has made its browser tools for Copilot in VS Code generally available, allowing agents to interact with live web apps directly. This feature enables agents to perform actions like navigating pages, clicking, typing, and even running scripted flows, enhancing the automation capabilities within VS Code. Privacy and security are prioritized, with tabs being private by default and sensitive permissions requiring explicit user approval. This development marks a significant step in integrating browser-based automation into the developer workflow, offering a more seamless and controlled environment for testing and debugging web applications.

Cursor launches mobile app for coding agents

Cursor is expanding its reach with the launch of Cursor Mobile, allowing users to manage coding agents directly from their phones. This move aligns with the industry's shift towards mobile AI coding tools, as seen with similar offerings from Anthropic and OpenAI. The app builds on Cursor 2.0's focus on independent coding agents, enabling developers to engage with these agents without needing a desktop setup. This development reflects a growing trend where developers are increasingly managing code-writing agents on the go, highlighting a significant change in how coding is approached.

Claude Code v2.1.195 Release

The latest update to Claude Code, version 2.1.195, brings a series of fixes and improvements aimed at enhancing user experience and functionality. Notably, it introduces a feature to disable mouse interactions in fullscreen mode while retaining scroll capabilities, and addresses issues with voice dictation on macOS and languages without spaces. The update also resolves problems with plugin management and background job handling, ensuring smoother operation across different environments. These changes make Claude Code more reliable and user-friendly, particularly for developers working with complex projects.

GitHub Desktop 3.6 Enhances Copilot Integration

GitHub Desktop 3.6 introduces significant enhancements with deeper integration of GitHub Copilot, making commit authoring and merge conflict resolution more intuitive. The update leverages the Copilot SDK, allowing users to select from various models and even connect third-party providers. This version also supports Git worktrees, enabling developers to manage multiple branches without the hassle of stashing changes or creating extra clones. These improvements streamline the Git workflow, making it more efficient and aligned with repository standards.

Claude Code v2.1.187 Release

The latest update to Claude Code, version 2.1.187, introduces several enhancements and fixes that improve usability and functionality. Notably, it adds a sandbox.credentials setting to prevent sandboxed commands from accessing sensitive files, and introduces model restrictions based on organizational settings. The update also addresses various bugs, such as fixing remote MCP tool calls that previously hung indefinitely and improving the handling of structured output. These changes make the platform more secure and efficient, enhancing the overall user experience.

Claude Code v2.1.193 Update Released

Claude Code's latest update, v2.1.193, introduces several enhancements aimed at improving user experience and system efficiency. Notably, the update includes a new auto-mode classifier for Bash/PowerShell commands, providing more comprehensive command routing. Additionally, OpenTelemetry logging now captures assistant response text, offering deeper insights into model interactions. The update also addresses several bugs, such as issues with background tasks and agent prompts, ensuring smoother operation. These changes make Claude Code more robust and user-friendly, particularly for developers relying on its automation capabilities.

Run vLLM Server on HF Jobs with One Command

Hugging Face has streamlined the process of deploying a vLLM server with a single command, making it easier for developers to test and evaluate models. By using the official vllm/vllm-openai image and specifying a GPU flavor, users can quickly set up a server for model inference. This approach allows for flexible scaling, accommodating larger models by adjusting GPU resources and parallel processing settings. The integration with Hugging Face's infrastructure simplifies access and management, providing a practical solution for developers needing quick, temporary model deployments.

GitHub Copilot Enhances Code Review Efficiency

GitHub's Copilot code review has become more efficient with the integration of built-in file exploration tools from the Copilot CLI and SDK. This update reduces review costs by about 20% without altering existing workflows, thanks to the use of tools like grep and rg. Additionally, users in the Medium analysis depth public preview can now benefit from improved configurability and visibility of review depth. Organizations can set default review levels, enhancing control over the review process. These changes make Copilot's code review more focused and cost-effective.

Enterprise Control for GitHub Copilot Plugin Installations

GitHub has introduced a new feature for enterprises using Copilot CLI and VS Code, allowing them to enforce stricter control over plugin installations. By adding 'strictKnownMarketplaces' to the enterprise-managed settings, organizations can ensure that only plugins from approved marketplaces are installed. This move enhances security by preventing the installation of potentially untrusted plugins, aligning with enterprise governance strategies. This update is now in public preview, offering businesses a more secure and controlled development environment.

GitHub Enhances Control Over Hosted Runners

GitHub is giving organizations more control over their GitHub-hosted runners in Actions, particularly for macOS environments. Admins can now disable standard labels for hosted runners and add macOS runners to specific runner groups, allowing for more precise management of resources. This update enables organizations to restrict access to macOS runners, enforce concurrency limits, and route jobs through policy-driven runner groups. While this feature enhances control and security, it is currently available only on Team and Enterprise plans, and network configurations for macOS runners are not yet supported.

GitHub Actions Steps Can Now Run in Parallel

GitHub Actions has introduced a significant update allowing workflow steps to run concurrently, enhancing efficiency for developers. Previously, steps executed sequentially, but now they can run in parallel with separate logs, thanks to new keywords like 'background', 'wait', and 'parallel'. This change enables more complex workflows, such as running multiple builds simultaneously or managing background services more effectively. Developers can now streamline their CI/CD processes, reducing wait times and improving overall productivity.

GitHub Copilot for Jira Now Generally Available

GitHub Copilot for Jira has moved from public preview to general availability, offering enhanced integration between GitHub and Jira. This release introduces real-time monitoring of coding agents directly within Jira issues, allowing users to track progress without switching platforms. Additionally, users can now provide follow-up instructions in Jira, ensuring changes remain consolidated in a single pull request. The setup process has been streamlined, reducing the steps needed to connect GitHub organizations and repositories to Jira. This integration aims to improve workflow efficiency for developers using both platforms.

Claude Code v2.1.186 Update Released

The latest update to Claude Code, version 2.1.186, introduces several enhancements and fixes aimed at improving user experience and functionality. Notably, it adds new CLI commands for authenticating MCP servers without a browser, and enhances the agent detail view with status filtering. The update also addresses multiple bugs, such as streaming request failures and session recap duplications, ensuring smoother operation. These changes make Claude Code more robust and user-friendly, particularly for developers working in complex environments.

GitHub Launches Code Quality Findings REST API

GitHub has introduced new REST API endpoints for accessing Code Quality findings, now available in public preview. This development allows developers to retrieve detailed information on CodeQL findings directly through API calls, enhancing integration capabilities with existing tools and workflows. By offering these endpoints, GitHub is bridging the gap between its UI and API functionalities, making it easier for developers to automate and streamline code quality checks. This move signifies a step towards more accessible and flexible code quality management for developers using GitHub.

Dependabot Gains Automatic Access to GitHub Registries

GitHub has streamlined Dependabot's access to private GitHub Packages registries by eliminating the need for personal access tokens. Now, if a package grants repository access through 'Manage Actions access', Dependabot can automatically read from these registries using its GITHUB_TOKEN. This change simplifies the process for developers, as they no longer need to modify dependabot.yml or maintain PAT-based registry entries. This enhancement is available across all GitHub Packages ecosystems supported by Dependabot, making dependency management more efficient and less error-prone.

GitHub Copilot CLI Terminal Interface Now Available

GitHub has launched the redesigned terminal interface for Copilot CLI, offering a more intuitive and accessible experience for developers. The new interface includes a tabbed layout, allowing users to navigate between sessions, gists, issues, and pull requests directly from the terminal. This update streamlines the workflow by enabling users to interact with GitHub repositories without leaving the terminal environment. Additionally, the setup process for tools and configurations is now guided and interactive, eliminating the need for manual file editing. This release enhances productivity by integrating GitHub functionalities seamlessly into the terminal.

GitHub Copilot App Adds BYOK Support

GitHub Copilot's latest update introduces 'bring your own key' (BYOK) support, allowing users to integrate their own model providers into the Copilot app. This means developers can now run agent sessions using models from providers like OpenAI, Azure OpenAI, and Anthropic, among others. The integration is seamless, with keys stored securely in the local OS keychain, ensuring privacy and security. This update empowers users to mix and match frontier and local models, offering flexibility in handling complex tasks while maintaining control over data and billing. It's a significant step for developers looking to customize their AI model usage within the Copilot ecosystem.

JetBrains IDEs Preview Claude as Agent Provider

JetBrains IDEs have expanded their capabilities by introducing Claude as an agent provider in public preview, giving developers more options within GitHub Copilot. This update enables the use of custom agents defined at the organization and enterprise levels, facilitating consistent workflows across teams. The addition of Claude provides a new choice for agent selection, although it currently operates without configurable permissions. With improvements to the model picker and clearer AI credit usage indicators, this release enhances the overall development experience, offering developers more control over their AI-driven tasks.

Claude Code v2.1.183 Release Enhances Safety

The latest update to Claude Code, v2.1.183, introduces significant safety improvements for developers using auto mode. Destructive git commands are now blocked unless explicitly requested, preventing accidental data loss. Additionally, the update provides warnings for deprecated models and enhances configuration management with new command options. These changes aim to streamline the development process while ensuring a safer and more reliable coding environment. Developers can now work with greater confidence, knowing that potentially harmful actions are more controlled.

GitHub Copilot API Adds AI Credit Tracking

GitHub has enhanced its Copilot usage metrics API by including a new field that tracks AI credits consumed per user. This addition allows enterprise administrators and organization owners to monitor AI credit usage alongside existing usage metrics, providing insights into how Copilot is being utilized across teams. By understanding consumption patterns, organizations can better plan for usage-based billing and assess the value Copilot delivers. This update does not break down credits by feature or model, but it offers a clearer picture of overall user activity.

GitHub Copilot Enhances Code Review with AGENTS.md

GitHub's Copilot code review now integrates AGENTS.md files, enabling developers to customize feedback according to their repository's unique standards. This enhancement allows Copilot to automatically apply instructions from AGENTS.md, resulting in more context-sensitive reviews. The introduction of a Request button for draft pull requests simplifies the process of engaging Copilot's input, reducing the steps needed for developers. These improvements are designed to make code reviews more effective and aligned with the specific guidelines of each project.

GitHub Launches Duplicate Issue Detection Preview

GitHub has introduced a public preview feature aimed at reducing the time maintainers spend on triaging duplicate issues. This new tool flags potential duplicate issues during the creation process, offering up to three suggestions inline to help users identify existing reports. Additionally, AI tools connected to the GitHub MCP server can now interact with issue fields, allowing for automated triaging and filtering based on various criteria. This development promises to streamline issue management for large repositories, potentially saving maintainers significant time and effort.

GitHub Enhances Pull Request Author Searches

GitHub has streamlined the process of tracking pull requests by integrating Copilot-authored contributions into author searches. This update means that when users search for pull requests by author, they will now see both their own and those initiated by Copilot on their behalf. This change simplifies the management of contributions, allowing developers to view all relevant pull requests in one place. The update is currently available on the GitHub website and mobile app, with plans to extend it to the REST and GraphQL APIs soon.

GitHub Actions Enhances Custom Image Capabilities

GitHub Actions has enhanced its custom image capabilities, allowing developers to construct images on top of existing custom images. This advancement facilitates layered image workflows, enabling teams to maintain a shared base image while adding their own dependencies. The update also introduces conditional logic for generating new image versions, providing developers with greater control over testing and deployment strategies. These improvements aim to make managing image-generation pipelines more efficient, ultimately accelerating development workflows and reducing redundancy.

GitHub Actions Enhances Security for pull_request_target

GitHub has taken a significant step to enhance security in its Actions ecosystem by updating the actions/checkout to version 7, which now blocks common 'pwn request' patterns by default. This change addresses vulnerabilities associated with the pull_request_target event, which previously allowed attacker-controlled code to execute with full privileges. By refusing to fetch fork pull request code in certain workflows, GitHub aims to prevent supply-chain incidents that have plagued the ecosystem. While this update strengthens security, it also provides an opt-out for workflows that require elevated trust, ensuring flexibility for developers who need it.

GitHub Introduces Workflow Execution Protections

GitHub has launched workflow execution protections in public preview, a significant security enhancement for GitHub Enterprise users. This feature allows administrators to define an allow list, controlling who can trigger GitHub Actions workflows and which events are permitted. By leveraging the GitHub rulesets framework, these protections help prevent unauthorized workflow executions, addressing vulnerabilities like poisoned pipeline execution and manual-trigger abuse. This development marks a shift from managing security on a per-file basis to implementing broad, enforceable policies across organizations.

Claude Code v2.1.173 Release Fixes Key Issues

The latest update to Claude Code, version 2.1.173, addresses two notable issues that were affecting users. The update normalizes Fable 5 model names by automatically stripping the [1m] suffix, which was redundant since Fable 5 already includes a 1M context by default. Additionally, it resolves a misleading startup warning on Windows about missing sandbox dependencies when the sandbox feature was enabled. These fixes enhance the user experience by eliminating unnecessary confusion and ensuring smoother operation.

Claude Code v2.1.181 Update Released

Claude Code's latest update, v2.1.181, introduces several enhancements and fixes that improve user experience and functionality. Notably, the update adds a new configuration syntax for setting options directly from the prompt, and an opt-in setting for Apple Events on macOS. The bundled Bun runtime has been upgraded to version 1.4, and improvements have been made to streaming long paragraphs and auto-retry mechanisms. These changes aim to streamline operations and enhance the reliability of the platform, making it more efficient for developers.

GitHub CLI Adds Remote Repo Content Reading

The latest update to GitHub CLI introduces 'gh repo read-file' and 'gh repo read-dir', enabling users to access and explore repository content directly from the terminal without cloning. This development is particularly useful for developers who need to quickly check files or directories across multiple repositories, enhancing their ability to review code and documentation efficiently. Available to all GitHub users, including those on GitHub Enterprise Server, this update allows for seamless integration of repository exploration into scripts and automation processes. By using GitHub CLI v2.95.0, developers can now perform these tasks more effectively, making it a valuable tool for those working with remote repositories.

GitHub Expands Secret Scanning Capabilities

GitHub has enhanced its secret scanning feature, broadening detection capabilities with new partners and patterns. The update includes automatic detection of new secret types from partners like Cloudsmith and Meraki, and expands coverage for GitLab tokens. Additionally, new detectors for Elastic, Slack, Supabase, DataDog, and VolcEngine have been added. This means repositories with secret scanning enabled will now have more comprehensive protection, with automatic blocking of commits containing these secrets. The update also introduces validity checks and richer metadata, helping users prioritize remediation efforts.

GitHub Copilot Chat Auto Mode Now Available

GitHub has rolled out an auto mode for Copilot Chat, allowing users to benefit from dynamic model selection based on request complexity and model availability. This feature aims to optimize token usage while ensuring high-quality results by routing requests to models like Claude Sonnet 4.6 and GPT-5.4. Users can still choose specific models if preferred, maintaining control over their interactions. This update enhances the flexibility and efficiency of Copilot Chat, making it a more adaptive tool for developers.

GitHub Copilot Introduces Agent Finder Feature

GitHub has launched an innovative Agent Finder for Copilot, allowing developers to streamline their workflow by automatically discovering the right AI resources for specific tasks. This feature leverages the open Agentic Resource Discovery (ARD) specification, developed with industry giants like Google and Microsoft, to rank and suggest the best tools from a chosen registry. By eliminating the need to manually configure agents and tools, developers can focus on their work while maintaining control over what gets installed. This marks a significant step in making AI-driven development more efficient and customizable.

GitHub Copilot App Now Generally Available