Wednesday, September 09, 2026

Amazon RDS for MariaDB now supports community minor versions 10.6.28, 10.11.19, 11.4.13, 11.8.9, and 12.3.3. These updates introduce post-quantum TLS key exchange for encrypting data in transit. The release also includes fixes for known CVEs and general performance improvements from the MariaDB community.

• New community minors are available for immediate upgrade in RDS MariaDB.
• Post-quantum TLS (PQ-TLS) is now supported for in-transit encryption.
• Upgrading addresses recent CVEs and applies community bug fixes.
• Review RDS MariaDB release notes for specific enhancement details.

Amazon RDS for SQL Server now supports the latest Cumulative Updates and General Distribution Releases for SQL Server versions 2016 through 2025. These patches include critical security fixes for vulnerabilities identified as CVE-2026-47295, CVE-2026-47296, CVE-2026-54118, and CVE-2026-55002. Specific RDS versions map to Microsoft KB articles for each supported release line.

• Patches cover SQL Server 2016 SP3 through 2025 CU7
• Addresses four specific CVEs listed in Microsoft advisories
• RDS versions now reflect specific KB numbers for compliance
• GDR updates provide security fixes without full CU feature set
• No manual patching required if using supported RDS engine versions

Dalibo has released PostgreSQL Anonymizer 3.2, introducing a new set of high-speed pseudonymization filters. This extension continues to support six core masking strategies, including dynamic, static, replica, backup, view, and wrapper-based masking. The update aims to enhance privacy protection for PII and sensitive commercial data with improved performance.

• New fast pseudonymization filters reduce overhead for data masking operations.
• Supports six strategies: dynamic, static, replica, backup, views, and wrappers.
• Extension masks PII and commercial data across various PostgreSQL workflows.
• Dalibo drives updates to improve privacy protection performance.

Autobase 2.11 transforms the PostgreSQL deployment interface into a comprehensive cluster lifecycle platform. The release enables direct management of scaling, upgrades, backups, and point-in-time recovery via the UI. Scaling is handled by automatically provisioning read replicas based on specified node counts using existing cloud configurations.

• Autobase Console now manages full cluster lifecycle, not just initial deployment.
• Scale read capacity by specifying node count; Autobase provisions replicas automatically.
• Manage upgrades, backups, and point-in-time recovery directly from the UI.
• Uses existing cloud configuration for server and infrastructure provisioning.

Two features have been removed from the upcoming PostgreSQL 19 release following a request by Robert Haas to the pgsql-hackers mailing list. Haas asked if six heavily patched features should ship with version 19, resulting in the reversion of two items. One of the removed features was on Haas's original list, while the other was not included in that initial review.

• PostgreSQL 19 excludes two features deemed too risky or immature for the release.
• Robert Haas initiated a review of six heavily patched features before the final ship.
• One reverted feature was on Haas's list; the second was an additional reversion.
• Drivers for removal likely involve stability concerns or incomplete patching.

Setting session_replication_role to replica disables triggers and rules but does not bypass check constraints or foreign keys. A practical example shows that while a foreign key violation is ignored, a check constraint on column values still fires and rejects invalid data within the same session. This distinction is critical for bulk load scripts that rely on this setting to bypass referential integrity.

• session_replication_role only affects triggers and rules, not data integrity constraints.
• Check constraints remain active even when the role is set to replica.
• Foreign keys are enforced via internal triggers, which are suppressed by this setting.
• Do not use this setting to bypass check constraints during data loads.

CriticGen replaces coarse, decoupled LLM evaluation with a framework that generates sample-specific criteria dynamically. It produces a score, reasoning, and executable refinement suggestions based on these custom rubrics. This process enables models to diagnose specific flaws and immediately apply improvements to their own outputs.

• Moves beyond static scoring by creating dynamic, sample-specific evaluation rubrics.
• Outputs executable refinement suggestions rather than generic critique.
• Enables closed-loop model improvement through generation-aware feedback.
• Categorizes constraints into subjective, objective, and self-derived types.

