Tuesday, August 04, 2026

The pgBackRest community has released version 2.59.0, delivering updates to the popular PostgreSQL backup and restore tool. This release introduces malware and ransomware protection capabilities alongside the ability to resume partial or failed backups. The software continues to support parallel operations, multiple compression types, and encryption for scalable database infrastructure.

• New malware and ransomware protection features enhance backup security.
• Partial and failed backup resumption reduces recovery time for interrupted jobs.
• Supports parallel backup/restore and asynchronous archiving for large workloads.
• Maintains compatibility with S3, Azure, GCS, and SFTP storage repositories.
• Validates page checksums during backup when enabled in the database.

The E-Maj 5.0.0 release introduces the ability for non-superuser roles to install and operate the extension, with feature access governed by specific privileges. This update ensures compatibility with PostgreSQL versions 14 through 19 and enhances the Emaj_web client. Key improvements also include better support for idempotent administration scripts and streamlined parameter management.

• Non-superuser roles can now install and use E-Maj, enabling finer-grained access control.
• Full compatibility with PostgreSQL 19, supporting versions 14 through 19.
• Emaj_web client updated to leverage new privilege and scripting features.
• Improved handling of idempotent admin scripts and E-Maj parameter configuration.

Amazon Aurora DSQL now supports multi-Region clusters in Europe (Stockholm), Europe (Spain), Asia Pacific (Mumbai), and Asia Pacific (Singapore). This serverless distributed SQL database offers active-active high availability and multi-Region strong consistency. Each multi-Region cluster provides a writable endpoint in both peered Regions, presenting a single logical database that remains available even if one Region becomes unavailable.

• Aurora DSQL multi-Region clusters are now available in Stockholm, Spain, Mumbai, and Singapore.
• Each multi-Region cluster provides a writable endpoint in both peered Regions.
• The database presents a single logical database that remains available even if one Region fails.
• Aurora DSQL is the fastest serverless, distributed SQL database with active-active high availability.
• Multi-Region strong consistency is maintained across the peered Regions.

Percona published an investigation into the memory usage of stored procedures within Percona Server for MySQL. The analysis originated from performance comparisons of different memory allocators during benchmarking. The authors highlight unexpected memory effects discovered during this process that warrant detailed examination.

• Memory allocation behavior for stored procedures may differ from expectations.
• Memory allocator choice can significantly impact server resource consumption.
• Benchmarking should include detailed memory profiling for stored logic.
• Review Percona's specific allocator implementations for optimization opportunities.

OpenAI's GPT-5.6 Sol, Terra, and Luna models now support 1 million token context windows on Amazon Bedrock. This update allows processing of full codebases, lengthy documents, and multi-turn agent histories in a single request without chunking. Prompt caching with explicit breakpoints applies to these long context requests, offering billing discounts for repeated context.

• Eliminate context chunking for full codebase or document analysis in one pass.
• Maintain complete conversation history in multi-step agentic workflows.
• Prompt caching discounts apply to long context requests with explicit breakpoints.
• GPT-5.6 Sol is available in US East (N. Virginia) and other regions.

The Swiftlet project demonstrates running an 80-billion parameter Qwen model on macOS with just 4.3 GB of RAM, alongside a 35B variant for iOS devices. This achievement highlights significant advances in on-device inference efficiency, allowing large language models to operate on consumer hardware without cloud dependency. The work showcases practical applications of quantization and memory optimization for edge computing scenarios.

• Large models like 80B Qwen can fit in minimal RAM via aggressive optimization
• iOS devices can now run 35B parameter models locally for offline inference
• Swiftlet provides a practical framework for on-device LLM deployment
• Edge AI capabilities are expanding beyond typical mobile constraints
• Memory-efficient inference enables privacy-preserving local model execution

Batched LLM serving complicates energy accounting because GPU telemetry is aggregate, not per-request. JouleShare addresses this by using an offline harness to establish ground truth energy costs through reproducible vLLM replays. This framework enables request-level attribution for sustainability reporting and chargeback, moving beyond model- or token-level estimates.

• Aggregate GPU power data is insufficient for precise per-request energy billing or carbon accounting.
• JouleShare uses offline vLLM replays to create ground truth for request-level energy attribution.
• Shapley fairness concepts guide the allocation, though this work provides measured data rather than just theory.
• Enables accurate chargeback and sustainability reporting for batched inference workloads.

