Monday, July 13, 2026

AWS Database Migration Service now allows offline schema conversion for Microsoft SQL Server by extracting metadata locally and uploading it to the service. This approach removes the need for direct connectivity, bypassing security reviews, firewall changes, and VPN setups. It delivers identical conversion results to the connected method while accommodating strict security policies that prohibit external tool access to production databases.

• Extract SQL Server metadata using standard commands in your own environment before uploading.
• Eliminate delays from security reviews, firewall rules, and VPN configuration for migrations.
• Achieves the same conversion accuracy as the connected method without live database access.
• Ideal for production environments with strict policies against external tool connectivity.

Percona has released an experimental MySQL 9.7 build featuring a DuckDB storage engine that routes analytical queries from marked tables directly to DuckDB. This approach allows analytical workloads to run on the same server and connection as transactional data without duplicating the dataset. Early TPC-H benchmarks at scale factor 10 show InnoDB timing out on six queries and taking 1317 seconds on others, highlighting the performance gap DuckDB aims to fill.

• Experimental MySQL 9.7 build enables ENGINE=DuckDB for analytical offloading from InnoDB.
• Analytical queries run in-process without data duplication or separate infrastructure.
• InnoDB struggled with TPC-H Q6-Q22 timeouts and high latency at scale factor 10.
• Validates hybrid transactional/analytical processing within a single database instance.

The pgrust project, a Postgres rewrite in Rust, now passes 100% of the Postgres 18.3 regression suite, covering over 46,000 queries. It maintains disk compatibility with existing Postgres data directories, allowing systems to boot directly from them. The current architecture uses a thread-per-connection model, replacing the traditional process-per-connection approach.

• pgrust achieves full regression test parity with Postgres 18.3, ensuring behavioral compatibility.
• Disk compatibility allows migration or side-by-side usage with existing Postgres data directories.
• Shifts from process-per-connection to thread-per-connection, potentially impacting concurrency models.
• Leverages Rust and AI-assisted development to explore deeper server internals changes.

This paper argues that LLM reliability depends less on model capability and more on inference-time control mechanisms like task framing and context selection. It introduces CogniConsole, an architecture that externalizes this control into a structured interface combining programmatic coordination with bounded prompt reasoning. Probes in a multi-step interactive environment show that adding structural scaffolding systematically reduces output variance and failure rates.

• Reliability is driven by inference-time control layers, not just model size or capability.
• CogniConsole externalizes control via a structured interface for task framing and context.
• Structural scaffolding significantly lowers output variance in multi-step interactions.
• Programmatic coordination combined with bounded reasoning improves system stability.

This paper addresses the accuracy degradation LLMs face when processing long contexts by introducing self-guided test-time training. Rather than adapting parameters across the entire noisy context or relying on random span sampling, the method identifies relevant evidence spans for specific questions. This instance-specific adaptation allows the model to utilize long inputs more effectively without the prohibitive cost of full-context training.

• Long-context accuracy drops as models struggle to filter irrelevant noise.
• Test-time training adapts parameters per instance but is usually too expensive.
• Self-guided selection targets only relevant spans, reducing noise significantly.
• Avoids the pitfalls of random span sampling used in prior TTT approaches.

Researchers introduce Soofi S 30B-A3B, a sovereign open-source foundation model blending Mixture-of-Experts with a hybrid Mamba-Transformer architecture. Designed for German and English, it activates only 3 billion of its 30 billion parameters per token, maintaining near-constant inference cache size as context expands. Pretrained on 27 trillion tokens with an emphasis on German, it matches dense 14-27B models on benchmarks and leads in code generation among comparable open models.

• Hybrid Mamba-Transformer design enables constant inference cache growth for long-context efficiency.
• Activates only 3B parameters per token (of 30B total), boosting throughput for high-concurrency workloads.
• Trained on 27T tokens with up-weighted German data, outperforming European sovereign baselines.
• Achieves best-in-class code aggregates for both English and German among 17 open base models.

HALO introduces a hybrid method to enhance frozen pretrained language models by adding adaptive extra computation. It uses a coarse refinement stage followed by selective second-stage refinement on specific tokens, determined by token scoring and monotonic halting. This approach avoids the waste of fixed refinement steps while achieving top average performance on MMLU-Pro and GPQA-Diamond benchmarks.

• Applies adaptive computation to frozen models, avoiding full retraining costs.
• Uses token scoring and monotonic halting to selectively refine only necessary tokens.
• Outperforms fixed-step refinement methods on MMLU-Pro and GPQA-Diamond.
• Balances compute efficiency with improved transfer performance via hybrid stages.