Researchers propose Neuron-Guided Fine-Tuning (NGFT) to address parameter redundancy and catastrophic forgetting in large language models. The framework uses neuron activation patterns as a universal proxy to synchronize data selection, parameter updates, and knowledge preservation. It identifies essential neurons in a single forward pass to concentrate updates and reduce computational waste.

• NGFT unifies data selection and parameter updates using a single optimization signal based on neuron activations.
• Adaptive Task-Specific Neuron Selection reduces redundancy by focusing updates only on essential neurons.
• The method mitigates catastrophic forgetting by preserving knowledge through activation-based constraints.
• Serves as a holistic alternative to isolated SFT improvements like LoRA or standard data filtering.

AWS has released GPT-6 Astra from OpenAI to general availability on Amazon Bedrock. This model features a 1 million input token context window and enhanced reasoning capabilities for complex business workflows. It integrates with Amazon Bedrock APIs and supports ChatGPT Work and Codex configurations.

• GPT-6 Astra supports up to 1 million input tokens for large context analysis.
• Available via Amazon Bedrock APIs for production-grade inference and security.
• Integrates with ChatGPT Work and Codex on Amazon Bedrock.
• Optimized for autonomous agents and professional-quality content generation.

This paper introduces a compression framework for Large Reasoning Models that avoids uniform INT4 quantization, which can damage critical reasoning circuits. By profiling per-module vulnerability via perturbation sweeps, the method selectively restores sensitive components to FP16. Experiments across five reasoning benchmarks reveal that aggressive quantization can paradoxically increase energy usage by extending reasoning chains.

• Uniform INT4 quantization risks damaging critical reasoning circuits in LRMs.
• The framework profiles vulnerability across 196-224 layer/projection pairs.
• Sensitive circuits are selectively restored to FP16 to preserve accuracy.
• INT4 quantization may increase energy by forcing longer reasoning chains.
• Energy efficiency requires balancing compression with reasoning integrity.

Researchers introduce Intra-Prompt Parallel Decoding (IPPD) to answer multiple questions sharing a context within a single prompt. This method bypasses the memory bottleneck of separate prompts by sharing attention computation and memory. The approach directly targets GPU underutilization in common-context question answering tasks.

• IPPP packs multiple questions into one prompt to share attention overhead.
• Reduces memory bottlenecks inherent in independent prompt batching.
• Improves GPU utilization for common-context QA workloads.
• Offers a new inference strategy beyond standard KV-cache techniques.

Research indicates that large language models can generate new social biases not present in their training data through the process of adaptive exploration. This suggests that the emergent behaviors during inference or fine-tuning may diverge from expected safety boundaries. The findings highlight a potential risk where models autonomously construct prejudiced patterns while optimizing for performance or novelty.

• Bias emergence is not limited to training data leakage; it can arise dynamically.
• Adaptive exploration mechanisms may inadvertently foster novel social prejudices.
• Standard safety filters might miss biases that are generated post-training.
• Monitoring inference-time behavior is critical for detecting emergent risks.
• Current alignment techniques may need updates to address autonomous bias formation.

Recent benchmarks of the Qwen3.8 27B model reveal a sharp performance cliff when aggressively quantizing to 1-bit. While 4-bit quantization maintains acceptable accuracy and efficiency, 1-bit representations suffer from significant degradation. The results suggest that 4-bit remains the practical lower bound for this architecture in production workloads.

• 4-bit quantization preserves model quality for Qwen3.8 27B, making it a safe deployment choice.
• 1-bit quantization causes severe accuracy collapse and should be avoided for this model.
• Benchmarks highlight the importance of testing extreme quantization levels before fleet rollout.
• Consider 4-bit as the minimum viable compression ratio for this specific 27B parameter model.

CONDUIT addresses KV cache reuse failures in vision-language models when visual prefixes change, using a training-free residual-stream restoration approach. It improves upon raw-attention selection by avoiding wasted recomputation on irrelevant or low-value tokens through norm-weighted ranking. The framework unifies single- and multi-image reuse scenarios to maintain quality with a minimal visual-token budget.

