Thursday, September 17, 2026

Percona has extended its Kubernetes operator capabilities by introducing cross-site replication support for Percona Server for MySQL (PS MySQL) in version 1.2.0. This new feature enables the configuration of a Disaster Recovery (DR) cluster that replicates from an existing Data Center (DC) cluster using Group Replication or InnoDB Cluster topologies. The update mirrors similar functionality previously released for the Percona XtraDB Cluster (PXC) operator, providing a consistent approach to multi-site deployments.

• PS MySQL operator v1.2.0 now supports cross-site replication for Group Replication topologies.
• Enables straightforward DR cluster setup replicating from an active DC cluster.
• Aligns MySQL operator features with existing PXC operator cross-site capabilities.
• Simplifies multi-site disaster recovery strategies for Kubernetes-based MySQL deployments.

PostgreSQL 19 REL_19_STABLE received 71 commits between September 8 and 16, 2026. The release window saw six reverts totaling 74 commits, with the latest revert addressing online data checksum transitions by Daniel Gustafsson. Meanwhile, PostgreSQL 20 master branch accumulated 46 commits during the same period.

• PostgreSQL 19 had 71 net commits in the first nine days of the Sept 8-16 window.
• Six reverts removed 74 commits, including critical work on online data checksum transitions.
• Online data checksum transition feature was reverted, likely due to stability or design concerns.
• PostgreSQL 20 master is active with 46 commits, indicating parallel development momentum.
• Two features remain tracked for shipping, suggesting ongoing refinement before final release.

pgAssistant 3.8.0 shifts from a static analysis tool to a continuous improvement platform centered on an Observe-Diagnose-Prioritize-Plan-Implement cycle. The release adds historical workload and environment measurements via pgAssistant Collector to track the full lifecycle of tuning efforts. This enables teams to verify what changes were actually implemented and measure their resulting impact on performance.

• Shifts focus from one-time tuning to a continuous feedback loop for sustained performance gains.
• Historical measurements allow tracking of 'what changed' versus 'what was planned' for accountability.
• Workload Insights now compares consecutive collections to highlight emerging or disappearing trends.
• Integrates with pgAssistant Collector to automate data collection for the improvement cycle.

Percona explains that Percona XtraDB Cluster (PXC) can accumulate thousands of gcache.page.* files when GCache purging is frozen, leading to significant disk space growth. The article details the mechanics behind this accumulation and outlines a safe recovery path using Incremental State Transfer (IST) to rejoin nodes without data loss.

• Frozen GCache purging is the primary cause of excessive gcache.page.* file accumulation in PXC nodes.
• Monitor disk usage closely when nodes are offline or slow, as GCache files will continue to grow.
• Use Incremental State Transfer (IST) for safe node rejoining to avoid full resync overhead.
• Regularly verify GCache size settings to ensure they align with expected network partition durations.

Fleet impact: For PXC clusters, monitor disk usage on data directories for rapid growth of gcache.page.* files, which indicates frozen purging. Ensure IST is viable and configured correctly to allow efficient rejoining of lagging nodes without consuming excessive network or storage resources.

Percona analyzed pgBackRest compression algorithms to identify the optimal balance between CPU overhead and backup size reduction. The findings indicate that Zstandard at low levels provides the best efficiency, with the default zst(3) setting already hitting the practical optimum. Increasing compression levels beyond this point yields diminishing returns on file size while consuming disproportionate CPU resources.

• Zstandard offers the best trade-off between CPU usage and backup size reduction.
• The default zst(3) setting is already near the optimal efficiency point.
• Higher compression levels consume significant CPU for negligible file size gains.
• Review current pgBackRest configs to ensure zst is enabled and levels are not over-tuned.

Amazon SageMaker AI now enables serverless fine-tuning for the NVIDIA Nemotron 3.5 Lightning model using SFT, DPO, and RFT. This hybrid Mixture-of-Experts model features 3B active parameters within a 30B total parameter count, allowing for efficient domain adaptation. Engineers can tailor the model with proprietary data to reduce latency and costs while maintaining high accuracy on specific tasks.

