Thursday, October 08, 2026

Dimitri Fontaine outlines how Postgres logical replication enables database consolidation by evolving the feature set across ten releases. This article serves as the second part of a series, assuming readers have reviewed the hub-and-workers architecture for write scalability from Part 1. It focuses on leveraging these capabilities to merge distinct database instances into a unified logical structure.

• Logical replication has matured significantly over ten Postgres releases, enabling complex consolidation patterns.
• Part 1 established a hub-and-workers model; this post builds on that for consolidation use-cases.
• Requires understanding of incremental feature additions across major versions to plan migrations.
• Part 3 will address zero-downtime major upgrades, completing the consolidation lifecycle.

Grab replaced its wide-column database with Aerospike for its high-volume Counter Service, achieving significant performance and cost improvements. The migration involved a redesigned data model that consolidated time buckets into map-based records, supported by shadow traffic and data parity validation. Post-migration metrics show a 50% reduction in p99 read latency, 1 TB disk usage compared to 3 TB previously, and a 45% to 50% drop in cost per node.

• Consolidating time buckets into map-based records reduced storage from 3 TB to 1 TB.
• P99 read latency dropped by approximately 50% after switching to Aerospike.
• Migration strategy used shadow traffic and parity validation to ensure data integrity.
• Cost per node decreased by 45% to 50% with the new storage abstraction.

PostgreSQL extension pg_vault_tde released version 1.7.2 to address critical stability and security issues. The update introduces a new on-disk tuple layout (v5) and fixes segmentation faults occurring during updates on indexed variable-length columns. It also resolves crashes related to TOAST threshold crossings for encrypted values and hardens the tde_btree index to prevent incorrect range query results.

• Upgrade to v1.7.2 to fix critical segfaults on UPDATE operations with indexed variable-length columns.
• New v5 on-disk tuple layout improves walkability and prevents unreadable tables from all-NULL rows.
• tde_btree index now strictly handles equality queries, avoiding incorrect returns on range operations.
• Runtime version check via pg_vault_tde_build_version() distinguishes this binary patch from v1.7.

Percona has released version 1.0.0 of ClusterSync for MongoDB as generally available, marking it as production-ready and fully supported. The tool is designed to facilitate data movement away from MongoDB Atlas, Enterprise, or Community editions. Early validation includes successful migrations involving multi-terabyte datasets.

• Enables migration off MongoDB Atlas, Enterprise, or Community editions.
• Production-ready with full vendor support for enterprise deployments.
• Validated on real-world multi-terabyte migration workloads.
• No longer in beta; safe for critical infrastructure planning.

The pg_ivm 1.16 release adds native support for PostgreSQL 19 and resolves several stability issues in incremental view maintenance. Key fixes address a segfault occurring when an Incremental Materialized View is dropped in the same transaction as maintenance, and correct maintenance failures for tables lacking default equality operators. The update also handles edge cases where OIDs exceed INT_MAX and prevents spurious transaction failures during maintenance operations.

• Upgrade to support PostgreSQL 19 deployments and new features.
• Fixes segfaults when dropping IMVs within the same transaction as maintenance.
• Resolves maintenance failures for tables with types lacking default equality operators.
• Corrects view maintenance when global OID counter exceeds INT_MAX.
• Prevents spurious transaction failures during incremental maintenance runs.

AWS has added Claude Haiku 5.5 to its model library, positioning it as the most efficient option in the Claude 5.5 family. Anthropic reports a 75% cost reduction compared to Haiku 4.5 while delivering significant gains in coding, tool use, and agent capabilities. The release introduces effort controls, allowing teams to dynamically balance intelligence against cost for specific workloads.

• 75% lower cost than Haiku 4.5 for most tasks, improving unit economics.
• New effort controls enable dynamic tuning of cost versus intelligence per request.
• Optimized for high-volume, latency-sensitive workloads like voice agents and classification.
• Significant capability uplift in coding, tool use, and computer use over previous generation.

The authors introduce Tokka-Bench, an open-source framework for standardized tokenizer evaluation across 100 natural languages and 20 programming languages. The study compares seven major BPE tokenizers using five metrics, including bytes per token and subword fertility. Key findings indicate that vocabulary allocation strategy significantly impacts performance more than raw vocabulary size.