• Eliminates need for retraining by using a training-free refresh policy.
• Unifies single- and multi-image KV cache reuse strategies.
• Prevents wasted compute on high-attention but low-value tokens.
• Maintains output quality under strict visual-token budgets.
• Restores residual streams to handle changed visual prefixes.

Researchers frame structured pruning of vision and language transformers as a multi-armed bandit problem to identify functional units with minimal performance impact. The method masks attention heads and MLP channel groups on calibration batches, calculating damage as the difference between masked and base loss to reduce variance. A smooth reward function guides a UCB or Thompson Sampling policy to sequentially select and zero out units in the dense checkpoint.

• Frames pruning as a damage-aware bandit problem for structured unit selection.
• Uses paired masked loss to neutralize batch-to-batch variance during evaluation.
• Applies UCB or fractional-Beta Thompson Sampling for sequential unit masking.
• Zeros out selected attention heads and MLP channels in the original dense model.

This study evaluates whether rewriting user queries into multiple variants improves Retrieval-Augmented Generation when the underlying search infrastructure is already robust. Using a fixed pipeline with BGE dense retrieval, cross-encoder reranking, and MMR diversification, the authors compared four rewriting strategies against HyDE and Query2Doc baselines across HotpotQA, AmbigNQ, and EnterpriseRAG-Bench. The results show that while individual rewriting methods are merely competitive with strong baselines, combining them delivers significant performance gains due to complementary failure modes.

• Single query-rewriting strategies offer limited gains over strong search baselines.
• Combining multiple rewriting methods yields outsized improvements in retrieval quality.
• Different strategies fail on different queries, making them complementary rather than redundant.
• Validation used paired-bootstrap significance tests across three datasets and seeds.

The RAPID method addresses the quadratic complexity of computing all example pairs in relational distillation by introducing a reliability-gated target and an adaptive pair proposal mechanism. It leverages calibrated teacher entropy and detached student-teacher residuals to determine which relations are evaluated, ensuring that the limited relation budget is used efficiently. The approach employs exact inverse proposal correction to maintain conditionally unbiased loss and gradient estimators.

• Reduces computational overhead by avoiding full all-pairs computation in mini-batches.
• Uses teacher entropy and residuals to gate which relational targets are emphasized.
• Ensures unbiased gradients through exact inverse proposal correction.
• Improves relation budget efficiency compared to uniform subsampling strategies.

CUSP addresses the reliability gap in aggregating heterogeneous vision-language models by mapping individual responses to a shared semantic space. It computes system-level collective uncertainty via the dispersion of a pooled semantic opinion and measures model conflict using Jensen-Shannon divergence. This training-free framework provides precise uncertainty signals without requiring additional model fine-tuning.

• Maps diverse VLM outputs to a unified semantic space for consistent comparison
• Quantifies system reliability via collective entropy and model-level conflict
• Uses Jensen-Shannon divergence to detect disagreement among agent opinions
• Requires no training or fine-tuning, enabling immediate deployment integration

Researchers introduce UniRRM, a unified reasoning reward model designed to address reliability challenges in open-ended reinforcement learning tasks. The model leverages MixReward, a large-scale multilingual dataset covering six domains and 103 languages, to support both pairwise and listwise evaluation paradigms. This approach aims to replace costly proprietary LLM-as-a-Judge systems and opaque scalar models with an interpretable, multilingual alternative.

• Replaces opaque scalar rewards with interpretable, generative reasoning models.
• Supports 103 languages across six domains via the new MixReward dataset.
• Handles both pairwise and listwise evaluation paradigms in a single framework.
• Reduces dependency on expensive proprietary LLM-as-a-Judge systems.

Amazon SageMaker AI now supports EC2 G6e instances for offline batch inference jobs. These instances feature up to eight NVIDIA L40S GPUs with 48 GB of memory each and third-generation AMD EPYC processors. This update targets GPU-intensive workloads such as large language models and generative AI for images, video, and audio. Users can enable this capability by selecting ml.g6e instance types via the AWS SDK or CLI.