• Serverless SFT, DPO, and RFT are now supported for Nemotron 3.5 Lightning.
• Model uses hybrid MoE architecture with 3B active out of 30B total parameters.
• Enables cost and latency reduction by tailoring models to specific domains.
• Labeled data improves task accuracy; preference data optimizes output alignment.

A new paper demonstrates a method to compress large language models beyond the traditional 1.58-bit limit associated with ternary quantization. This advancement allows for more extreme model compression while maintaining performance metrics that were previously unattainable at such low bit-widths. The work targets the physical limits of ternary weight representations to enable denser model storage and inference.

• Ternary LLMs can now exceed the historical 1.58-bit compression ceiling.
• Extreme quantization enables significantly denser model storage and reduced memory footprint.
• Performance degradation at ultra-low bit-widths is mitigated by the new method.
• Pushes the boundary of hardware-efficient inference for resource-constrained environments.

This paper addresses the fragmentation in LLM optimization reporting by constructing a Pareto atlas for cost, quality, and latency. The authors benchmarked 54 configurations of Qwen2.5-7B-Instruct on vLLM 0.12 across L4, A100, and H100 GPUs to create anchor data. They then calibrated a simulator that reproduces these measurements with under 1.5% drift. Quality evaluations covered FP16, AWQ 4bit, and FP8 variants on GSM8K, while sparse attention was assessed via simulation.

• Standardizes comparison of LLM optimizations across different hardware and quantization schemes.
• Validates a simulator against real vLLM 0.12 benchmarks with <1.5% cross-campaign drift.
• Provides concrete tradeoff data for FP8 weights/cache and AWQ 4bit on GSM8K tasks.
• Enables rapid identification of optimal configurations without exhaustive real-world testing.

The CapMem benchmark addresses the token and context limits of vision-language models in wearable assistants by testing if textual captions serve as efficient episodic memory. It introduces a dataset of 75 hours of egocentric video with 1,000 multiple-choice questions to evaluate Caption-Based Episodic Memory. Results show that for videos longer than 20 minutes, generating captions at 30-60 second intervals often yields higher accuracy than processing raw video frames directly.

• Caption-based retrieval beats raw video processing on >20min egocentric clips for most tested models.
• CapMem provides 75 videos and 1,000 QA pairs to standardize episodic memory evaluation.
• Textual summaries mitigate visual-token costs and long-context failures in VLMs.
• Wearable AI architectures benefit from pre-processing video into dense caption streams.
• Performance gains vary by model, but caption windows of 30-60s show consistent promise.

This paper addresses the cost of refreshing KV caches in RAG systems when underlying documents are edited. It demonstrates that while full reprefill is safe, in-place repair can save compute by selectively recomputing only affected segments. The authors compare training-free position-selection policies, finding that maintaining contiguity in the edited span significantly outperforms importance-based selection for repairing derived state dependencies.

• In-place KV cache repair avoids full reprefill costs but risks stale downstream states.
• Contiguous selection policies outperform importance-based ones for derived edits.
• All tested policies successfully repair direct edits under the specified budget.
• Derived edits clearly separate policy effectiveness, highlighting dependency complexity.
• The approach is training-free, making it broadly applicable across model families.

A new study reveals that complexity-based LLM routing systems systematically misclassify non-standard English variants, such as African American English and L2 writing, as lower-complexity queries. This bias is primarily driven by input length metrics, as these registers often omit function words, resulting in shorter strings that routing algorithms interpret as simpler tasks. Consequently, users receive responses from smaller, less capable models compared to meaning-equivalent standard English queries.

• Routing algorithms relying on input length disproportionately penalize non-standard English registers.
• Test your query router for demographic bias by comparing standard vs. AAVE/L2 equivalents.
• Shorter input length does not always correlate with lower cognitive or task complexity.
• Consider adding semantic complexity signals beyond raw token count to mitigate this gap.

NVIDIA has released NeMo Data Designer (NDD), an open-source framework for generating multimodal synthetic data using a declarative configuration format. The tool supports diverse column types including text, code, images, and embeddings, allowing users to explicitly steer dataset diversity through statistical samplers. A core feature is its built-in preview-and-revision loop, which treats configuration as an inspectable artifact to ensure reproducibility and workflow sharing during the iterative generation process.