• Tokka-Bench provides a standardized multi-metric framework for tokenizer comparison.
• Evaluation covers 100 natural languages and 20 programming languages.
• Vocabulary allocation strategy matters more than raw vocabulary size.
• Seven major BPE tokenizers were benchmarked for performance differences.

This research addresses the challenge of high-recall LLM extraction producing noisy, overlapping, or excessive intent data. The authors propose a dataset-adaptive post-processing architecture for Customer Intent Extraction that separates initial recall-oriented extraction from utility-oriented reduction. By isolating evidence from multimodal plans and structured data before standardizing and deduplicating candidates, the method aims to produce stable, traceable intent units suitable for downstream systems.

• Separates recall extraction from utility reduction to prevent downstream overload.
• Adapts post-processing logic to specific dataset characteristics and sources.
• Standardizes and deduplicates candidate intents for human and system review.
• Improves traceability of extracted signals from unstructured customer language.

Masked diffusion language models (MDLMs) typically make irreversible token commitments early in decoding, leading to error propagation when initial sparse context misleads the model. The CoDR method addresses this by detecting confidence drift, where the model's certainty in a committed token drops as more context becomes available. This training-free, sampler-agnostic refinement pass remasks tokens that no longer meet confidence thresholds, allowing for correction without retraining.

• MDLMs often commit tokens too early under sparse context, causing irreversible errors.
• CoDR detects confidence drift to identify tokens that should be uncommitted.
• The method is training-free and agnostic to the underlying sampling strategy.
• Remasking allows the model to revise decisions as context density increases.
• Reduces error propagation without requiring architectural changes or new training.

A new study of 103,939 replies reveals that LLM sycophancy is driven primarily by the verification cost of the user's claim and the presence of trained guardrails, rather than just model architecture. Researchers tested eight LLM configurations across 200 items and 13 pressure conditions in four-turn conversations. The findings suggest that current single-rate sycophancy metrics obscure critical context-dependent factors that influence when models abandon correct answers.

• Sycophancy rates vary significantly based on task complexity, not just model identity.
• Trained guardrails are a dominant factor in suppressing or enabling yielding behavior.
• Verification cost of user claims is a key predictor of when models switch stances.
• Single-rate metrics fail to capture when sycophancy actually occurs in practice.
• Designing prompts to increase verification cost may reduce erroneous yielding.

This research paper introduces U-Space, a method to uncover exactly when and why uncertainty arises in large language models. Unlike existing techniques that rely on repeated generations or scalar estimates, this approach traces uncertainty evolution during the reasoning process. The study addresses the critical need to understand trustworthiness in high-stakes LLM decisions by revealing where confidence breaks down.

• Moves beyond scalar uncertainty scores to pinpoint specific reasoning steps causing doubt
• Avoids the computational cost of repeated generations required by many prior methods
• Reveals how uncertainty evolves dynamically throughout the model's thought process
• Helps practitioners identify when to defer LLM outputs in high-stakes scenarios

Existing quantization-aware training often fails because it optimizes on fixed data while the deployed model generates its own prefixes, causing quantization errors to push the model into unseen states. OnlineQAT addresses this by first initializing a low-bit model via block-wise QAT and then performing on-policy distillation on the student's own generated responses. A frozen full-precision teacher provides a reverse-KL training signal at each visited prefix to correct these distributional shifts.

• Fixes accuracy loss when deploying LLMs compressed below four bits.
• Uses on-policy distillation to match the model's actual inference behavior.
• Frozen teacher applies reverse-KL signals to correct student prefix drift.
• Two-stage process: block-wise initialization followed by self-generated distillation.

AdaGuard introduces an adaptive LLM-as-a-Judge framework that dynamically enforces safety and compliance policies without requiring frequent model updates. Built via supervised fine-tuning and reinforcement learning, it allocates reasoning budgets based on runtime needs, addressing the rigidity of fixed guardrail solutions. This approach allows enterprise applications to accommodate diverse risk postures and evolving policies with greater transparency and flexibility.

• Eliminates need for frequent model updates by generalizing to user-defined policies at runtime.
• Uses SFT and GRPO reinforcement learning to build adaptive reasoning capabilities.
• Dynamically allocates reasoning budgets to balance safety checks against latency constraints.
• Addresses rigidity in current guardrails by supporting evolving enterprise risk postures.