DiffusionGemma is an experimental open-weight model that generates text using discrete diffusion rather than autoregressive decoding. It refines blocks of 256 tokens in parallel, bypassing the sequential bottleneck of standard LLMs. The model is derived from Gemma 4 via fine-tuning, utilizing only 10% of the original training token budget.

• Parallel block decoding of 256 tokens eliminates autoregressive sequential bottlenecks.
• Open-weight model built on Gemma 4 MoE with 25.2B total parameters.
• Training uses 10% of the source model's token budget via supervised fine-tuning.
• Bidirectional denoising replaces next-token prediction for faster generation.

Amazon SageMaker AI extends its serverless model customization to include full fine-tuning capabilities for over 25 open-source models, including Llama, Gemma, and Qwen families. This update allows engineers to update all model parameters rather than relying solely on parameter-efficient methods like LoRA. The feature enables deeper adaptation for domain-specific patterns, specialized reasoning, and complex output formats using proprietary datasets.

• Full fine-tuning is now available in SageMaker serverless, replacing the need for dedicated GPU instances for this workload.
• Supports 25+ open-source models including Llama, Gemma, Qwen, Nemotron, and gpt-oss families.
• Enables deep adaptation for specialized reasoning and complex output structures beyond surface-level style adjustments.
• Ideal for internalizing domain knowledge from large proprietary datasets where LoRA may be insufficient.
• Simplifies infrastructure by removing the operational overhead of managing persistent fine-tuning clusters.

Firecrawl has open-sourced a Rust library that classifies PDFs as text-based, scanned, or mixed in under 50 milliseconds. The tool extracts text with position awareness and converts documents to Markdown without relying on expensive OCR services. It includes bindings for Python, Node.js, and WebAssembly to facilitate local processing.

• Skip OCR costs for the ~54% of PDFs that are text-based by using smart content stream sampling.
• Get per-page OCR routing decisions with confidence scores to handle mixed or scanned documents selectively.
• Deploy locally via Python, Node.js, or WebAssembly bindings for low-latency processing under 200ms.
• Extract text with position awareness to preserve document structure when converting to Markdown.

Nova is an automated end-to-end JIT compiler built on MLIR designed to overcome the limitations of eager execution in high-level tensor frameworks. It captures eager executions to provide whole-graph visibility, enabling granular control over hardware mapping, operation fusion, and memory hierarchy optimization. The system tunes execution down to the register level to maximize physical hardware utilization for deep learning models at scale.

• Bridges the gap between flexible model design and low-level hardware optimization via whole-graph analysis.
• Captures eager executions to enable cross-operation fusion and register-level tuning.
• Provides granular control over memory hierarchies to maximize physical hardware utilization.
• Leverages MLIR for an automated end-to-end compilation pipeline from high-level ops to hardware.

The C-Guard framework addresses the conflict between catching real harm and avoiding over-refusal in RL alignment by using a constitution-grid instrument to generate training data. It employs C-LIM, a per-cell learnability score, to dynamically prune, densify, amend, or expand data regions based on their utility. This approach identifies and eliminates dead-weight data, such as 187 untargeted rows that provided zero gain, while significantly improving learning impact in those regions.

• C-Guard resolves the safety vs. utility conflict in RL alignment through structured data generation.
• C-LIM scores per-cell learnability to optimize data composition before training begins.
• Method eliminated 187 zero-gain rows, lifting learning impact from 0.733 to 0.80.
• Reduces over-refusal rates from 22.4% to 12.8% without worsening adversarial vulnerability.

AWS has generally released the Context Ontology Accelerator, an open-source tool designed to build machine-readable business ontologies for AI agents. The system ingests structured and unstructured data to draft an ontology, which domain experts then review and approve before it is stored in a W3C-standard knowledge graph. Agents access this trusted context via a Model Context Protocol (MCP) server to ensure decisions are consistent and auditable.

• Drafts ontologies from data using AI, requiring human expert validation for accuracy.
• Stores approved models in a W3C-standard knowledge graph owned by the organization.
• Exposes context to AI agents via a Model Context Protocol (MCP) server.
• Aims to improve trust, explainability, and auditability in agent decision-making.

A new study characterizes AI coding agent workloads using 761 million LLM calls from 3.2 million GitHub Copilot users. The data shows sessions consist of sparse user turns followed by autonomous loops of LLM inference and tool execution. This structure results in high KV cache hit rates within turns but significantly lower rates across turn boundaries.

