Monday, July 27, 2026

Researchers introduce SCOPE, a benchmark for inducing schema graphs from raw text, addressing the bottleneck of pre-existing schemas in information extraction. The dataset normalizes 24 public sources into gold schema graphs, focusing on event types, argument roles, and inter-event links. Accompanying this is SCION, an auditable reference pipeline designed to standardize schema construction and ontology normalization from unstructured data.

• Solves the upstream bottleneck of requiring pre-defined schemas for information extraction.
• Provides a standardized benchmark using 24 normalized public sources for RE and EE tasks.
• Focuses on event extraction targets including argument roles and inter-event connections.
• SCION offers an auditable reference implementation rather than a novel algorithm.
• Enables reproducible schema induction workflows from corpus-to-schema pipelines.

Percona now includes CycloneDX 1.6 Software Bill of Materials in JSON format for all PBM 2.15.0 and PCSM 0.9.0+ release artifacts, including binaries and Docker images. This enables immediate vulnerability detection using tools like Trivy or Grype without waiting for vendor advisories. The integration supports rapid scanning of OCI images via specific CLI flags to identify embedded CVEs.

• PBM 2.15.0 and PCSM 0.9.0+ artifacts include CycloneDX 1.6 JSON SBOMs.
• Scan binaries and packages immediately using Trivy, Grype, or compatible tools.
• Use 'trivy image --sbom-sources oci' for fastest Docker image CVE detection.
• Enable day-one vulnerability visibility across your MongoDB tooling fleet.

MariaDB has declared MySQL Galera Cluster will reach end of life on September 30, 2026, halting maintenance releases for the MySQL build. New clustering features are now exclusive to MariaDB Galera Cluster, making a migration necessary for MySQL users. Percona provides a guide for migrating to Percona XtraDB Cluster as a viable alternative to staying on the deprecated MariaDB path.

• MySQL Galera Cluster support ends Sept 30, 2026, with no further binary or maintenance updates.
• MariaDB is steering new clustering innovations exclusively toward its own Galera Cluster product.
• Percona recommends migrating to Percona XtraDB Cluster to maintain multi-master replication capabilities.
• In-place migration to MariaDB is an option, but switching to Percona offers a distinct ecosystem path.

The pgEdge Vectorizer extension now generates BM25 sparse vectors directly within PostgreSQL, eliminating the need for application-layer keyword matching. It combines these sparse vectors with dense embeddings and fuses the results using Reciprocal Rank Fusion (RRF) natively in the database. This update shifts hybrid search logic from the application layer into the database engine itself.

• BM25 sparse vector generation is now handled inside PostgreSQL via pgEdge Vectorizer
• Hybrid search combines dense embeddings and BM25 keywords natively in the database
• Results are fused using Reciprocal Rank Fusion (RRF) directly within PostgreSQL
• Application-layer keyword matching logic is no longer required for hybrid search

This study evaluates baking documents into 4-bit Gemma-4-e4b weights via LoRA to enable closed-book question answering without retrieval. Across 100 training runs, the authors found that adapter capacity acts as a hard gate, but once sufficient, training data quality becomes the dominant factor for accuracy. A single curation pass focused on canonical answer spans improved accuracy by nearly 30 percentage points, outperforming architectural changes or hyperparameter tuning.

• Data quality outweighs LoRA rank, learning rate, and architecture changes in closed-book QA.
• Adapter capacity is a hard gate; insufficient size renders data interventions ineffective.
• Curation (shortening answers, dropping trivia) yields larger gains than architectural tweaks.
• Closed-book QA is viable on 4-bit models if internalized data is highly curated.

This paper introduces a framework for accurately predicting LLM inference latency on heterogeneous edge hardware. It models requests by combining static descriptors with dynamic telemetry, separating prefill and decode phases. A gated prediction model adaptively fuses these inputs to account for factors like DVFS and thermal variations. The approach facilitates faster, more reliable model selection during deployment.