• Declarative config enables reproducible, shareable multimodal synthetic data pipelines.
• Built-in preview-and-revision loop supports iterative dataset refinement and quality control.
• Plugin architecture allows custom column types and functionality beyond standard offerings.
• Supports text, code, images, embeddings, and statistical samplers for controlled diversity.

Large reasoning models suffer from inference overhead due to long chain-of-thought traces. Recent pruning methods calibrate on model rollouts but treat all tokens uniformly, failing to distinguish between correct and erroneous reasoning paths. This new approach, OBC-Prune, evaluates parameter importance based on whether the computation leads to a correct outcome, ensuring pruned weights support valid reasoning rather than statistical salience alone.

• Standard pruning protects weights by statistical salience, not reasoning correctness.
• Erroneous computation patterns survive pruning, degrading final model quality.
• OBC-Prune calibrates importance based on successful reasoning outcomes.
• This method reduces inference overhead while preserving logical accuracy.

Amazon SageMaker JumpStart now hosts three new foundation models: IBM's granite-speech-4.1-2b, Kakao's kanana-2-30b-a3b-instruct, and OpenFold3. These additions target specific enterprise needs, including multilingual speech recognition, bilingual agentic AI, and biomolecular structure prediction. The models allow customers to deploy specialized AI workloads directly on AWS infrastructure.

• IBM's granite-speech-4.1-2b supports ASR and translation for six languages in a compact 2B parameter size.
• Kakao's kanana-2-30b-a3b-instruct enables bilingual agentic AI capabilities for complex reasoning tasks.
• OpenFold3 provides high-performance biomolecular structure prediction for scientific and healthcare use cases.
• All models are pre-configured on SageMaker JumpStart for immediate deployment and scalability.

EvolveTrade replaces static, hand-written tool-use policies in LLM trading agents with a dynamic, text-parameterized system prompt. A dedicated Policy Agent updates this prompt after each interval by analyzing accumulated decision traces and realized portfolio feedback. This approach allows the agent to adapt its evidence gathering, tool invocation, and risk management strategies without modifying the underlying backbone LLM.

• Replaces rigid, pre-deployment tool-use policies with adaptive, text-based system prompts.
• Leverages a separate Policy Agent to refine strategies based on historical decision traces.
• Uses realized portfolio feedback to drive continuous improvement in risk and signal verification.
• Maintains the base LLM architecture, focusing updates solely on the policy layer.
• Enables agents to adjust behavior dynamically in response to changing market regimes.

GraphEcho reveals that LLM agents often treat repeated traversal of the same graph paths as independent corroboration, leading to inflated confidence. The benchmark isolates this by varying path counts while keeping evidence content constant, showing that redundant walks skew judgment across frozen models. Provenance-aware post-training reduces these revisits and improves synthetic accuracy but narrows source diversity and hurts performance on scientific claims.

• LLMs conflate repeated graph path visits with new evidence, skewing judgment confidence.
• GraphEcho benchmark isolates structural redundancy from evidential content for testing.
• Provenance-aware post-training cuts revisits but reduces distinct source coverage.
• Accuracy gains from PAPT on synthetic data do not generalize to scientific claims.

The HarnessTax study quantifies the friction introduced by AI coding assistants, focusing on the time and cognitive load required to integrate their output into existing codebases. It highlights that while agents generate code quickly, the subsequent review, debugging, and refactoring steps often negate those gains. The research suggests that the true cost of using these tools is not just in their subscription price, but in the structural changes they impose on development velocity.

• AI agents introduce significant review and debugging overhead that reduces net productivity gains.
• The 'tax' includes cognitive load from understanding generated code rather than writing it.
• Integration friction often outweighs the speed of initial code generation.
• Teams should measure end-to-end delivery time, not just code creation speed.
• Workflow adjustments are necessary to mitigate the structural impact of agent-generated code.