LRCC introduces a method for low-rank model compression that replaces fixed-rank inference with conditional computation. It trains lightweight routers per Transformer block to select among nested low-rank paths based on input tokens, while keeping the underlying low-rank factors frozen. Evaluations on Llama and Qwen models show performance gains within the same active-parameter budget compared to conventional static compression.

• Replaces static low-rank compression with dynamic, token-dependent routing for better efficiency.
• Only lightweight routers are trained; low-rank factors remain frozen to reduce training cost.
• Improves language modeling and zero-shot performance without increasing average active parameters.
• Demonstrated effectiveness on major open models like Llama and Qwen.

This research investigates whether serving factors like batch size, hardware, and inference engines cause output variations in text classifiers, extending prior findings from text generation models. The study systematically measures serving-context non-invariance to determine if floating-point non-associativity and kernel selection affect classification predictions. It aims to clarify the extent to which implementation-level differences alter results even when model parameters and sampling randomness remain fixed.

• Text classification outputs may vary based on serving infrastructure, not just model weights.
• Batch size and composition can introduce non-determinism in classifier predictions.
• Hardware differences and inference engines contribute to floating-point non-associativity.
• Deterministic inference is critical for reliable and trustworthy ML systems.
• Practitioners should audit serving contexts when reproducibility is required.

This research paper demonstrates that early-stage Mixture-of-Experts models develop correlated token routing patterns, allowing for optimized expert placement. By leveraging these correlations through token shuffling and correlated placement, the study significantly reduces the all-to-all communication overhead that currently consumes up to 60% of training steps on AMD MI300X clusters. The approach improves training efficiency without requiring changes to the core model architecture.

• All-to-all collectives dominate MoE training time, reaching 60% at top-6 routing.
• Early pretraining routers exhibit strong correlation in expert selection patterns.
• Correlated expert placement exploits these patterns to minimize communication volume.
• Token shuffling further optimizes dispatch efficiency during the forward pass.
• Significant speedup potential for large-scale MoE clusters without architectural changes.

Hugging Face and Liquid AI have released open-source multimodal decision models designed specifically for edge deployment. These models aim to bring advanced reasoning capabilities to resource-constrained environments without relying on cloud inference. The release provides developers with accessible tools to integrate complex multimodal logic directly into edge devices.

• Open models enable local multimodal reasoning without cloud dependency.
• Designed for edge hardware constraints and low-latency requirements.
• Collaboration between Hugging Face and Liquid AI expands open AI tooling.
• Supports decision-making workflows on devices with limited compute.

Recent open-looped LMs fail to deliver promised savings because each iteration requires a separate KV cache level, forcing full computation. The authors introduce a 'best-available' KV caching strategy that breaks this static processing pattern. This method allows models to dynamically adjust depth per token, achieving significant efficiency gains without sacrificing performance.

• Prior looped LMs wasted resources by caching KV states for every iteration, negating dynamic benefits.
• New KV strategy enables true dynamic computation, varying depth based on token difficulty.
• Results show up to 30% reduction in FLOPs and KV memory usage compared to static approaches.
• Performance remains high, retaining full-depth accuracy while optimizing for easier tokens.

The trycua/cua repository provides infrastructure to scale computer-use 2.0 AI agents, featuring open-source drivers for cross-OS desktop automation. It includes Cua Spaces for managing full desktop environments on Mac and owned machines, alongside Lume for local VM creation. The project also offers CUA-S1 specialized decision models and Cua Bench for evaluating agent performance and generating training data.

• Cua Spaces enables agents to operate full desktop environments on Mac and owned hardware.
• Cua Driver automates desktop interactions, allowing verification of actions like calculator results.
• Cua Bench provides tools for evaluating computer-use agents and generating training data.
• CUA-S1 offers small, specialized models tailored for computer-use decision-making tasks.
• Lume facilitates creating Tahoe VMs with SSH connectivity for local sandboxing.

Researchers evaluated nine models ranging from 0.8B parameters to frontier-tier LLMs across five distinct call sites in a deployed home-automation system. Using unmodified production prompts and real-world data, the study reveals that model capability is not uniformly ordered across different task types. The findings challenge the industry practice of using a single, large model for all agentic operations, demonstrating that smaller models often suffice or even excel at specific, less complex call sites.

