Friday, October 02, 2026

This paper introduces BudgetSchemaBench, a diagnostic framework for optimizing database schema injection into LLM context windows. Using an 80-database catalog, the authors sweep four schema-context budgets to compare representation strategies while maintaining fixed table ranking. The benchmark mechanically derives relevance labels from gold SQL, eliminating the need for human or LLM-generated ground truth and including a namespace check to prevent cross-database result leakage.

• Schema serialization costs force trade-offs between table coverage and detail before context limits are hit.
• Relevance labels are derived mechanically from gold SQL, removing human/LLM annotation bias.
• Namespace checks ensure queries return correct results from the intended source database only.
• Evaluation sweeps four context budgets against three schema representations with fixed retrieval ranking.

Pgpool-II has issued maintenance releases across five versions, addressing critical security vulnerabilities. CVE-2026-92867 allows an attacker to write arbitrary 32-bit values to memory via malformed watchdog messages during failover. Additionally, certificate authentication fails to properly handle NUL bytes in client X.509 certificate Common Name fields.

• Apply updates immediately to fix CVE-2026-92867 memory corruption risk.
• Update Pgpool-II to mitigate NUL byte handling in client certificates.
• Affected versions: 4.7.3, 4.6.8, 4.5.13, 4.4.18, and 4.3.21.
• Monitor failover logs for potential watchdog message injection attempts.

Tomas Vondra clarifies that recent Postgres 19 feature reverts were not caused by AI-discovered bugs, contrary to circulating reports. The delays stem from invasive fix requirements late in the development cycle, pushing the release back by approximately one month. This correction aims to address misconceptions about the specific technical drivers behind the schedule slip.

• Postgres 19 release is delayed by ~1 month due to late-cycle reverts
• Vondra rejects claims that AI tooling directly caused the patch reversals
• Reverted features required invasive fixes incompatible with current cycle
• Practitioners should monitor for updated release candidate timelines
• Development focus shifts to stabilizing remaining core components

Amazon Redshift has added a DEBUG permission that allows specific identities to view unredacted secure logging records across multiple data warehouses. This change addresses the visibility gap created by Federated Permissions, which previously redacted sensitive values in system tables to protect data owners' information. Data owners can now grant auditors and administrators the necessary access to troubleshoot and audit queries without compromising data security.

• DEBUG permission enables unredacted log access for authorized troubleshooters.
• Logging remains redacted by default to protect FGAC-protected data.
• Permissions apply automatically across all warehouses in the AWS account.
• Simplifies auditing of rewritten query text and error messages.

Percona has published guidance on optimizing ClusterSync for MongoDB, which replicates data from source clusters like Atlas to targets in two phases. The process begins by establishing a consistent starting point and cloning collections and indexes while simultaneously capturing changes via MongoDB change streams. Once the initial copy finishes, the tool transitions to replicating ongoing changes.

• ClusterSync uses a two-stage replication model for MongoDB data synchronization.
• Initial phase clones collections and indexes while capturing change streams.
• Post-clone phase handles ongoing replication of source database changes.
• Source clusters can include on-prem MongoDB or MongoDB Atlas deployments.

CAST optimizes speculative LLM inference by organizing multiple high-scoring token candidates from block drafters into a verification tree. Instead of discarding non-top chains, it verifies them in a single target model pass, leveraging already-computed drafts. The method dynamically adjusts tree width by adding candidates only when the expected performance gain exceeds the computational cost.

• Reuses existing block drafter scores by verifying multiple candidates instead of just the top one.
• Reduces target model passes by packing candidates into a single verification tree structure.
• Requires no changes to target model weights, drafter architecture, or decoding rules.
• Dynamically scales tree width based on cost-benefit analysis of additional candidates.

Researchers evaluated PRM-Pruned Fragment Grafting (PPFG) to mitigate diversity collapse in parallel chain-of-thought reasoning. Testing on Qwen2.5-7B-Instruct with Math-Shepherd across the full MATH500 dataset, the method failed to outperform independent decoding. The findings indicate that PPFG alone is insufficient for performance gains, suggesting prior successes relied on additional compensating mechanisms.

• PPFG extracts high-PRM prefixes from pruned chains to graft into decoding siblings.
• No statistical improvement observed on Qwen2.5-7B-Instruct with Math-Shepherd on MATH500.
• Stagnation- and random-targeting variants both showed inert results.
• Prior fragment-grafting gains likely required extra ingredients beyond simple grafting.
• Cross-trajectory step-level transfer is not automatically cost-effective without tuning.