Cloudflare has open-sourced a coding-agent skill that transforms AI assistants into structured security auditors. The tool orchestrates isolated agents through six phases, including reconnaissance, coverage-led hunting, and independent verification of findings. It serves as the foundational starting point for the multi-stage, fleet-wide vulnerability discovery harness previously described in Cloudflare engineering blogs.

• Uses a six-phase workflow: recon, hunting, validation, output, verification, and reporting.
• Generates machine-readable findings with independent record verification for accuracy.
• Serves as the single-repo entry point for Cloudflare's internal vulnerability harness.
• Maps architecture and trust boundaries to identify deterministic coverage gaps.

A controlled study across six Qwen3 models (0.6B-32B parameters) compares supervised fine-tuning (SFT) with LoRA, reinforcement learning via GRPO, and a combined SFT-then-GRPO approach. SFT with LoRA proves to be the strongest method for in-distribution performance, winning 15 out of 18 experimental settings. While GRPO shows slight advantages in cross-dataset transfer scenarios, its margin over SFT remains under one point, suggesting SFT is the more robust baseline for tool-calling agents.

• SFT with LoRA is the top performer for in-distribution tool-calling across 0.6B-32B models.
• GRPO offers marginal gains in cross-dataset transfer, averaging less than one point over SFT.
• Combined SFT-then-GRPO does not clearly surpass standalone SFT for in-distribution tasks.
• Practitioners should prioritize SFT with LoRA as the primary adaptation method for tool use.

This paper introduces ERPBench, a new benchmark designed to evaluate screenshot-only computer-use agents on a live, reproducible ERP system rather than general desktop tasks. It addresses the unique challenges of enterprise software, such as dense interfaces and multi-step interactions that can alter persistent business records. Unlike existing benchmarks that rely on proprietary platforms or simulated approximations, this approach scores tasks against grounded state changes.

• Targets computer-use agents operating via screenshots in complex enterprise environments
• Evaluates agents on live, reproducible ERP systems instead of simulated approximations
• Focuses on dense interfaces and multi-step interactions typical of finance and procurement
• Scores performance against grounded state changes to catch errors affecting business records
• Moves beyond general desktop/web benchmarks to address specific enterprise software challenges

This research addresses the challenge of distributed perception in multi-agent Vision-Language Model systems, where different agents inspect distinct visual regions. It introduces a framework for shared visual context that enables agents to build on each other's contributions, recover missing context, and reconcile conflicting interpretations as new evidence emerges. The work focuses on memory hierarchy and consistency mechanisms to synchronize dependent reasoning across agents.

• Solves the distributed perception problem in multi-agent VLM setups
• Enables agents to share visual context across different image regions
• Provides mechanisms to reconcile conflicting agent interpretations
• Supports recovery of missing visual context during complex tasks

A recent discussion on Hacker Highlights exposes the hidden complexity behind seemingly straightforward backup strategies. The article argues that relying on simple snapshots or copies ignores critical edge cases like transactional consistency and application-level dependencies. It serves as a reminder that robust data protection requires rigorous validation and frequent restore drills rather than just automated routines.

• Snapshots alone do not guarantee application-consistent backups.
• Regular restore testing is the only way to validate backup integrity.
• Data corruption can persist through backup cycles if unchecked.
• Complex dependencies require more than just file-level copying.

AWS Step Functions now automatically adds SDK integrations for new AWS services within weeks of their release, eliminating manual updates. The first integrations cover AWS Lambda MicroVMs and AWS Lambda Core, enabling immediate orchestration of these capabilities. This update allows users to build agentic workflows with isolated execution environments and automatic retries without writing custom coordination code.

• Step Functions auto-updates integrations for new AWS services within weeks of release.
• New integrations include Lambda MicroVMs and Lambda Core for agentic workflows.
• MicroVMs provide isolated, secure execution with built-in retry logic for failed starts.
• Orchestrate latest AWS capabilities without waiting for manual Step Functions updates.

The first stable version of PostgreSQL Migrator has been released, developed by Florent Jardin and colleagues to address PostgreSQL migration challenges. The tool includes an offline catalog feature that allows practitioners to inspect source database structures, such as table schemas and constraints, without requiring an active connection. This capability is designed to streamline the preparation phase for migrating from relational databases like Oracle to PostgreSQL.

