Claim/evidence database
Structured Reviews
Paper reviews stored as schema-compatible records and rendered into readable review pages and slide decks.
ReAct: Synergizing Reasoning and Acting in Language Models
ReAct prompts a frozen LLM to interleave natural-language thoughts with task actions and observations, making tool use and environment interaction part of the reasoning loop.
Cognitive Architectures for Language Agents
CoALA turns language agents into a cognitive-architecture design problem by separating memory modules, internal and external actions, and a looping decision procedure.
Building Effective Agents
Anthropic argues that effective agentic systems usually start with simple LLM calls and only add workflows or autonomous agents when the task's uncertainty justifies the latency, cost, and control tradeoffs.
Chain-of-Thought Prompting Elicits Reasoning in Large Language Models
Chain-of-thought prompting shows that large language models can be induced to solve harder reasoning tasks by generating intermediate natural-language steps before the final answer.
Self-Consistency Improves Chain of Thought Reasoning in Language Models
Self-consistency improves chain-of-thought reasoning by sampling many reasoning paths and choosing the final answer that appears most consistently across them.
Tree of Thoughts: Deliberate Problem Solving with Large Language Models
Tree of Thoughts generalizes chain-of-thought prompting into explicit search over intermediate language states, letting an LLM generate, evaluate, and backtrack among multiple reasoning paths.
Reflexion: Language Agents with Verbal Reinforcement Learning
Reflexion teaches an LLM agent across trials by turning task feedback into verbal self-reflections stored in memory, without updating model weights.
Self-Refine: Iterative Refinement with Self-Feedback
Self-Refine improves a model's first answer by repeatedly asking the same LLM to critique its output and rewrite it from that feedback.
Toolformer: Language Models Can Teach Themselves to Use Tools
Toolformer teaches a language model to insert and consume API calls by sampling possible calls, executing them, and keeping only those that reduce next-token loss.
Gorilla: Large Language Model Connected with Massive APIs
Gorilla turns API use into a retrieval-aware function-calling problem: pick the right API from a large changing catalog, generate a valid call, and avoid hallucinated tools.
ToolLLM: Facilitating LLMs to Master 16000+ Real-World APIs
ToolLLM scales tool learning from API-call selection to multi-step REST API trajectories over 16,464 real-world APIs.
HuggingGPT: Solving AI Tasks with ChatGPT and its Friends in Hugging Face
HuggingGPT uses ChatGPT as a controller that plans tasks, selects Hugging Face expert models, executes subtasks, and summarizes the results.
Model Context Protocol
MCP standardizes the protocol surface between AI applications and external context, tools, prompts, and client-mediated capabilities.
MemGPT: Towards LLMs as Operating Systems
MemGPT treats the context window as RAM and external stores as disk, then gives the model functions for paging memory in and out.
Generative Agents: Interactive Simulacra of Human Behavior
Generative Agents turns an LLM into a persistent social simulator by logging every experience, retrieving relevant memories, reflecting over them, and planning from them.
Voyager: An Open-Ended Embodied Agent with Large Language Models
Voyager makes agent competence compound by saving successful behaviors as executable code skills and retrieving them for harder tasks.
LLM+P: Empowering Large Language Models with Optimal Planning Proficiency
LLM+P gets reliable plans by making the LLM translate natural language into PDDL and letting a classical planner do the search.
On the Planning Abilities of Large Language Models: A Critical Investigation
LLMs are weak autonomous planners but useful plan sketchers when an external planner or verifier owns correctness.
AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation
AutoGen turns LLM applications into programmable conversations among agents backed by models, tools, and humans.
CAMEL: Communicative Agents for Mind Exploration of Large Language Model Society
CAMEL uses role-conditioned agent conversations to turn a vague idea into multi-turn instruction-following data and task progress.
MetaGPT: Meta Programming for A Multi-Agent Collaborative Framework
MetaGPT makes multi-agent software development work more like an assembly line by encoding SOPs, role handoffs, and structured artifacts.
Improving Factuality and Reasoning in Language Models through Multiagent Debate
Multiagent Debate improves some reasoning and factuality tasks by making several model instances critique and update each other's answers before taking a final consensus.
Training Language Models to Follow Instructions with Human Feedback
InstructGPT made broad instruction following work by training GPT-3 with demonstrations, human preference rankings, a reward model, and PPO.
WebGPT: Browser-Assisted Question-Answering with Human Feedback
WebGPT trains GPT-3 to answer long-form questions by operating a text browser, collecting citations, and optimizing answer quality with human feedback.
Direct Preference Optimization
DPO turns preference optimization into a direct classification-style policy loss, removing the explicit reward-model and PPO loop from standard RLHF.
Tulu 3: Pushing Frontiers in Open Language Model Post-Training
Tulu 3 is an open post-training recipe that combines data curation, SFT, length-normalized DPO, RL with verifiable rewards, decontamination, and staged evaluation.
DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning
DeepSeek-R1 shows that large-scale reinforcement learning with verifiable rewards can elicit long-chain reasoning, then packages the result into a stronger cold-start-plus-RL model and distilled smaller models.
Making Reliable Distributed Systems in the Presence of Software Errors
Armstrong's thesis argues that reliable systems can be built from faulty software by isolating concurrent processes, letting failed workers crash, and delegating recovery to explicit supervision hierarchies.
DBOS: A DBMS-Oriented Operating System
DBOS argues that a distributed transactional DBMS should be the substrate for cluster operating-system services, so execution state becomes queryable, transactional, and highly available by construction.
Durable Execution
Durable execution records workflow progress so long-running code can resume after failures without redoing already completed steps or losing the logical trajectory.
Firecracker: Lightweight Virtualization for Serverless Applications
Firecracker makes hardware virtualization viable for dense serverless multi-tenancy by replacing general-purpose QEMU with a small Rust VMM specialized for Linux microVMs.
gVisor
gVisor is a Linux-compatible userspace application kernel that intercepts container syscalls, implements them in a separate Sentry, and sharply limits direct host-kernel exposure.
seL4: Formal Verification of an OS Kernel
seL4 proves functional correctness of a complete general-purpose microkernel from abstract specification down to C implementation, showing that a small privileged mediator can be both high-assurance and practical.
Bringing the Web Up to Speed with WebAssembly
WebAssembly defines a compact, typed, sandboxed low-level code format whose validated modules can run near native speed while receiving authority only through host-provided imports.
Capability Myths Demolished
Capability Myths Demolished argues that object-capability systems are not just ACLs in another notation: they better support least privilege, delegation, confinement, revocation, and confused-deputy avoidance.
Orca: A Distributed Serving System for Transformer-Based Generative Models
Orca reframes LLM serving as token-iteration scheduling: instead of batching full requests until every sequence finishes, it admits, removes, and schedules requests after every generated token.
Efficient Memory Management for LLM Serving with PagedAttention
PagedAttention applies virtual-memory paging to the LLM KV cache so serving systems can batch more requests with far less fragmentation and share prefixes through copy-on-write blocks.
Fast Inference from Transformers via Speculative Decoding
Speculative decoding uses a faster draft model to propose several tokens, then verifies them with the slow target model in parallel so generation accelerates without changing the target distribution.
SGLang: Efficient Execution of Structured Language Model Programs
SGLang treats multi-call prompting, agent control flow, and structured outputs as language-model programs, then accelerates them with a Python DSL plus runtime optimizations such as RadixAttention and compressed-FSM decoding.
FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness
FlashAttention makes exact attention fast by tiling the computation so the quadratic attention matrix is never materialized in slow GPU HBM.
SWE-bench: Can Language Models Resolve Real-World GitHub Issues?
SWE-bench evaluates language models on real GitHub issues by asking them to patch repository snapshots and grading whether the repo's tests pass.
WebArena: A Realistic Web Environment for Building Autonomous Agents
WebArena is a self-hosted web benchmark where agents perform long-horizon tasks across realistic sites and are graded by functional correctness rather than matching reference actions.
GAIA: A Benchmark for General AI Assistants
GAIA evaluates general AI assistants with concise, factoid real-world questions that are easy for humans but require AI systems to browse, reason, handle multimodal evidence, and use tools accurately.
tau-bench: A Benchmark for Tool-Agent-User Interaction in Real-World Domains
tau-bench evaluates whether tool-using agents can converse with simulated users, follow domain policies, update databases correctly, and do so consistently across repeated trials.
OSWorld: Benchmarking Multimodal Agents for Open-Ended Tasks in Real Computer Environments
OSWorld evaluates multimodal computer-use agents inside real desktop environments with task setup, browser/desktop actions, and execution-based grading.
AgentBench: Evaluating LLMs as Agents
AgentBench evaluates LLMs as text-based agents across eight interactive environments spanning code, games, and web tasks.
Establishing Best Practices for Building Rigorous Agentic Benchmarks
This paper turns agent benchmark quality into a checklist-driven validity problem: task validity, outcome validity, and honest benchmark reporting.
ClawBench: Can AI Agents Complete Everyday Online Tasks?
ClawBench evaluates browser agents on 153 write-heavy everyday tasks across 144 live production websites while intercepting the terminal request and retaining five synchronized evidence layers for scoring.
Reflections on Trusting Trust
Thompson shows that source review is not enough when the compiler or lower toolchain can hide and reproduce a Trojan across rebuilds.
Not what you've signed up for: Compromising Real-World LLM-Integrated Applications with Indirect Prompt Injection
Indirect prompt injection lets an attacker hide instructions in content that an LLM application later retrieves, causing the model to treat untrusted data as control input.
Universal and Transferable Adversarial Attacks on Aligned Language Models
GCG showed that adversarial suffixes can be automatically optimized on open models and transfer to other aligned LLMs, including black-box systems.
Identifying the Risks of LM Agents with an LM-Emulated Sandbox
ToolEmu uses a language model to emulate tool execution and sandbox states so agent risks can be tested before real tools are wired up.
The Rise and Potential of Large Language Model Based Agents: A Survey
Xi et al. map LLM-based agents around a broad brain-perception-action framework, then survey single-agent, multi-agent, human-agent, and agent-society applications.
A Survey on Large Language Model Based Autonomous Agents
Wang et al. organize LLM-based autonomous agents around profile, memory, planning, and action modules, then survey capability acquisition, applications, evaluation, and challenges.
Advances and Challenges in Foundation Agents
This survey reframes agents as foundation-agent systems with brain-inspired modules, self-evolution, multi-agent collaboration, and safety as coequal design axes.