Reading verdicts from the first token's logits is a common cheap evaluation method, but it systematically inflates position bias by treating initial tokens as final decisions. For several Qwen3 models, 12% to 49% of pairs fail to lead with a verdict, causing forced reads to incorrectly favor the first response shown. This distortion acts as an upper bound on reported bias metrics, misleading researchers about actual judge behavior.

• First-token logit reading inflates position bias metrics, acting as an upper bound.
• Qwen3 judges skip verdict tokens in 12-49% of cases, skewing forced-read results.
• Forced reads incorrectly select the first response when no verdict token is present.
• Llama-3.1-8B and Phi-3.5-mini show minimal skipping (<3%), reducing this error.
• Evaluation harnesses using constrained decoding may produce misleading bias figures.

A study on role-specialized QA pipelines reveals that passing rationales from a reasoner to a verifier yields minimal gains in answer accuracy compared to providing no rationale at all. Using DeepSeek models on multi-hop datasets, the researchers found that corrupted rationales significantly shift a verifier's support judgments by up to 22%, while harmless paraphrases cause negligible changes. This suggests rationales may create a new failure surface rather than reliably improving answer quality.

• Faithful rationales provide almost no accuracy boost over no rationale in role-specialized QA pipelines.
• Corrupted rationales strongly distort verifier support judgments, shifting them by 10-22%.
• Harmless paraphrases of rationales have negligible impact (0-2.5%) on support assessments.
• Designers should view rationales as a potential failure surface, not a guaranteed quality signal.

Research demonstrates that fine-tuning with minimal harmful examples can strip aligned LLMs of their refusal capabilities. However, safety behaviors remain linearly separable from benign ones even after the attack. By identifying the specific depth where refusal localizes, defenders can patch compromised models by restoring clean hidden states or freezing layers up to that transition point.

• Few-shot harmful fine-tuning effectively disables model refusal across multiple model families.
• Safety and benign prompts remain linearly separable in hidden states post-attack.
• Patching clean hidden states at the transition depth restores refusal behavior reproducibly.
• Freezing layers up to the identified safety depth offers a robust defense against adaptation.
• Localizing safety to specific layers enables targeted recovery without full retraining.

Cloudflare has introduced Clef, a new open-weight decision model designed to optimize routing and infrastructure choices in real time. Alongside the model, they have released a dedicated platform for reinforcement learning (RL) fine-tuning to improve these decision-making capabilities. This release aims to provide developers with transparent, customizable tools for managing complex network and compute decisions.

• Clef is an open-weight model focused on decision-making rather than generative text.
• New RL fine-tuning platform allows practitioners to customize model behavior.
• Enables real-time optimization for routing and infrastructure resource allocation.
• Open weights facilitate transparency and integration into existing Cloudflare stacks.

This study evaluates nine NER systems across classical, encoder, and generative paradigms for on-device deployment, ranging from 13M to 8B parameters. It moves beyond standard leaderboard metrics by jointly assessing accuracy, latency, and output validity without requiring human-annotated gold labels. The authors utilize a silver-grounded corpus derived from RSS-News to enable scalable evaluation of model reliability and confidence.

• Evaluates spaCy, GLiNER, and local LLMs (Qwen3, DeepSeek-R1) for on-device NER.
• Prioritizes latency and output validity alongside accuracy for deployability.
• Uses silver-grounded annotation to scale evaluation without human labeling.
• Covers parameter sizes from 13M to 8B across three distinct model paradigms.

Researchers audited the GooseReason-0.7M dataset to check if models learn synthetic distractor patterns instead of reasoning. A classifier using only surface statistics achieved an AUROC of 0.562, proving the asymmetry between real correct answers and synthetic wrong ones is detectable. Code-based distractors were particularly easy to identify, performing below chance, suggesting models might exploit these artifacts rather than learning genuine reasoning.

• Synthetic distractors in RLVR corpora are statistically distinguishable from human prose using surface features.
• Models risk learning provenance shortcuts instead of reasoning if data asymmetry is not addressed.
• Code distractors are easier to flag than natural language ones, indicating domain-specific artifact risks.
• Data pipelines should audit for synthetic artifacts to ensure models learn genuine capabilities.

Praxa is a new agent harness that explicitly separates proposal, authority, dispatch, verified effect, and promotion states through deterministic admission and brokered execution. It utilizes external read-back and reconciliation to ensure actions are verified before serving promotion. The system reports evidence from a local audit passing over 1,000 tests and an initial pilot on the Terminal-Bench dataset.

• Explicit state separation prevents conflating agent proposals with verified external effects.
• Deterministic admission and brokered execution enforce strict governance boundaries.
• External read-back and reconciliation steps validate actions before promotion.
• Early evidence includes 1,027 passing unit tests and 89 Workerd tests.
• Initial pilot conducted on Terminal-Bench Core 0.1.1 across 12 curated tasks.