• Separates prefill and decode phases for granular latency modeling.
• Fuses static config with dynamic telemetry via a gated model.
• Accounts for DVFS and thermal variations in predictions.
• Validated on Pixel mobile devices for edge deployment scenarios.
• Enables faster LLM screening based on accurate runtime estimates.

Traditional benchmarks fail to capture nuance when multiple answers are acceptable, relying instead on static ground truths. This research introduces a framework where a panel of diverse LLMs ranks anonymized responses to gauge relative preference. Aggregate inter-model agreement serves as a proxy for perceived quality, focusing on clarity and usefulness rather than binary correctness.

• Moves beyond static datasets to measure relative preference among model outputs.
• Uses a panel of diverse LLMs to rank anonymous responses for the same prompt.
• Inter-model agreement acts as a proxy for response quality and usefulness.
• Better captures nuances like clarity and completeness than absolute correctness metrics.

AWS has launched Claude Opus 5 via Amazon Bedrock, marking the latest iteration of the Opus series with enhanced capabilities for coding and autonomous agents. The model supports zero data retention and demonstrates improved accuracy in navigating large codebases and analyzing complex, document-heavy enterprise tasks. It is designed to sustain long-running agent sessions, recovering from errors to complete multi-hour objectives.

• Accessible via Amazon Bedrock with zero data retention support for secure enterprise use.
• Excels at understanding large codebases and generating production-quality code autonomously.
• Capable of running dependable agents for hours, recovering from errors to meet goals.
• Delivers significant reasoning improvements for complex analysis of long documents.

MoE²-LoRA introduces a dual-channel Routing-Conditioned Projection module to fine-tune Mixture-of-Experts models. It reuses base router activations to guide LoRA routing, avoiding the efficiency loss of uniform adapters. This approach preserves pretrained expert specialization while enabling dynamic, per-token task adaptation.

• Introduces MoE-style low-rank adaptation for LLMs, a previously underexplored area.
• Uses Routing-Conditioned Projection to reuse base router activations for LoRA routing.
• Avoids uniform adapters that ignore router priors and risk catastrophic forgetting.
• Enables dynamic expert selection rather than relying on static routing mechanisms.

Expedia Group has launched STAR, an internal platform that leverages LLMs and service telemetry to accelerate production incident investigations. The system utilizes FastAPI, Datadog, Celery, Redis, and Langfuse to structure workflows for root cause assessment while ensuring engineers remain actively involved in the process. This approach aims to reduce mean time to resolution by automating initial telemetry analysis.

• STAR integrates telemetry data with LLMs to generate root cause assessments automatically.
• The architecture relies on FastAPI, Datadog, Celery, Redis, and Langfuse for execution.
• Engineers stay in the loop, using AI outputs to guide manual investigation steps.
• Structured workflows ensure consistent analysis and support faster incident response.
• The tool is designed to handle complex service dependencies via structured AI workflows.

The AgentKVShift paper introduces a training-free method to reduce inference latency in LLM agents by reusing Key-Value (KV) caches for structured agentic memory. Unlike prior techniques designed for raw RAG passages, this approach uses probe-guided residual correction to handle metadata like summaries and tags. The method selectively recomputes only necessary tokens per retrieved memory unit, addressing the high prefill costs associated with re-encoding structured context.

• Reduces prefill latency by reusing KV states for structured agentic memory units
• Uses probe-guided residual correction to maintain accuracy without retraining
• Outperforms existing RAG-focused KV reuse methods on metadata-heavy contexts
• Eliminates full re-encoding of retrieved summaries, keywords, and tags

LeafData is an agentic system designed to replace manual, error-prone JSON configuration in modern data migration pipelines. It features a frontend chatbot that incrementally gathers user intent and performs schema-driven validation, passing validated inputs to a backend service. The backend then generates executable JSON configuration artifacts directly consumable by orchestration platforms, enabling end-to-end pipeline generation.

• Eliminates manual JSON authoring for data connections and pipeline logic
• Chatbot interface captures user intent with incremental schema validation
• Backend generates validated, executable configs for orchestration platforms
• Reduces time and errors associated with domain-specific migration setup