WILDTRACE evaluates how models integrate evidence dispersed naturally across distant passages in long documents, addressing a gap in existing benchmarks. Unlike needle-in-a-haystack probes or reverse-engineered chains, this dataset uses real-world scenarios like incident reports and novels where facts are organically scattered. The benchmark aims to assess true long-document analysis capabilities rather than artificial retrieval tasks.

• Focuses on source-internal evidence integration rather than artificial needle probes.
• Tests reasoning over naturally dispersed facts in complex documents like incident reports.
• Addresses distribution and placement gaps found in prior multi-hop reasoning benchmarks.

A new study identifies 'deceptive grounding' in clinical RAG systems, where models correctly cite real documents but attribute evidence to the wrong entity, such as swapping drug X for drug Y. This failure bypasses standard faithfulness and hallucination metrics because the citations are technically valid, even though the semantic link is incorrect. Testing 13 models revealed deceptive grounding rates between 8% and 87% under adversarial conditions, with medical fine-tuned models showing significant vulnerability.

• Standard RAG evals miss entity attribution errors, allowing wrong drugs to be linked to correct papers.
• Deceptive grounding rates hit 87% in adversarial settings across 13 tested models.
• Medical fine-tuned models are not immune to this specific attribution failure mode.
• Practitioners must add entity-resolution checks beyond simple faithfulness metrics.

This paper investigates why knowledge distillation works for large language models by decomposing output scores into nonlinear interactions between input variables. The authors find that the common mechanism across various distillation methods is the sparsification of these interactions. Student models retain only a subset of significant interactions while suppressing others to zero, effectively simplifying the model's decision logic.

• KD efficacy stems from interaction sparsification, not just probability matching.
• Student models suppress nonlinear input interactions to near-zero values.
• Retained interactions represent the core logic preserved during distillation.
• This provides a unified theoretical framework for analyzing diverse KD methods.

Mixture-of-Experts models often trigger frequent expert switching between consecutive tokens, causing costly weight swaps between storage and fast memory. This work introduces StickyMoE, a differentiable routing consistency loss that penalizes abrupt switches, encouraging the router to maintain assignments across semantically coherent spans. Unlike post-hoc fine-tuning, this method integrates directly into pretraining without architectural changes.

• StickyMoE adds a single hyperparameter lambda to penalize abrupt expert switches during training.
• Encourages router consistency across adjacent tokens to reduce memory bandwidth pressure.
• No architectural modifications required; integrates directly into the pretraining loop.
• Addresses the root cause of weight swapping rather than relying on caching heuristics.
• Enables more memory-efficient inference on edge devices by stabilizing expert activation.

Amazon SageMaker Feature Store now supports BatchWriteRecord, enabling high-throughput ingestion of multiple records across feature groups in a single API call. The update also introduces ListRecords for discovering stored data without predefined identifiers and allows custom naming for offline store tables and databases. These enhancements reduce API overhead and latency while improving offline store cataloging flexibility.

• Use BatchWriteRecord to ingest features at scale with fewer API calls and lower latency.
• Discover stored records dynamically via ListRecords without needing specific record identifiers.
• Define custom names for databases and tables within the offline store for better organization.
• Optimize training data pipelines by reducing the overhead of single-record writes.

The GATS framework addresses the high cost and stochastic behavior of LLM-based planning tools like LATS and ReAct by eliminating LLM calls during inference. It combines systematic UCB1-based tree search with a three-layer world model that handles exact symbolic matching, execution log statistics, and LLM predictions only for unknown actions. This approach aims to deliver superior planning performance on synthetic tasks with branching paths and dead-ends while reducing computational overhead.

• GATS removes LLM inference during the planning phase, significantly cutting computational costs.
• A layered world model handles known actions via symbolic matching and logs, reserving LLMs for unknowns.
• UCB1-based tree search provides systematic exploration, reducing the stochastic behavior of prior methods.
• Performance gains are demonstrated on synthetic tasks involving complex branching and dead-ends.
• This architecture offers a deterministic alternative to purely LLM-driven agent planning workflows.

KV-PRM addresses the quadratic scoring cost of text-based Process Reward Models in long multi-agent rollouts by eliminating redundant text re-encoding. Instead of processing full trajectories from scratch, the model directly reads the KV cache generated during the LLM's initial generation phase. This approach allows for efficient scoring of agent steps using a single verify token, significantly reducing computational bottlenecks in test-time scaling.