• Stable v1.0 released Sept 4, offering a mature alternative for PG migration workflows.
• Offline catalog inspection enables schema analysis without live source database access.
• Supports detailed review of data types, constraints, views, and functions for accurate planning.
• Reduces risk during migration prep by decoupling inspection from source availability.

AWS STS now enforces a single 4,096-byte limit for session tokens, removing previous separate constraints on inline policies and tags. The service provides visibility into token size and utilization percentage via CloudTrail logs and CloudWatch metrics. A new optional API parameter allows generating tokens up to the limit for application testing purposes.

• Unified 4096-byte limit replaces separate token and parameter size caps.
• Monitor usage via CloudTrail logs and CloudWatch metrics.
• Use new API parameter to test infrastructure with larger tokens.
• Allows larger combinations of policies and session tags.

Amazon ECS now allows tasks on EC2 instances to mount Amazon S3 as a shared file system using standard file semantics. This update brings EC2 launch type parity with Fargate and Managed Instances for S3 Files access. Applications can read and write S3 data directly without code changes or intermediate staging steps.

• EC2-based ECS tasks can now mount S3 as a file system directly.
• Eliminates need to stage or duplicate data before processing.
• Provides consistent S3 Files behavior across all three ECS launch types.
• Enables standard file semantics for AI agents and data workloads on EC2.

AWS now routes root user sign-in traffic across US East (N. Virginia), US East (Ohio), and US West (Oregon) to reduce dependency on a single region. This automatic distribution improves availability during regional service disruptions without requiring changes to the sign-in process. ConsoleLogin events are recorded in the specific region that handled the request, shifting where audit logs originate.

• Root sign-in is now distributed across US East (N. Virginia), US East (Ohio), and US West (Oregon).
• No user action is required; traffic routing is handled automatically by AWS.
• CloudTrail ConsoleLogin events now appear in the region processing the sign-in request.
• Update monitoring and alerting rules to cover all three regions for complete visibility.

Amazon SageMaker AI now allows users to submit prioritized lists of acceptable instance types for training and processing jobs, replacing the previous single-instance constraint. This feature automates the selection of available compute capacity, addressing unpredictable wait times for high-demand GPUs during peak periods. Engineers can eliminate complex retry logic or concurrent job submissions by defining acceptable alternatives upfront.

• Submit prioritized lists of instance types instead of a single fixed option
• Automatically selects the first available instance from your preferred list
• Reduces job wait times during peak GPU demand periods significantly
• Eliminates the need for custom retry logic or concurrent job submissions

Percona and HexaCluster have formed a partnership designed to simplify the process of migrating away from proprietary databases like Oracle, SQL Server, DB2, and Sybase ASE. The collaboration combines Percona's open-source distributions, operators, and enterprise support with HexaCluster's assessment and migration engineering capabilities. This joint offering aims to provide a predictable timeline and increased confidence for organizations seeking to leave legacy commercial database systems.

• Partnership combines Percona's open-source support with HexaCluster's migration engineering expertise.
• Aims to replace multi-year consulting programs with a more predictable migration timeline.
• Specifically targets migration from Oracle, SQL Server, DB2, and Sybase ASE environments.
• Offers assessment and engineering services to reduce risk during the transition to open source.

Alibaba released Open Code Review, an open-source CLI tool born from their internal AI assistant. It combines deterministic pipeline checks with LLM agents to provide precise, line-level comments on Git diffs. The tool supports multiple language-specific rulesets for issues like SQL injection and thread safety, and is compatible with OpenAI and Anthropic model endpoints.

• Hybrid architecture merges static rule checks with LLM reasoning for higher precision.
• Built-in multi-language ruleset covers NPE, XSS, SQL injection, and thread safety.
• Works as a CLI tool; simply configure a compatible model endpoint to start.
• Validated at Alibaba scale, serving tens of thousands of developers for two years.
• Reads Git diffs directly, integrating into existing developer workflows.