This paper proposes a technical definition for AI-native systems, moving beyond marketing hype by focusing on decision-level authority rather than model capability. It distinguishes between occupancy (who executes a decision) and revision authority (who can change it), organizing the latter into a ladder of self-tuning, self-rewriting, and self-architecting. A system is classified as AI-native only when an AI autonomously rewrites its own implementation code.

• Shift focus from model capability to 'revision authority' for precise AI-nativeness classification.
• Distinguish 'occupancy' (execution) from 'revision authority' (modification rights) in system design.
• AI-nativeness requires the AI to autonomously rewrite its own system implementation code.
• Ladder of authority includes self-tuning, self-rewriting, and self-architecting capabilities.
• Paper addresses ambiguity in 'AI-native' by providing a formal decision-level model.

Researchers introduce a longitudinal evaluation instrument that generates synthetic conversations from seeded fact scripts rather than extracting keys from existing chats. This approach embeds validity intervals and volatility classes into the data, ensuring gold answers are constructed mechanically and verified for answerability. The resulting corpus addresses documented label errors and contamination issues found in standard short-history benchmarks.

• Inverts benchmark pipeline: seeds facts first, then renders synthetic chat from manifests.
• Eliminates label contamination by mechanically instantiating questions from valid scripts.
• Introduces volatility classes and validity intervals missing in standard short-history tests.
• Corpus includes ~380 questions across 15 types to stress-test long-term memory retention.

T3 Code provides a lightweight web-based interface to manage and interact with various coding agents, including Codex, Claude, Cursor, and OpenCode. Users must authenticate with at least one provider via their respective CLI tools before utilizing the GUI. The tool supports immediate execution via npx or installation as a desktop application across Windows, macOS, and Arch Linux.

• Consolidates multiple AI coding agents into a single minimal web GUI interface.
• Requires pre-authentication via CLI for each supported provider (e.g., codex login).
• Accessible instantly via npx t3@latest without local installation.
• Available as desktop apps for Windows (winget), macOS (Homebrew), and Arch Linux (AUR).

FlowEvo is a training-free framework that captures successful execution traces from LLM agents and compiles them into persistent skill records. Each record pairs a callable artifact with structured guidance, subject to interface, replay, and safety checks. These skills are stored in an inference-time bank to systematically benefit future tasks rather than remaining transient.

• Eliminates need for retraining by persisting successful agent workflows at inference time
• Pairs callable code artifacts with structured guidance for reliable reuse
• Applies safety and replay checks before admitting new skills to the bank
• Targets the gap where useful procedures are lost after solving a single task

Standard RAG pipelines break chronological context into isolated snippets, losing critical temporal structure for decision-making. This paper introduces TLM, an agentic framework that uses SHAP-guided feedback to iteratively refine evidence sets. It employs a latent growth curve model over chunk embeddings to detect trends, turning points, and information gaps in long-form text.

• RAG pipelines discard temporal structure, hurting chronological decision accuracy
• TLM uses closed-loop agents to iteratively refine retrieved evidence
• SHAP-guided feedback directs the retrieval refinement process
• Latent growth curve models detect trends and gaps in text embeddings

This paper identifies Role Drift, a failure mode where compound LLM modules abandon their assigned responsibilities while maintaining overall task accuracy through hidden shortcuts. The authors propose Role Anchor, a regularization technique that constrains training by monitoring how role prompts shift next-token predictions relative to neutral prompts. This approach makes internal role violations observable and correctable during end-to-end reinforcement learning.

• End-to-end RL optimizes for output accuracy, not internal role adherence, enabling silent failure modes.
• Role Drift allows modules to use role-violating shortcuts that bypass system-level evaluation metrics.
• Role Anchor regularizer tracks prediction shifts caused by role prompts to enforce behavioral constraints.
• Using neutral prompts as a baseline provides a proxy for intended role effects during training.