• Eliminates quadratic scoring cost by reusing existing KV caches instead of re-encoding text.
• Enables efficient Process Reward Modeling for long-context multi-agent rollouts.
• Reduces test-time scaling overhead, making PRMs more practical for complex agent tasks.
• Validates KV cache reuse as a viable optimization for inference-time reward signals.

This paper addresses the context loss problem in agentic LLMs that generate code via multi-turn tool use, where sessions typically start from zero. The proposed architecture, shared selective persistent memory, retains reusable context such as task specifications, data schemas, and tool configurations while discarding irrelevant session-specific reasoning traces. This approach avoids the token inefficiency and quality degradation associated with naively persisting entire conversation histories.

• Agentic LLMs lose productive context like schemas and constraints between sessions, hurting efficiency.
• Selective persistence keeps reusable artifacts (specs, schemas) while dropping verbose reasoning traces.
• Shared memory workspaces allow multiple sessions to leverage retained context without token bloat.
• Reduces irrelevant context noise, improving generation quality compared to full history retention.

This paper introduces GRACE, a method to manage persistent system instructions for LLM agents by storing them as a typed semantic graph instead of flat text. It validates updates within local neighborhoods to prevent conflicts as the instruction set grows over long operational horizons. The approach reconstructs accepted graph changes as incremental edits to the final system prompt, ensuring reliable context evolution under distribution shifts.

• Replaces fragile flat-text instruction maintenance with a structured typed semantic graph.
• Validates updates locally to reduce verification complexity as context scales.
• Enables reliable long-horizon agent operation by handling accumulated instruction interactions.
• Reconstructs graph updates as incremental edits to maintain a consistent system prompt.

OpenProver is an open-source system for automated theorem proving that uses a Planner-Worker-Verifier architecture to generate and check proofs in Lean 4. A Planner agent manages a scratchpad and repository, delegating tasks to parallel Workers while a Verifier ensures correctness. The system supports an interactive terminal interface, allowing human operators to monitor and guide the proof search process directly.

• Uses a Planner-Worker-Verifier architecture for structured, parallel proof generation.
• Integrates Lean 4 for automatic formal verification of all generated proofs.
• Fully open-source with reproducible evaluation capabilities.
• Offers interactive terminal mode for human-guided proof search and steering.

Amazon SageMaker HyperPod now allows AMI-based node lifecycle configuration for Slurm clusters operating in continuous provisioning mode. This update eliminates the need to download, configure, or upload lifecycle scripts to S3, as the AMI pre-bakes necessary software like Docker, Enroot, and Pyxis. Nodes are automatically provisioned with production-ready configurations, including Slurm accounting and SSH keys, as capacity becomes available.

• No more S3 script uploads for lifecycle config in continuous provisioning mode
• AMI pre-loads AI/ML runtime stack: Docker, Enroot, Pyxis, and Slurm
• Automated setup of SSH keys, accounting, and log rotation on node launch
• Simplifies scaling workflows by removing manual config steps for new nodes

Amazon Aurora DSQL Change Data Capture is now generally available, allowing developers to stream real-time insert, update, and delete events directly to Amazon Kinesis Data Streams. This managed feature supports event-driven architectures by integrating with AWS Lambda, Amazon S3, Redshift, and OpenSearch via Data Firehose, all without requiring infrastructure management. The service is designed to operate with zero impact on the underlying database workload performance.

• Aurora DSQL CDC is GA and integrates natively with Kinesis Data Streams for real-time event streaming.
• Automatically captures inserts, updates, and deletes without managing infrastructure or impacting DB performance.
• Enables event-driven workflows by triggering Lambda functions or delivering data to S3, Redshift, and OpenSearch.
• Available in all AWS Regions where Aurora DSQL is currently supported.

Amazon EMR on EKS now integrates an Apache Spark troubleshooting agent that allows data engineers to diagnose job failures using natural language queries. The agent automatically analyzes Spark History Server data, distributed executor logs, and cluster configurations to identify root causes like memory errors or data skew. It provides automated root cause analysis and PySpark code recommendations, eliminating the need to manually navigate complex logs. This feature extends the troubleshooting agent's coverage to all EMR deployment options, including EC2 and Serverless.

• Diagnose EMR on EKS failures via natural language in the console.
• Agent analyzes history server data, logs, and configs for root causes.
• Identifies memory errors, data skew, contention, and connectivity issues.
• Provides automated root cause analysis and PySpark code fixes.
• Spark troubleshooting agent now covers EC2, Serverless, and EKS.