This paper analyzes the distribution of memory usage in long-horizon language agents, revealing that retrieval patterns often follow a heavy-tailed distribution. While core states are retrieved frequently, rare states accumulate in a long tail where prediction errors grow. The study contrasts random-walk policies, which show log-normal artifacts, with semantic LLM policies that exhibit strong truncated power-law core-tail traces, suggesting current evaluation metrics miss critical structural inefficiencies.

• Memory concentration creates a long tail where rare state prediction errors accumulate.
• Semantic LLM policies show stronger heavy-tail traces than random-walk approaches.
• Standard metrics like task success miss structural memory distribution issues.
• Current systems assume uniform memory access, which contradicts observed traces.
• Understanding tail behavior is key to optimizing long-horizon agent reliability.

A new paper introduces FedCausalCompose, a framework that enables modular LLM agents to distinguish correlation from causation during cross-module planning. Standard observational world models fail to identify valid intervention paths, such as whether payment actually authorizes shipment or if inventory mediates the effect. By using local actions as intervention-response evidence, this approach resolves irreducible errors found in traditional observational traces.

• Observational traces fail to distinguish valid causal links from spurious correlations in modular systems.
• FedCausalCompose uses local intervention evidence to map cross-module dependencies accurately.
• Prevents irreducible planning errors when actions in one module gate transitions in another.
• Shifts agent design from passive pattern matching to active causal reasoning.
• Essential for complex workflows like order, payment, and inventory orchestration.

This paper benchmarks off-the-shelf Qwen3 models (0.6-8B) on four agent harness microtasks, including command approval and memory writing, against practitioner-defined thresholds. The study reveals an eligibility gap where even the best-performing FP16 greedy configurations fail to clear confidence bounds anchored to cheap non-LLM baselines. It further investigates whether quantization mitigates these failures or exacerbates them in real-world agent workflows.

• SLMs struggle to meet strict confidence thresholds for agent microtasks without tuning.
• Benchmark uses fixed prompts and auto-metrics anchored to non-LLM baselines.
• Quantization effects on eligibility gaps are explicitly tested in this study.
• 0.6-8B Qwen3 models show significant gaps in command approval and memory tasks.

This paper formalizes budget conservation for AI agents delegating work across failure-prone workers, addressing overspend risks from lost replies, timeouts, and message duplication. It proposes using quantized resource vectors as exclusive escrow credits that move through a delegation DAG. Before dispatch, branches convert credit into operation reservations bound to lineage, epoch, and idempotency keys to ensure precise cost tracking despite network instability.

• Prevents budget overspend in multi-agent systems when replies are lost or duplicated.
• Uses exclusive escrow credits to enforce strict resource allocation via delegation DAGs.
• Binds operations to lineage and idempotency keys for fault-tolerant accounting.
• Addresses edge cases like timeout effects and message repetition in distributed AI.

The Linux kernel has been updated to address several newly discovered security vulnerabilities. These fixes are critical for maintaining system integrity across production environments. Operators should prioritize applying these patches to their infrastructure.

• Apply kernel updates immediately to mitigate identified security risks.
• Review release notes for specific CVEs affecting your stack.
• Schedule maintenance windows for affected production nodes.
• Verify patch status across all fleet instances post-deployment.

Devrim Gündüz has integrated Rust-based PostgreSQL extensions into the official RPM distribution, starting with pgrx and postgresql_anonymizer. The update includes specific packaging guidelines for maintaining these Rust packages within the repository structure. Current support covers existing distributions, with plans to extend compatibility to RHEL 9.9 and 10.3 by November.

• Rust extensions are now officially packaged, simplifying deployment for RHEL-based systems.
• pgrx and postgresql_anonymizer are the initial supported Rust packages in the repo.
• Packaging guidelines are available to ensure consistent builds for future Rust additions.
• RHEL 9.9 and 10.3 support is targeted for inclusion in the November release cycle.

Amazon Redshift now allows direct querying of S3 data lake tables located in different AWS Regions, eliminating the need for data replication. Enhanced VPC routing ensures that query traffic between Redshift and S3 remains within the customer's VPC, addressing security and compliance requirements. This capability is powered by the integrated data lake query engine running on both provisioned and serverless cluster compute.

• Query cross-Region S3 tables directly without copying or replicating data first.
• VPC routing keeps data lake query traffic within the customer's private network.
• Supports both provisioned and serverless Redshift cluster configurations.
• Enables global analytics and consolidated reporting across distributed regions.