A recent analysis demonstrates that automated optimization techniques now yield provable efficiency gains in critical infrastructure. Using Zstandard compression as a case study, the work shows how tool-driven refinement can surpass manual tuning efforts. This marks a shift from theoretical potential to practical, measurable results in system engineering.

• Automation is no longer experimental; it yields provable efficiency gains in core infrastructure.
• Zstd compression serves as a benchmark for how tool-driven optimization outperforms manual tuning.
• Engineering teams should prioritize investing in automated refinement pipelines for critical paths.
• Proof-of-concept results are transitioning into production-ready best practices for compression.

The Go team has released a new package for modular static analysis, allowing developers to build and share analysis passes that inspect Go source code. This framework standardizes how linters and analyzers are composed, enabling better reusability and composition of code quality tools. It provides a structured way to define analysis logic that can be run incrementally or on demand across codebases.

• Enables building reusable, composable static analysis passes for Go code.
• Standardizes the interface for linters to inspect AST and type information.
• Simplifies sharing analysis logic between projects and CI pipelines.
• Supports incremental analysis for faster feedback loops in development.
• Part of golang.org/x/tools, ensuring official maintenance and updates.

AWS has generally available the Durable Execution SDK for .NET, enabling C# developers to build resilient, long-running workflows directly within Lambda. This toolset supports multi-step applications such as payment pipelines and AI agent orchestration by automatically checkpointing progress and pausing execution for up to a year. It removes the need for custom progress tracking logic or external orchestration services.

• Use the new .NET SDK to build long-running Lambda workflows without external orchestration.
• Execution can pause for up to a year while waiting on external events or human approval.
• Automatic checkpointing eliminates the need for custom state management logic.
• Enables idiomatic C# patterns for AI agent orchestration and payment processing pipelines.

Alibaba has released OpenCodeReview, an open-source CLI tool originally used internally for tens of thousands of developers. The hybrid architecture pairs deterministic static analysis pipelines with configurable LLM agents for precise, line-level comments. It includes built-in fine-tuned rulesets for common vulnerabilities like NPE, XSS, and SQL injection, while supporting OpenAI and Anthropic compatible endpoints.

• Hybrid approach uses deterministic pipelines alongside LLM agents for balanced accuracy.
• Built-in rules cover critical issues like NPE, thread-safety, XSS, and SQL injection.
• CLI tool reads Git diffs and supports multiple LLM providers via configurable endpoints.
• Battle-tested at Alibaba scale with millions of defects identified over two years.

Amazon Managed Workflows for Apache Airflow (MWAA) now supports version 2.11.2, a maintenance update focused on security and stability. This release patches core dependencies, enhances secrets masking in logs, and resolves issues with task lifecycle management for queued tasks. It also includes UI corrections and provider package updates for S3 and CloudWatch log delivery. Users can deploy new environments or upgrade existing ones to this version.

• MWAA now supports Airflow 2.11.2 for new environments or upgrades.
• Security patches applied to core dependencies for improved stability.
• Enhanced secrets masking in logs reduces data exposure risk.
• Fixes for task lifecycle management improve queued task reliability.
• Provider packages updated for S3 and CloudWatch log delivery.

Amazon SageMaker AI now supports G7e instances in Asia Pacific (Seoul, Tokyo) and Europe (London). These instances utilize up to 8 NVIDIA RTX PRO 6000 Blackwell GPUs and 5th Gen Intel Xeon processors, offering 2.3x better performance than G6e. The expansion allows practitioners to deploy inference endpoints closer to users in Asia and Europe to reduce latency for generative AI workloads.

• G7e instances are now available in Seoul, London, and Tokyo for lower-latency AI inference.
• Hardware includes up to 8 NVIDIA RTX PRO 6000 Blackwell GPUs with 96 GB VRAM each.
• Performance is up to 2.3x faster than previous-generation G6e instances.
• Single instances provide up to 768 GB GPU memory to serve LLMs up to 70B parameters.
• Elastic Fabric Adapter networking delivers up to 1,600 Gbps bandwidth for distributed workloads.