• Agentic coding differs from chatbots with interleaved LLM inference and tool execution.
• Sessions feature sparse user turns leading to autonomous agent loops.
• KV cache hit rates average 90% within turns but drop to 55% across boundaries.
• Workload structure has distinct implications for systems design and optimization.

Researchers identify a small set of MLP neurons that linearly separate common agentic LLM tool-use errors: invalid arguments, unnecessary calls, and missing calls. They introduce PRISMS, a closed-loop framework that leverages these failure-specific neurons for both sparse detection and activation steering. Evaluated across Qwen3, Llama, and Gemma models, the method effectively targets over-calling and missing tool use patterns.

• Three key tool failures are detectable via linearly separable neuron activations.
• PRISMS unifies detection and steering using a shared sparse neuron basis.
• L1-regularized detectors fit on contribution-critical MLP activations.
• Framework validated on Qwen3, Llama, and Gemma model families.
• Sparse approach offers precise monitoring without full-model overhead.

This paper details a production deployment of a shared memory system designed to capture tacit enterprise knowledge that falls outside public training data or formal docs. The platform automatically collects task-adjacent experience with contributor approval, curating it into reusable question-answer pairs. This approach integrates knowledge capture directly into the coding workflow to prevent repeated rediscovery of internal conventions and fixes.

• Integrates knowledge capture into the coding workflow rather than relying on manual agent recording.
• Captures tacit enterprise knowledge like internal DSLs, local conventions, and recent fixes.
• Curates raw experience into reusable question-answer memories for retrieval by coding agents.
• Requires contributor approval to ensure quality and appropriate gating of shared memories.

The paper introduces AgentMemBench, a unified benchmark designed to evaluate long-term memory management in conversational AI agents. It compares five distinct strategies—in-context windowing, external key-value stores, graph-based episodic memory, compression-based summarization, and web-augmented memory. The assessment utilizes three public datasets covering multi-session dialogue, document grounding, and persona chat, measuring metrics like recall, faithfulness, and memory footprint.

• Evaluates ICW, EKV, GEM, CBS, and WAM under identical conditions for fair comparison.
• Tests across LoCoMo, MultiDoc2Dial, and MSC datasets for diverse long-term scenarios.
• Measures Recall@k, MRR, nDCG@k, Answer F1, LLM-judge Faithfulness, and Memory Footprint.
• Addresses the bottleneck of finite context windows in multi-turn conversational agents.

The article argues that developer tools should be open source to ensure transparency and community trust. It highlights the risks of proprietary black-box tools in critical development workflows. The author advocates for open standards and accessible codebases to empower engineers.

• Proprietary devtools obscure internal logic, creating trust and security risks.
• Open source tools enable community audits and faster vulnerability patching.
• Engineers benefit from transparency in how their environments process data.

PostgreSQL 18 introduces a new GUC enabling extension control and SQL files to reside outside standard server directories. This change facilitates packaging extensions as independent OCI images, allowing them to be mounted at runtime via Kubernetes ImageVolume or Docker volumes. The approach supports independent versioning and upgrading of extensions without rebuilding the core PostgreSQL server image.

• PostgreSQL 18 adds a GUC to locate extension files outside server directories.
• Enables packaging extensions as separate OCI images for runtime mounting.
• Allows independent extension upgrades without rebuilding the server image.
• Decoupling effectiveness depends on the specific extension's architecture.

Amazon CloudWatch now offers fully managed collectors to ingest Prometheus metrics from AWS resources like EKS, EC2, ECS, MSK, and OpenSearch. This feature eliminates the need to deploy and maintain self-managed OpenTelemetry Collector agents. Users simply provide scrape configurations, and CloudWatch handles provisioning, scaling, and metric delivery in OpenTelemetry format.

• Remove self-managed OpenTelemetry Collector overhead for Prometheus ingestion.
• Collect metrics from EKS, EC2, ECS, MSK, and OpenSearch seamlessly.
• Query ingested metrics alongside AWS vended metrics using PromQL.
• Enable unified alarming, dashboards, and cross-service correlation.

AWS Transform for full-stack Windows modernization now allows offline source transformation, enabling migration from Microsoft SQL Server to Amazon Aurora PostgreSQL without a live database connection. The service converts storage objects using AWS DMS and handles code objects like stored procedures through an interactive, agentic experience. Enterprises can upload SQL Server DDL files to assess complexity and generate customizable migration plans directly.

