Introduction to LLM Agents

Mon, 01 Jan 0001 00:00:00 +0000

What Is an LLM Agent?

An LLM agent is a software system built around a language model that can pursue a goal through context, state, tool use, feedback, and repeated interaction.

The model is important, but it is not the whole agent. The larger system supplies the prompt, chooses what context the model sees, exposes tools, records state, retrieves memory, validates actions, handles errors, and decides when the work is finished. When people say that an agent “remembers,” “plans,” or “uses a tool,” the precise mechanism usually belongs to this surrounding runtime, not to the model by itself.

References and Supporting Papers

Mon, 01 Jan 0001 00:00:00 +0000

This section collects papers, essays, and project references related to the themes in the book. It should be treated as a starting point for further reading, not as a fully audited citation apparatus. Some entries need source verification before a formal publication pass.

Chapter 1: Introduction to LLM Agents

Vaswani et al. (2017). Attention is All You Need. Introduced the transformer architecture foundational to modern LLMs.
Brown et al. (2020). Language Models are Few-Shot Learners (GPT-3). Demonstrates general capabilities of LLMs as zero/few-shot learners.
OpenAI (2023). Introducing Function Calling. Relevant to tool-calling interfaces and structured model outputs.

Chapter 2: Methodologies and Core Patterns

Yao et al. (2022). ReAct: Synergizing Reasoning and Acting in Language Models. Relevant to reasoning-and-acting loops.
Jiang et al. (2023). Active-Prompt: Prompt Engineering with Chain-of-Thought Reasoning. Related to prompt refinement and idea iteration.
McLuhan, M. (1964). Understanding Media: The Extensions of Man. “The medium is the message” section reference.

Chapter 3: The Architecture of Agent Behavior

Shinn et al. (2023). Reflexion: Language Agents with Verbal Reinforcement Learning. Relevant to reflection and feedback loops.
Liu et al. (2023). ToolLLM: Facilitating Tool Learning with Language Models. Basis for tool-augmented agent capabilities.
Rajani et al. (2019). Explain Yourself! Leveraging Language Models for Commonsense Reasoning. Relevant background for explanation and reasoning traces.
Microsoft (2023). AutoGen: Enabling Next gen LLM Applications. Practical implementation of agent roles and multi-agent coordination.

Chapter 4: Designing Your First Agent (On Your Phone)

OpenAI Community & Prompt Engineering Guides (2022–2023). Prompt design as an accessible interface to agent behaviors.
Qin et al. (2023). ToolBench: Towards Empowering Large Language Models with In-Context Tool Learning. Basis for simulating tools with prompts.
Shinn et al. (2023). Reflexion. Related to critique and revision patterns.

Chapter 5: The Thinking Agent

Madaan et al. (2023). Self-Refine: Iterative Refinement with Self-Feedback. The model-as-critic structure.
Liu et al. (2023). Reviewer LLMs. Citation needs verification before publication.
Bai et al. (2022). Training a Helpful and Harmless Assistant with RLHF. Introduces reward feedback loops and output alignment strategies.

Chapter 6: Architecting Agent-Based Systems

Wu et al. (2023). AgentVerse: Facilitating Multi-Agent Collaboration. Details centralized vs decentralized agent architectures.
Zhang et al. (2023). CAMEL: Communicative Agents for Mind Exploration of Large Scale Language Model Society. Supports multi-agent dialogue frameworks.
Zeng et al. (2022). A Survey of Multi-Agent Systems. Gives academic grounding to MAS coordination techniques.
Patil et al. (2023). Gorilla: Large Language Model Connected with Massive APIs. Relevant to tool and API use.

Chapter 7: A New Way of Working With Technology

Schick et al. (2023). Toolformer: Language Models Can Teach Themselves to Use Tools. arXiv:2302.04761
→ Relevant to tool-use interfaces.
Paranjape et al. (2023). DSPy: Compiling Declarative Language Model Programs. arXiv:2310.01848
→ Relevant to declarative language-model programs.
Yao et al. (2022). ReAct: Synergizing Reasoning and Acting in Language Models. arXiv:2210.03629
→ Relevant to reasoning-and-acting loops.
Wu et al. (2023). AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation Frameworks. arXiv:2309.11455
→ Demonstrates modular, conversation-first interactions among agents.
Shinn et al. (2023). Reflexion: Language Agents with Verbal Reinforcement Learning. arXiv:2303.11366
→ Relevant to reflection and revision patterns.

Chapter 8: Companion Agents

Shinn et al. (2023). Reflexion: Language Agents with Verbal Reinforcement Learning.
→ Related to reflection loops; does not by itself establish companion-agent memory.
Liu et al. (2023). CAMEL: Communicative Agents for Mind Exploration of Large Scale Language Model Society.
→ Relevant to role assignment in multi-agent simulations.
Paranjape et al. (2023). DSPy.
→ Relevant to modular language-model program design.
Wu et al. (2023). AutoGen.
→ Foundation for prompt-based team construction and multi-role behavior.
Yao et al. (2024). MARS: A Multi-Agent Framework Incorporating Socratic Guidance for Automated Prompt Optimization.
→ Citation needs verification before publication.

Chapter 9: Designing Your Digital Lens

Yao et al. (2022). ReAct.
→ Relevant to task-contextual reasoning.
Paranjape et al. (2023). DSPy.
→ Relevant to declarative interfaces; filtering claim needs verification.
Wu et al. (2023). AutoGen.
→ Conversation-driven interface for lens behavior.
Schick et al. (2023). Toolformer.
→ Relevant to tool-use learning; content-filtering application is an extrapolation.
Shinn et al. (2023). Reflexion.
→ Relevant to feedback-driven revision loops.
Yao et al. (2024). MCTS-RAG: Enhance Retrieval-Augmented Generation with Monte Carlo Tree Search.
→ Retrieval/planning relevance needs verification before publication.

The following references are candidates for Chapter 10’s discussion of freestyle cognition, research automation, and AI-assisted prototyping. Verify each title, author list, date, and relevance before final publication.

Agent Architectures on Programmer.ie: Modern AI programming