Amazon SageMaker AI inference now supports G7 instances equipped with NVIDIA RTX PRO 4500 Blackwell Server Edition GPUs. These instances deliver up to 4.6x AI inference performance over G6, leveraging 32 GB of GPU memory per card and 5th Generation Tensor Cores. Networking throughput increases to 700 Gbps via EFA, while local NVMe storage scales up to 7.6 TB to keep large models close to compute.

• G7 instances offer 4.6x inference performance over G6 for generative AI workloads.
• 32 GB GPU memory per card reduces the need for model quantization or over-provisioning.
• 700 Gbps EFA networking provides 7x bandwidth improvement for distributed serving.
• Up to 7.6 TB local NVMe allows large models to reside near compute for lower latency.

Amazon EC2 I8ge instances are now generally available in Europe (London) and Canada (Central). Powered by Graviton4 processors and third-generation Nitro SSDs, these storage-optimized instances offer up to 120TB of local NVMe storage. They deliver up to 60% better compute performance than Graviton2-based instances and significantly lower storage I/O latency compared to the Im4gn generation.

• I8ge instances are now live in AWS Europe (London) and Canada (Central).
• Graviton4 processors provide up to 60% better compute performance than Graviton2.
• Storage I/O latency is up to 60% lower with improved variability vs Im4gn.
• Ideal for workloads requiring high throughput and low latency on local NVMe.

Amazon EKS Auto Mode and Karpenter node pools can now configure Elastic Fabric Adapter (EFA) networks and EC2 placement groups. This enables fine-grained control over instance distribution and network interfaces for high-performance distributed training and inference workloads. EFA-only interfaces are supported, which avoids consuming VPC IP addresses while optimizing network throughput.

• Enable EFA and placement groups in EKS Auto Mode and Karpenter node pools.
• Supports EFA-only interfaces to save VPC IP addresses on EFA-capable instances.
• Optimize instance placement for low-latency distributed AI training and inference.
• Configures both dynamic and static capacity node pools for EFA workloads.

bitchat is a peer-to-peer messaging application that supports dual transport mechanisms: local Bluetooth mesh for offline connectivity and the Nostr protocol for global reach. The architecture eliminates the need for accounts, phone numbers, or central servers, positioning itself as a resilient communication tool. The project emphasizes supply chain security, providing source verification hashes due to previous takedown attempts against the repository.

• Uses Bluetooth mesh for offline local communication and Nostr for global P2P sync.
• Zero infrastructure dependency: no accounts, phone numbers, or central servers required.
• Critical security feature: source builds must be verified against per-release hashes.
• Repository has faced takedown demands; mirrors may lack integrity guarantees.
• Available via App Store or self-compiled from verified source code.

OtterMind has released Chat2DB, a cross-platform SQL client that integrates an AI assistant directly into the workspace. The tool supports over 30 database engines including MySQL, PostgreSQL, Oracle, and ClickHouse via plugins. It provides standard SQL features like execution history and formatting while allowing users to connect to their own LLM models for assistance.

• Self-hosted AI integration lets you use your own LLMs for private data handling.
• Supports 30+ engines including Oracle, ClickHouse, and MongoDB via plugins.
• Runs locally on Windows, macOS, and Linux for full data sovereignty.
• Combines SQL workspace features with AI assistance in a single GUI.

CoreBunch/Instatic is an open-source, self-hosted visual CMS built entirely on Bun. It consolidates the visual editor, content management, and static site generation into a single server process, aiming to replace fragmented stacks like Webflow or WordPress. The system outputs clean static HTML and includes built-in support for users, roles, plugins, and a database layer.

• Single Bun server handles editing, content, and publishing, reducing infrastructure sprawl.
• Self-hosted alternative to Webflow/Framer with full control over data and uptime.
• Outputs clean static pages suitable for CDN distribution and low-latency access.
• Includes native user/role management and plugin architecture out of the box.