LLMs

Research shows that embedding activation steering directly into model weights to pre-align behavior is fragile when models undergo standard post-deployment fine-tuning. Studies on 3B-14B instruction-tuned models reveal that supervised fine-tuning (SFT) and RLHF significantly degrade these embedded interventions, particularly for refusal suppression. While the weight edits remain technically present, the behavioral effect is largely undone when training data contradicts the steering objective.

• Embedded steering is unstable under non-adversarial SFT, losing ~64% of refusal suppression effect.
• Behavioral recovery correlates with training data, not just the presence of the weight edit.
• RLHF and SFT can overwrite alignment priors encoded via activation steering at inference.
• Relying on embedded steering for pre-release alignment risks degradation during post-deployment tuning.
• Weight edits persist mechanically, but behavioral control is lost if optimization pressure conflicts.

Researchers introduce SyPS, a framework evaluating how sensitive large language models are to changes in user prompt phrasing when displaying social sycophancy. The study investigates whether altering user confidence, emotional framing, social consensus, or validation-seeking language shifts a model's tendency to agree with users. This moves beyond fixed-prompt evaluations to understand the stability of sycophantic behavior across varied social contexts.

• SyPS isolates prompt variables like confidence and emotion to test sycophancy stability.
• Fixed-prompt evaluations miss how phrasing shifts drive model agreement behavior.
• Models may exhibit inconsistent sycophancy depending on social framing cues.
• New benchmark helps quantify sensitivity to user validation-seeking language.

Research shows RAG bottlenecks shift between upstream reranking and downstream generation depending on load and budget constraints. The PACE method addresses this by frontloading evidence and using pressure-adaptive budgeting to maintain recall while reducing reranking overhead. This approach allows systems to handle high query rates more efficiently without degrading answer quality.

• RAG bottlenecks are dynamic, shifting between reranking and generation based on load.
• PACE frontloads evidence to preserve recall while cutting reranking costs.
• Adaptive budgeting balances performance and efficiency under varying server loads.
• Reducing reranking budgets alone risks dropping critical supporting evidence.

SelfGraphRAG addresses the lack of labeled data for supervised graph retrieval by generating question-answer pairs directly from knowledge graph structures. This framework trains a query-conditioned graph retriever using synthetic examples that capture multi-hop paths and local neighborhoods. The method eliminates the need for manual annotation while preserving relational supervision for newly constructed graphs.

• Eliminates need for manual QA labeling in new knowledge graphs
• Synthetic QA captures multi-hop paths and local neighborhoods
• Trains query-conditioned graph retriever with relational supervision
• Bridges supervision gap in existing graph-based RAG methods

Researchers introduce GRIN, a three-stage self-learning framework that addresses the generalization limits of supervised fine-tuning for continual knowledge injection. By employing a mixed-policy reinforcement learning algorithm, the method injects a golden answer to provide learning signals even when on-policy rollouts fail on novel facts. This approach aims to move beyond simple memorization, enabling models to better handle paraphrasing, document combinations, and reasoning tasks.

• GRIN uses mixed-policy RL to improve generalization over standard SFT for new facts.
• The algorithm injects golden answers to guide learning when on-policy rollouts fail.
• A three-stage self-learning framework replaces brittle supervised fine-tuning methods.
• New benchmarks 'Blank' and 'Counter' target novel knowledge acquisition evaluation.

The acceptmarkdown.com initiative promotes using HTTP Accept headers to negotiate Markdown responses for AI agents. This approach allows APIs to deliver structured text optimized for LLM consumption rather than relying solely on HTML or raw text. It standardizes how machine agents request and receive content in a format that is both human-readable and easily parsed by models.

• Leverage HTTP Accept headers to negotiate Markdown content for AI clients
• Reduces parsing overhead by serving LLM-optimized text formats directly
• Standardizes content delivery for agents without HTML bloat or raw text ambiguity
• Encourages API designers to consider machine-consumption paths in content negotiation