• Use G6e instances for high-throughput, offline inference on large S3 datasets.
• L40S GPUs with 48 GB VRAM improve performance for LLMs and diffusion models.
• Select ml.g6e instance types in CreateTransformJob to enable this support.
• Optimized for batch workloads that do not require persistent endpoints.

Current benchmarks rely on conversational recall, failing to measure if memory actually improves task execution for tool-using agents. The new MERIT benchmark addresses this by evaluating episodic tool-use tasks with explicit cost accounting and automated leak checks. It tracks token and dollar usage to determine the marginal utility of remembering facts across different difficulty levels.

• Replaces dialogue-centric benchmarks with tool-use task evaluation for agents
• Measures marginal utility of memory against explicit token and dollar costs
• Includes automated leak checks to verify true reliance on prior facts
• Tests updated-fact recall and controlled memory corruption scenarios

Amazon Bedrock AgentCore Memory now supports the IngestData API, allowing developers to push content directly into long-term memory without first creating a short-term memory event. This change decouples long-term memory extraction from the short-term memory pipeline, enabling independent adoption of persistent memory strategies. The API accepts both conversational payloads with user/assistant roles and raw JSON inputs.

• IngestData API bypasses short-term storage, reducing latency and storage overhead for persistent contexts.
• Supports conversational messages and JSON, offering flexibility in data ingestion formats.
• Developers can now implement long-term memory independently of short-term event workflows.
• Extracted records are immediately available via standard retrieval operations used by other memory types.

AutoFyn introduces a non-parametric training approach for long-horizon agents that updates persistent state rather than model weights. By leveraging a frozen base model, the system iteratively improves performance through verified reward signals distilled into memory files and repository state. An orchestrator manages specialized agents to explore solutions, while a verifier ensures task-grounded accuracy before updating the policy state for subsequent rounds.

• Avoids costly weight updates by updating persistent state like memory files instead.
• Uses a frozen base model to reduce computational overhead per iteration.
• Orchestrator explores multiple approaches while a verifier ensures accuracy.
• Rewards are distilled into durable state to guide future agent behavior.

SCAFFOLD introduces a framework for visual web agents that moves beyond flat skill caches by inducing parametric, executable skills from successful trajectories. It maintains a recursively composed hierarchy where higher-level skills invoke lower-level ones, allowing for principled compression of redundancy. This approach addresses the limitation of previous agents that discard procedural knowledge after isolated task execution.

• Moves beyond flat prompt-side caches to a parametric, executable skill library.
• Enables recursive composition where high-level skills invoke lower-level ones.
• Compresses redundancy in procedural knowledge across long-horizon web tasks.
• Agents retain and reuse knowledge instead of discarding it per task.

EdgeMem addresses the cost and data loss of compressing agent histories by preserving original interaction turns. It organizes these turns into a multi-anchor hypergraph using lightweight local processing based on content, temporal, and episodic cues. This structure allows retrieval engines to return direct source evidence to the LLM for final answer generation, rather than relying on pre-computed summaries.

• Eliminates compression costs by storing raw interaction turns instead of summaries.
• Uses a multi-anchor hypergraph to organize data via content, temporal, and episodic cues.
• Retrieval returns source evidence directly, reserving LLM usage for final answer synthesis.
• Reduces risk of discarding critical details before the specific query context is known.

Amazon API Gateway REST APIs can now present ACM-issued or imported certificates to backend services during TLS handshakes, enabling mutual TLS. This replaces the previous limitation of using only self-signed certificates, allowing backends to validate connections against trusted certificate authorities. Automatic propagation of certificate updates in ACM ensures changes are applied without requiring API redeployment or causing downtime.

• Use ACM to manage CA-signed certificates for backend mTLS validation
• Eliminate reliance on self-signed certs for stricter security postures
• No redeployment needed when certificates are renewed or replaced in ACM

