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.
arXiv22 entries
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.
4 entries
Getting a model to show its work, and checking the work.
5 entries
Models that call tools, hold state, and finish multi-step jobs.
6 entries
Changing what a model does without retraining all of it.
3 entries
Steering outputs toward what a person would accept.
3 entries
How you know it works before a customer finds out it does not.
5 entries