• Capability ranking varies by task; larger models do not universally outperform smaller ones.
• Agentic systems have heterogeneous call sites with varying difficulty levels.
• Smaller models can handle specific tasks more efficiently than frontier-tier LLMs.
• A single large model strategy is inefficient for systems with diverse call requirements.

This paper introduces Humanize, a multi-agent workflow designed to solve the reliability gap in agentic coding where agents struggle to judge their own completion. The system uses explicit judgement engineering with deterministic hooks that route work between planning, implementation, and review roles. Key to this approach is the enforcement of 72 mechanical gates, including mandatory human approval for plan contracts and independent vendor-based reviewer agents for completion decisions. The process is modeled as a Markov chain over repository states to ensure rigorous defect detection through alternating builder and reviewer sampling.

• Relies on judgement engineering rather than model capability to ensure reliable code completion.
• Enforces 72 mechanical gates via deterministic hooks to control workflow boundaries.
• Requires human approval for plan contracts before any implementation begins.
• Uses an independent reviewer agent from a different vendor to decide completion status.
• Models the workflow as a Markov chain to manage defect survival probabilities.

Researchers address how persistent LLM memory retains rejected hypotheses as facts, creating durability for false reasoning. They introduce 'discourse ownership', a signal representing the context or speaker licensing a proposition. This approach aims to detach propositions from their original validity scope before committing them to long-term storage.

• Persistent memory risks turning simulated or rejected agent plans into durable false facts
• Discourse ownership captures the context that licenses a proposition's validity
• LLMs already contain causal signals for ownership that can be leveraged for filtering
• Scope-aware rules prevent context-less propositions from contaminating long-term memory

Research highlights how supervisory governors can inadvertently cause persistent task failures by interfering with regulated agents. In controlled file-recovery tests, cost-blind governors triggered blocking when regulatory intensity increased and tool failures occurred. The study compares this against an adaptive backoff mechanism that lowers intervention probability based on recent failure history, showing improved completion rates.

• Governors can become the primary source of blocking if they ignore cost implications of interventions.
• Adaptive backoff using moving averages of induced failures outperforms fixed weak governors.
• Persistent blocking occurs even with simple stochastic-policy agents under result replacement attacks.
• Implementing failure-aware backoff rules is critical for resilient tool-using agent architectures.

Researchers introduce Sigma-Hunter, a domain-adapted LLM designed to help detection engineers translate threat reports and forensic observations into valid Sigma rules. Unlike general-purpose models that often produce invalid YAML or incorrect logic, this model is fine-tuned on a curated dataset of 3,635 validated open-source rules expanded into over 7,600 examples. The team trained both a 7B Mistral and a Phi model to ensure strict adherence to detection engineering constraints without data leakage across splits.

• Addresses common LLM failures like invalid YAML and unsupported fields in Sigma rules.
• Trained on 7,663 QA examples derived from 3,635 validated open-source rules.
• Ensures no data leakage by partitioning source rules before expansion.
• Available for both Mistral 7B and Phi architectures for flexible deployment.

AWS Batch now emits native CloudWatch metrics for job state transitions and duration, enabling direct visibility into batch workload health. These metrics cover the entire lifecycle, including submission to runnable times and total execution duration, tagged with the JobQueueName dimension. Users can access this data via the AWS Batch console, CloudWatch console, or through standard CLI and SDK integrations.

• Native CloudWatch metrics eliminate the need for custom logging pipelines to track batch job health.
• State transition metrics allow precise monitoring of job flow through submitted, running, and failed states.
• Duration metrics provide granular visibility into latency between submission, runnable status, and completion.
• Metrics are automatically tagged with JobQueueName, simplifying aggregation and alerting per queue.

AWS Batch now authenticates to Amazon EKS clusters using the API-driven access entry mechanism instead of relying solely on the aws-auth ConfigMap. This change simplifies cluster setup and lifecycle management by allowing IAM principals to be granted access programmatically. Users can enable this feature via the CreateComputeEnvironment or UpdateComputeEnvironment APIs by setting the accessEntry.desiredState to ENABLED.

• Eliminates manual ConfigMap management for Batch-to-EKS auth
• Enable via API by setting accessEntry.desiredState to ENABLED
• AWS Batch creates one access entry per cluster automatically
• Associates AWSBatchClusterPolicy with the new access entry
• Use CLI, SDKs, or Console to configure access entries

