Research desk
An annotated reading list. Every entry is credited to its original authors, with a note on what it changes once the idea meets a real system.
2023
The single most useful result for anyone shipping retrieval. A bigger context window does not fix relevance: if the right chunk lands in the middle of twenty, it may as well not be there. Re-rank and put the best passage last.
arXiv2022
The pattern behind most of the agents we build. The trace is not decoration: it is the only way to debug an agent that took a wrong turn three steps ago.
arXiv2020
Where prompt engineering starts. The limitation matters as much as the result: few-shot performance is sensitive to the examples you pick and to their order.
arXiv2020
The paper behind most of what we ship. The practical appeal is control: knowledge lives in documents you own, so it can be corrected, versioned and audited.
arXiv30 entries
A deploy that returns HTTP 200 has told you nothing. Three incidents in one project, each passing every status check while shipping the wrong thing.
Group-based reinforcement learning methods credit whole trajectories by final outcome, which makes it hard to see the contribution of individual steps — including valuable steps buried inside failed trajectories. The authors propose Graph-based Group Policy Optimization (GraphGPO), which aggregates all rollout trajectories into a unified state-transition graph, estimates the distance from each state to the task goal using global information encoded in the graph, and assigns credit to each edge by how much the transition reduces that distance. They report improved training efficiency and state-of-the-art performance across a range of benchmarks.
We removed a working feature because it hardcoded a 75% improvement rate that nobody had measured. It converted well. That is exactly why it had to go.
Introduces AuthorityBench, a 220,564-prompt multi-domain benchmark that isolates how citation-based authority signals influence epistemic behaviour in LLMs. It uses a fully balanced 2x2 factorial design crossing claim veracity with citation veracity across four domains, with controlled variation over 40 prompt templates, four venue prestige tiers and a country-coded author name dataset. Evaluating seven models, the authors find that citation presence, whether real or fabricated, consistently increases hallucination rates relative to a no-citation baseline, with the effect strongest when fabricated citations accompany true claims.
A benchmark for what happens when a model receives conflicting instructions from different priority levels, built from a human-authored taxonomy of 44 constraint families across generic, health, finance, retail and coding settings. Across 37 evaluated models, hierarchy compliance ranges from 98.2% to 20.5%. The authors report that strong system-over-user compliance is not a reliable proxy for user-over-tool robustness: several models hold system constraints under direct user conflict but degrade sharply when the conflicting instruction arrives inside a tool output.
An audit of what happens when an agent calls a production API that answers 200 OK with a parsable body while having silently failed. Across 721,320 parameters in 2,501 independently published OpenAPI documents, 7.5% declare an enumeration and 15.2% declare any machine-checkable constraint at all, while 40.1% of documents state at least one constraint in prose their schema does not encode. Executing 219 schema-derived perturbations against live endpoints from 27 vendors, the authors find that constraint form rather than vendor identity predicts honesty: machine-checkable constraints produced an honest error in 111 of 111 cases, prose-only constraints failed silently in 44 of 61 (p = 2e-13). Twelve models across eight families then met these endpoints: a vocabulary the description merely exemplified was missed on 88 of 88 attempts, while vocabularies written out in full were used correctly 88 to 91% of the time. Running the full agent loop, models detected the silent failure in 12% of cases, repaired it in 0%, asserted a false negative to the user in 41%, and invented a figure in 12%. Promoting the vocabulary into the schema removes the failure, from 88 of 88 to 0 of 89.
A controlled scaling study of retrieval-augmented generation paradigms, usually evaluated on different benchmarks at one corpus size. Corpus size is varied along 28 strictly nested tiers spanning roughly 450-fold while questions and a fixed bedrock of relevant and adversarial documents are held constant, under one reader model and one judging protocol. The result is a scale-dependent crossover rather than an unconditional winner. File-System Agent leads at the smallest shared tiers but costs 39 times more query tokens at the bedrock and becomes less effective as the search space grows. Around 10 million corpus tokens BM25 overtakes it and leads at every larger shared tier, with a margin approaching 20 points at full scale, and anchors the low-cost end of the Pareto frontier without any LLM-based construction. Dense retrieval remains efficient but less accurate; graph-based RAG encounters construction walls before deployment scale and its scalable variants stay below BM25 at shared tiers. The authors conclude that corpus growth increasingly favours global candidate ranking, with agentic reasoning working best after ranked discovery rather than in place of it.
A study of multi-party LLM agents, which act for a principal who briefs them and receives results while conversing in a separate channel with a counterparty whose interests may diverge, as in negotiating with a vendor, screening inbound requests or mediating between employees. The authors argue that "help whoever you are talking to" is the wrong objective and formalise the resulting loyalty problem. PrincipalBench is a 75-item multi-turn benchmark with leak probes, dual judges and an integrity-audit gate. Across 13 frontier subjects it exposes a sharp split, with one cluster at or below 20% harm and another at 53.6 to 75.3%, a split that single-turn safety evaluations do not surface: a selective cluster that declines adversarial probes while still following the principal's legitimate requests, and an over-refusing cluster that refuses broadly. A prompt-time loyalty scaffold of seven prioritised rules, open-coded from over 50 failure trajectories, holds Claude-Sonnet to 19.4% harm and all nine selective subjects at or below 20%. A per-token KL distillation recipe transfers a prompted Qwen3-32B teacher into 8B Qwen3 and Llama-3.1 students. Both mechanisms move along a common leak/over-refusal trade-off rather than crossing it.
A benchmark built from real issue reports and pull requests across popular Python repositories. A model is handed a codebase and a GitHub issue and has to produce a patch that makes the repository test suite pass, which is a far harder target than generating plausible-looking code.
Language models attend strongly to the beginning and end of a long context and weakly to the middle. The authors show accuracy degrading in a characteristic U-shape as the position of the relevant passage moves through the input, even in models explicitly built for long contexts.
An examination of whether a strong language model can stand in for a human rater on open-ended questions. The paper introduces MT-Bench and Chatbot Arena, then measures how often model judgements agree with human preference and where they systematically go wrong.
Reformulates preference learning so the reward model can be folded into the policy in closed form. The result is a single supervised objective over preference pairs, with no separate reward model and no reinforcement learning loop.
Backpropagates through a frozen 4-bit quantized base model into a small set of low-rank adapters. The approach brings fine-tuning of large models down to a single consumer GPU while holding quality close to full 16-bit tuning.
Generalises chain-of-thought into a search tree. The model proposes multiple partial solutions, evaluates them against each other, and can back out of a branch that is not working, rather than committing to one linear line of reasoning.
Agents that keep a natural-language memory stream, reflect over it to form higher-level conclusions, and plan their day from those conclusions. The paper studies what emerges when twenty-five such agents share a small sandbox world.
Instead of updating weights, the agent writes down what went wrong after a failed attempt and carries that reflection into the next attempt. The reflection is stored in natural language and used as additional context, so no gradient step is required.
A model decides for itself when to call an external API, inserts the calls into its own training data, and keeps only the ones that actually reduce its prediction loss. No hand-written tool demonstrations are needed.
Trains a model to critique and revise its own outputs against a written set of principles, then learns from the revised outputs. The aim is a helpful assistant that can explain why it declined, rather than one that simply refuses.
Argues that accuracy alone is a misleading summary of a language model, and evaluates a set of models across many scenarios and many metrics at once, including calibration, robustness, fairness and efficiency, so the trade-offs stay visible.
Interleaves verbal reasoning traces with tool actions, so the model thinks about what to do next, does it, then reasons about what came back. The reasoning trace also becomes an auditable record of why the agent took each step.
Samples several independent reasoning paths for the same question and takes the most common answer, instead of trusting a single greedy chain. The intuition is that a correct derivation can be reached many ways while a wrong one is usually reached once.
Fine-tunes language models on human demonstrations and then on human preference comparisons collected through reinforcement learning. The paper is the origin of the RLHF pipeline that produced the first widely used instruction-following assistants.
Shows that asking a model to write out intermediate reasoning steps before answering substantially improves multi-step arithmetic, commonsense and symbolic reasoning, and that the behaviour appears without any fine-tuning at sufficient model scale.
Freezes the pretrained weights and injects trainable low-rank matrices into each layer instead. The number of trainable parameters drops by several orders of magnitude, adapters are small enough to swap at runtime, and training cost falls with them.
A collection of retrieval datasets spanning very different domains and task types, used to test whether a retriever that works on one corpus still works on another without retraining. The headline finding is that sparse lexical baselines remain hard to beat out of domain.
Demonstrates that a sufficiently large language model can perform a new task from a handful of examples in the prompt, with no gradient updates. The paper established in-context learning as the default interface to a language model.
Pairs a pretrained generator with a neural retriever over an external corpus, so answers can draw on documents that were never in the training data and can be updated by changing the corpus rather than retraining the model.
Replaces term matching with a dual-encoder that embeds questions and passages into the same vector space. Relevance becomes a nearest-neighbour lookup, which lets retrieval find passages that share no vocabulary with the question.
Pre-trains a bidirectional transformer by masking tokens and predicting them from both directions, then fine-tunes the same weights on downstream tasks. The masked objective, and the idea of pre-train then fine-tune, set the template for the following years of NLP.
Introduces the transformer: a sequence model built entirely from attention, with no recurrence and no convolution. Because every position is computed in parallel, the architecture scales to far larger training runs than the recurrent models it replaced.
The architectures and pre-training results everything else stands on.
3 entries
Grounding a model in documents you actually own.
5 entries
Getting a model to show its work, and checking the work.
6 entries
Models that call tools, hold state, and finish multi-step jobs.
8 entries
Changing what a model does without retraining all of it.
4 entries
Steering outputs toward what a person would accept.
6 entries
How you know it works before a customer finds out it does not.
11 entries