AWS Neuron 2.31.0 introduces NKI 0.5.0 with MX FP8 scale dtype support, tensor indirection for optimized indexed access, and zero-cost layout transformation APIs. The release adds a public beta UltraServer Operator for Amazon EKS to automate Trainium UltraServer workload management. Additionally, the Neuron Compiler uses a redesigned backend by default on Trn2 and Trn3 for better performance, while the Runtime simplifies configuration with contiguous shared scratchpad support.

• NKI 0.5.0 adds MX FP8 scale dtype and tensor indirection for efficient indexed access patterns.
• UltraServer Operator for EKS automates discovery, allocation, and resource claims for Trainium workloads.
• Neuron Compiler backend redesign is now default on Trn2 and Trn3, boosting inference/training performance.
• Neuron Runtime supports contiguous shared scratchpad, removing manual page size configuration needs.

Amazon DocumentDB now supports R8g.24xlarge and R8g.48xlarge instances powered by AWS Graviton4 processors and DDR5 memory. These new nodes offer up to 1,536 GiB of memory and 192 vCPUs, enabling larger in-memory working sets and higher throughput. They are designed to handle high-concurrency transactional applications and memory-intensive operational workloads.

• R8g instances leverage Graviton4 and DDR5 for improved throughput and memory capacity.
• R8g.48xlarge provides 192 vCPUs and 1,536 GiB RAM for massive working sets.
• Suitable for high-concurrency transactions and large-scale document processing.
• Deploy via Console, CLI, or SDK by modifying existing clusters or creating new ones.

Amazon SageMaker Unified Studio Workflows now includes 19 new operators to orchestrate Amazon Bedrock, S3 Tables, S3 Vectors, AWS Glue Data Catalog, and MWAA Serverless. These additions enable users to manage Bedrock guardrails, provision S3 resources, and handle Glue catalog tasks directly within the visual workflow builder. This update eliminates the need to write custom integration code or switch between multiple AWS consoles for these specific service interactions.

• 19 new operators added for Bedrock, S3 Tables/Vectors, Glue Catalog, and MWAA Serverless
• Visual workflow creator now supports managing Bedrock guardrails and Glue catalog objects
• No custom DAG code required for provisioning/deleting S3 Tables and Vectors
• Reduces context switching by orchestrating diverse AWS services from one interface
• Available in all AWS Regions as of the publication date

AWS has extended availability of sixth-generation Intel Xeon Scalable-powered R8in, R8ib, R8idn, and R8idb instances to Asia Pacific (Tokyo) and Europe (Frankfurt, Ireland) regions. These instances feature custom sixth-gen processors and latest Nitro cards, delivering up to 43% better compute performance per vCPU than previous R6 generations. The R8in and R8idn variants offer 600 Gbps network bandwidth, the highest among enhanced networking EC2 instances, targeting big data, in-memory caches, AI/ML caching fleets, and 5G Telco applications.

• New regions for R8in/ib/idn/idb: Tokyo, Frankfurt, Ireland
• Up to 43% better compute per vCPU vs R6in/6idn
• R8in/idn provide 600 Gbps network bandwidth
• Ideal for big data, AI/ML caches, and 5G Telco workloads
• Powered by custom 6th-gen Intel Xeon and latest Nitro cards

AWS Organizations now automatically attaches service control policies (SCPs) that prevent member accounts from leaving or closing when a new organization is created via the console. This default behavior safeguards multi-account environments by blocking unintended departures from day one. Central security teams gain immediate protection without manual configuration during initial setup.

• New orgs created via console get departure-blocking SCPs automatically
• Members cannot leave or close accounts without explicit policy override
• Reduces initial security configuration effort for new AWS entrants
• Existing orgs are not retroactively affected by this change
• CloudOps teams should verify SCP inheritance in new deployments

The pglayers project publishes 53 PostgreSQL extensions as minimal Docker images built from scratch, containing only shared libraries, control files, and SQL scripts. Users can compose these onto the official postgres image using COPY --from, eliminating the need for apt-get or build tools in the final container. This approach allows practitioners to enable extensions like pgvector and PostGIS with a simple CREATE EXTENSION command after deployment.

• Eliminates compilation steps and build tools from final Docker images.
• Supports 53 extensions including pgvector, PostGIS, and pg_cron.
• Uses COPY --from to stack extensions onto official postgres base images.
• Simplifies dependency management for containerized PostgreSQL deployments.