cmux is an open-source terminal built on Ghostty that introduces vertical tabs and system-level notifications specifically for AI coding agents. It provides a notification panel to aggregate pending agent alerts and includes an in-app browser for splitting views alongside the terminal. The tool emphasizes multitasking and programmability for developers managing multiple AI interactions.

• Vertical tabs improve screen real estate when managing many concurrent AI agent sessions.
• Notification rings and a central panel reduce context-switching overhead for developers.
• Built on Ghostty, leveraging its performance while adding agent-specific UI features.
• In-app browser support allows splitting terminal and web views for easier reference.
• Targeted workflow optimization for macOS users heavily relying on AI coding assistants.

AWS Control Tower Account Factory for Terraform now supports plan-only customization runs, allowing administrators to preview Terraform changes before applying them. Previously, triggering customizations always executed a full apply, making it hard to validate outcomes or detect drift. This new capability enables safe pre-rollout validation and integration into CI/CD pipelines without altering the live environment.

• Preview Terraform plans for global and account customizations without applying changes.
• Reduce risk of unintended configuration drift during broad rollout phases.
• Integrate AFT customizations into CI/CD workflows for safer automated deployments.
• Validate expected outcomes of Terraform modules before committing to production.

AWS Continuum for Penetration Testing has entered public preview with native support for CI/CD integration. This update shifts security testing left by embedding penetration tests directly into deployment workflows, moving validation from post-deployment to deploy-time. Developers now receive immediate findings on severity and affected endpoints within their existing build systems.

• Native CI/CD integration enables continuous penetration testing as a deploy-time event
• Eliminates need for third-party vendor contracts for routine security validation
• Shifts security testing left to align with daily code shipping workflows
• Public preview status available now for immediate integration testing

AWS Certificate Manager extends ACME public certificate issuance to work over AWS PrivateLink, keeping traffic within the AWS network. Users can create a VPC interface endpoint for the ACM ACME service, allowing any ACMEv2-compatible client to route requests through the VPC. Existing client configurations and directory URLs continue to function without modification, as Private DNS automatically resolves to the new interface endpoint.

• Route ACME public certificate issuance over private VPC paths via AWS PrivateLink.
• No code or config changes required for existing ACMEv2-compatible clients.
• Private DNS automatically resolves the ACME directory URL to the interface endpoint.
• Create the managed endpoint in ACM, then provision a standard VPC interface endpoint.

AWS Private CA now emits a new CloudTrail event, IssueCertificateDetails, that captures the complete to-be-signed certificate content, issuing CA info, requester identity, and signing status for every issuance. This replaces the previous limited management event which only confirmed API success with an ARN and missed failed attempts or certificate payload details. The enhancement supports compliance auditing, inventory management, algorithm migration tracking, and monitoring of failed issuance attempts.

• IssueCertificateDetails event captures full X.509 fields and extensions in CloudTrail logs.
• Enables auditing of failed issuance attempts that were previously invisible in management events.
• Simplifies certificate inventory and algorithm migration tracking with complete payload data.
• Replaces the prior IssueCertificate event which lacked content and failure details.
• Use these logs for compliance auditing and monitoring CA signing status.

AWS Client VPN now integrates with third-party posture providers like CrowdStrike and Jamf to verify device security before granting network access. This capability extends beyond previous certificate or SAML authentication by evaluating real-time signals such as encryption status and compliance scores. Administrators define granular access rules using Cedar policies to ensure only trusted devices reach AWS resources.

• Integrates with CrowdStrike, Jamf, and JumpCloud for automated device trust verification.
• Uses Cedar policies to define fine-grained access rules based on device security signals.
• Adds a layer of endpoint validation beyond existing user authentication methods.
• Enforces compliance requirements like encryption status before allowing network connectivity.

This GitHub repository provides production-grade engineering skills designed to guide AI coding agents through the full software development lifecycle. It defines six key phases—Define, Plan, Build, Verify, Review, and Ship—using quality gates and best practices typically used by senior engineers. The project includes nine slash commands that automatically activate the appropriate skills for each stage, ensuring consistency across development tasks.

• Encodes senior engineer workflows as reusable skills for AI agents
• Covers full lifecycle: spec, impl, test, QA, and deployment
• Uses nine slash commands to trigger context-specific skills
• Aims to standardize quality gates across every development phase