• Migrate SQL Server to Aurora PostgreSQL without requiring a live connection to the source database.
• Upload DDL files directly to assess database and stored procedure complexity before migration.
• AWS DMS handles storage object conversion while an agentic tool manages stored procedure code.
• Enables offline modernization for legacy .NET applications and their dependent SQL Server databases.

AWS Resilience Hub now generates pre-configured resilience tests tailored to your service architecture and resilience policy. Leveraging AWS Fault Injection Service, these tests inject controlled faults to validate recovery against objectives like zone or region impairments. The system automatically targets relevant resources, executes the faults, and evaluates pass or fail outcomes based on alarms and recovery metrics.

• Automated test generation aligns with your specific resilience policy and architecture
• Validates recovery for critical scenarios including AZ/region outages and dependency failures
• Integrates with FIS to execute controlled fault injection without manual scripting
• Provides immediate pass/fail results based on defined recovery objectives and alarms

AWS Lambda has increased the maximum number of event pollers for Provisioned Mode Amazon SQS event source mappings from 2,000 to 10,000. This fivefold increase allows workloads to scale up to 100,000 concurrent invocations. The update is designed to support mission-critical applications requiring high throughput and low latency, such as real-time order processing and IoT telemetry ingestion. Users can now configure minimum and maximum pollers to optimize throughput for demanding event-driven architectures.

• SQS Provisioned Mode poller limit increased 5x from 2,000 to 10,000.
• Supports up to 100,000 concurrent Lambda invocations for high-scale workloads.
• Optimizes throughput for latency-sensitive apps like financial pipelines and IoT.
• Enables finer control over min/max pollers for predictable performance.

AWS has moved the IAM Policy Simulator directly into the IAM console, replacing the previous standalone interface. The updated tool now allows testing of Service Control Policies (SCPs) alongside identity and resource policies. This integration provides platform teams with greater flexibility to model complex permission scenarios before deployment.

• Simulator is now native to the IAM console, centralizing identity management workflows.
• New capability to test Service Control Policies (SCPs) in simulations.
• Enables validation of SCP hierarchy interactions with identity and resource policies.
• API access retains support for testing specific condition keys.

Amazon OpenSearch Service now offers version 3.7, featuring enhanced performance for vector search and improved search relevance capabilities. The update introduces 1-bit scalar quantization on Faiss and Lucene engines to reduce storage and memory usage without sacrificing accuracy. Additional features include faster vector retrieval via doc values without reindexing and new Search Relevance Workbench tools for evaluating hybrid search quality.

• Run OpenSearch 3.7 on Amazon OpenSearch Service starting today.
• Use 1-bit scalar quantization on Faiss/Lucene to cut vector storage and memory costs.
• Retrieve vectors faster using doc values with no reindexing required.
• Leverage new Search Relevance Workbench metrics and CSV uploads for quality control.
• Access automated query recommendations and finished-queries cache via Query Insights.

AWS Direct Connect now exposes BGP route details for private, transit, and public virtual interfaces. Users can inspect accepted and advertised routes, including AS paths and BGP communities, directly in the console or via the ListVirtualInterfaceRoutes API. This capability simplifies troubleshooting hybrid network routing issues and verifying route propagation.

• View accepted and advertised BGP routes for all VIF types in the console.
• Inspect AS paths and BGP community values for detailed traffic analysis.
• Access route data programmatically via the ListVirtualInterfaceRoutes API.
• Use this feature to verify route propagation and troubleshoot connectivity.

Amazon RDS for Oracle now supports 1-year and 3-year Reserved Instances for the R8i and M8i instance families, offering up to 53% savings over On-Demand pricing. These instances leverage custom Intel Xeon 6 processors exclusive to AWS, providing up to 2.5x more memory bandwidth and 15% better price-performance than previous generations. Reserved Instance benefits apply to both Single-AZ and Multi-AZ configurations, allowing flexibility to switch between them within the same instance class.

• Up to 53% cost savings available for R8i and M8i instances via 1- or 3-year RIs.
• Custom Intel Xeon 6 chips deliver 2.5x memory bandwidth vs. prior gen Intel instances.
• RIs apply to Multi-AZ and Single-AZ, allowing config switching without losing benefits.
• Ideal for stable workloads needing high memory bandwidth and predictable Oracle costs.