Amazon ECS now allows configuring a healthy percent threshold to mark a rolling deployment as successful before all tasks are healthy. This feature enables operators to unblock CI/CD pipelines and subsequent deployments earlier, based on their specific confidence levels. The system continues launching the remaining tasks in the background after the deployment is marked successful.

• Define a healthy percent (e.g., 90%) to trigger deployment success early.
• Accelerate CI/CD pipelines by not waiting for 100% task health.
• Background tasks continue launching after the deployment is marked successful.
• Balances speed against risk based on workload operational needs.

AWS Transfer Family SFTP Connectors now handle credential rotation without interrupting active file transfers. By pulling from an ordered list of AWS Secrets Manager versions, the connector automatically attempts authentication with the latest credentials while falling back to previous ones if needed. This eliminates manual updates to connector configurations during rotation windows and prevents transfer failures.

• Configure ordered Secrets Manager version stages in connector settings
• Active transfers continue uninterrupted during credential rotation
• Automatic fallback to previous versions ensures authentication success
• Removes manual intervention required for each credential rotation cycle

Amazon SageMaker Feature Store now supports updating specific feature values within a record without rewriting the entire entity. This feature-level write capability replaces the traditional read-modify-write pattern, reducing both latency and storage costs. Multiple pipelines can now concurrently update distinct features in the same record, enabling efficient hybrid streaming and batch workflows.

• Eliminates read-modify-write cycles by updating only changed features
• Lowers write latency and storage costs compared to full record rewrites
• Enables concurrent multi-pipeline updates on the same feature group
• Simplifies integration for streaming jobs and nightly batch pipelines

Amazon GuardDuty introduces Custom Detection Rules, a library of 35 prebuilt rules targeting CloudTrail management events. These opt-in detections cover 26 unique finding types mapped to 10 MITRE ATT&CK tactics, allowing engineers to flag context-specific activities like external AMI sharing or MFA bypass without managing log ingestion. This feature enables precise tuning of threat detection to match organizational baselines rather than relying solely on default alerts.

• Enables 35 prebuilt rules for CloudTrail management events to extend threat coverage.
• Covers 26 finding types mapped to 10 MITRE ATT&CK tactics for better context.
• Allows opt-in activation for specific TTPs like AMI sharing or MFA absence.
• Eliminates need for manual log ingestion, normalization, or storage for these rules.

AWS has enabled custom Python plugins for managed InfluxDB 3 Core and Enterprise instances in Amazon Timestream. Users can host code in their own repositories and trigger execution for data transformations, alerts, and aggregations directly within the database. The managed environment provides standard library access and vetted packages, eliminating the need for external infrastructure to handle workload-specific logic.

• Run custom Python plugins in managed InfluxDB 3 Core and Enterprise editions.
• Host plugin code in public or private repositories you control.
• Triggers allow data transformations, alerting, and service integrations.
• Executes close to data, removing need for separate external processing.
• Environment includes standard library and Amazon-vetted Python packages.

AWS has extended S3 Object Lock to support event holds, enabling WORM protection to activate based on future triggers like contract closings. Unlike legal holds that stop immediately upon removal, event holds enforce a fixed retention duration after the trigger event occurs. This feature can be applied to individual objects or set as a bucket default to meet specific compliance windows.

• Event holds start WORM protection only after a specified trigger event occurs
• Retention duration is enforced after the event, avoiding over-retention required by policy
• Applies to individual objects or configured as a bucket-wide default setting
• Distinguishes from legal holds by maintaining protection for the full post-event duration

AWS allows AMI owners to define whitelists or blacklists of compatible instance types. Launch attempts on non-permitted instance types are automatically blocked, preventing failures due to incompatible pairings. Existing workflows remain unaffected unless these restrictions are explicitly applied.

• AMI owners can now enforce instance type compatibility via whitelists or blacklists.
• Incompatible launch attempts are blocked automatically, reducing operational failures.
• Default behavior remains unchanged; restrictions must be explicitly configured.
• Feature is available globally in all AWS Regions at no additional cost.