AWS has launched a preview of the Well-Architected Agent, an AI-driven service that supersedes Trusted Advisor and the Well-Architected Tool. It correlates metrics and application topology against best practices to deliver prioritized recommendations based on business goals. The agent also analyzes Terraform, CDK, and CloudFormation templates to generate automation-ready fixes.

• Replaces legacy Trusted Advisor and Well-Architected Tool with an AI agent.
• Prioritizes recommendations by business impact and implementation effort.
• Supports IaC analysis across Terraform, CDK, and CloudFormation.
• Generates automation-ready fixes for identified architectural issues.
• Correlates metrics with topology for contextualized optimization advice.

AWS Glue Data Catalog now natively supports table optimization, statistics generation, and crawler discovery for Apache Iceberg Version 3 tables. Users can auto-maintain tables using binpack, sort, or z-order compaction strategies to enhance query performance and reduce storage costs by cleaning up expired snapshots. The update also includes NDV statistics for better query planning and support for V3-specific data types like variant, geospatial, and nanosecond timestamps.

• Glue crawlers can now discover and register Iceberg V3 tables stored in S3 automatically.
• Support for binpack, sort, and z-order compaction strategies to optimize V3 table performance.
• Generate NDV statistics to help analytics engines plan queries more efficiently.
• Native support for Iceberg V3 data types including variant, geospatial, and nanosecond precision.
• Automated maintenance helps remove orphan files and expired snapshots to lower storage costs.

Amazon DynamoDB adds filtered export capabilities, allowing users to export specific subsets of table data to Amazon S3. This feature leverages key condition, filter, and projection expressions to select exactly which items and attributes are included in the output. The resulting dataset is optimized for offline analytics, granular recovery, or cross-account data movement.

• Use key condition, filter, and projection expressions to precisely control exported data subsets
• Reduces S3 storage and processing costs by exporting only relevant items and attributes
• Enables granular data recovery and efficient cross-account data migration slices
• Supports analytics use cases by generating focused datasets without full table dumps

Amazon EMR Serverless has increased its per-job shuffle storage limit from 200 GB to 1 TB. This change allows data engineers to run production-scale Apache Spark jobs involving large joins, aggregations, and sorts without hitting storage constraints. The update removes a key bottleneck for migrating enterprise workloads that process massive datasets in a serverless environment.

• Shuffle storage limit for EMR Serverless jobs increased to 1 TB from 200 GB
• Enables production Spark workloads with large joins, aggregations, and sorting
• Removes storage constraints previously blocking terabyte-scale dataset processing
• Simplifies migration of enterprise big data workloads to serverless infrastructure

AWS Glue now supports system-managed materialized views for Apache Iceberg, restricting write access to the engine itself. This prevents users with S3 or catalog write permissions from altering precomputed results, ensuring data integrity. Users define the view via SQL and optionally schedule refreshes, with Glue handling the storage as standard Iceberg tables in S3.

• Only AWS Glue can write to the materialized view, blocking external S3 or catalog writes.
• Precomputed query results remain immutable, preventing accidental or malicious data corruption.
• Define views with SQL and optional refresh schedules for automated maintenance.
• Results are stored as standard Apache Iceberg tables in Amazon S3 for compatibility.

NawfalMotii79/PLFM_RADAR introduces AERIS-10, a fully open-source, low-cost 10.5 GHz phased array radar system using Pulse Linear Frequency Modulation. The project offers modular hardware and software for beamforming, pulse compression, and Doppler processing, available in 3km and 20km range variants. It targets researchers, drone developers, and SDR enthusiasts seeking to experiment with radar technology.

• Democratizes phased array radar via open-source hardware and software stack.
• Supports key signal processing: beamforming, pulse compression, Doppler.
• Available in two range variants (3km/20km) for diverse experimental needs.
• Targeted at drone devs and researchers for rapid prototyping and learning.

K-Dense BYOK is an open-source AI research assistant designed to run locally on a researcher's machine, allowing users to supply their own model keys while the tool handles the workflow scaffolding. Unlike general chat agents, it enforces scientific rigor through written procedures, guided templates, and a catalog of data locations. Crucially, it maintains a hash-chained lab notebook to ensure an immutable, verifiable audit trail of all research activities and results.

• Researchers retain full control by running the assistant locally and supplying their own model access keys.
• Each project is stored as a standard folder, ensuring long-term readability of data and code without the app.
• Hash-chained lab notebooks provide an immutable audit trail, distinct from standard chat assistant logs.
• Built-in scientific scaffolding includes procedural libraries and guided workflow templates for structured research.
• Open-source design ensures transparency and avoids vendor lock-in for critical research metadata.