ReAct (Reasoning + Acting)

A Large Language Model (LLM) is a class of machine learning models based on the Transformer architecture, trained on large text datasets via autoregressive language modeling (next-token prediction). These models have billions of parameters and can generate coherent text, answer questions, write code, translate languages, and perform many other language-cognitive tasks without task-specific fine-tuning. The term covers models such as GPT, LLaMA, Gemini, Claude, and Mistral. Most modern LLMs are instruction-tuned (SFT + RLHF) after the pre-training phase.

Chain-of-Thought (CoT) Reasoning is a prompting technique introduced by Wei et al. (2022) in which a large language model is induced to generate a series of intermediate natural-language reasoning steps as part of its output, prior to producing a final answer. The technique was shown to significantly improve LLM performance on arithmetic, commonsense, and symbolic reasoning benchmarks where standard few-shot prompting yields flat or poor results. In the original formulation (few-shot CoT), a small number of exemplar question-answer pairs are included in the prompt, where each answer consists of a chain of thought followed by the final answer. The model learns from these demonstrations to produce its own reasoning chains. A subsequent zero-shot variant (Kojima et al., 2022) showed that appending the phrase 'Let's think step by step' to a question is sufficient to elicit reasoning chains from large models without any exemplars. CoT is an emergent property: empirical results in the originating paper show that reasoning ability via CoT prompting appears only in models above a certain parameter threshold (approximately 100B parameters for the models tested in 2022), with smaller models not benefiting or performing worse. This relationship has been revisited by subsequent work as smaller models have been fine-tuned on CoT data. Key extensions include Self-Consistency CoT (Wang et al., 2022), which samples multiple reasoning paths and selects the most frequent final answer; Tree of Thoughts (Yao et al., 2023), which frames reasoning as search over a tree of intermediate thoughts; and native reasoning models such as OpenAI o1 (2024) and DeepSeek-R1 (2025), which internalize extended reasoning through reinforcement learning on process reward signals rather than relying on prompting.

In-Context Learning (ICL) is the ability of large language models to perform a new task from a handful of examples (called demonstrations or shots) given directly in the prompt, without modifying model weights. The concept was formalized by Brown et al. (2020) in the GPT-3 paper "Language Models are Few-Shot Learners" as an emergent capability of models at ≥175B-parameter scale. In ICL, the prompt contains k (input, output) pairs demonstrating the task, followed by a new query input. Conditioned on these examples, the model produces output following the demonstration pattern. The number of examples k defines variants: zero-shot (k=0, natural-language task description only), one-shot (k=1), and few-shot (k=2–32, typically 4–8). Brown et al. showed that GPT-3 175B achieves competitive performance against fine-tuned models on many NLP tasks — using few-shot prompting alone. The underlying mechanism of ICL remains an active research topic. Main hypotheses: (1) ICL implements implicit gradient descent in attention activation space (Akyürek et al. 2022, von Oswald et al. 2023); (2) models perform pattern matching over distributions of patterns seen during pretraining (Xie et al. 2022 — Bayesian inference framework); (3) ICL relies on induction heads — attention structures forming during pretraining (Olsson et al. 2022, Anthropic). Empirically, demonstration quality, ordering, and even labels significantly affect performance (Min et al. 2022). ICL is the foundation of a broader family of prompt-engineering techniques: Chain-of-Thought (Wei et al. 2022) extends ICL with reasoning chains in demonstrations, instruction tuning (FLAN, T0) strengthens zero-shot ICL, and Retrieval-Augmented Generation dynamically selects demonstrations from a knowledge base. ICL became the dominant paradigm for using LLMs from 2022–2024, before being supplemented by instruction-tuned models requiring fewer or no examples.

An AI Agent (autonomous agent) is a single, autonomous system based on an AI model — most often an LLM — that dynamically directs its own process and tool usage to accomplish a given goal. In Anthropic's definition (December 2024), an agent is a system in which an LLM independently controls its actions, in contrast to a workflow, where LLMs and tools are orchestrated through predefined code paths. An AI Agent is the concrete executable artifact of the Agentic AI paradigm — analogous to how a microservice is an instance of the microservice paradigm. A single agent has a clearly defined goal, access to a set of tools (web search, code execution, file operations, APIs, MCP), memory (in-context and optionally external), a control loop (perceive → reason → act → observe), and termination conditions (goal achievement, max_steps, escalation). The agent starts work from a command or interactive discussion with a human; once the task is clarified, it operates independently, optionally returning for further information or approval. During execution it obtains "ground truth" from the environment after each step (tool results, code execution) and may pause at checkpoints. In practice, an AI Agent is typically just an LLM using tools in a loop based on environmental feedback — the implementation is often simpler than a framework, but requires care in designing the agent-computer interface (ACI) and tool documentation. AI Agent should be distinguished from related concepts: Agentic AI is the paradigm (class of systems), an AI Agent is an instance (concrete actor); a Multi-Agent System is a collective of multiple cooperating agents; a Workflow is a predefined orchestration of LLMs without decisional autonomy.

Agentic AI denotes an architectural transition from single-turn, stateless generative models toward goal-directed systems capable of autonomous perception, planning, action, and adaptation through iterative control loops. An agentic system wraps a large language model in a runtime that gives the model access to tools (web search, code execution, APIs, file I/O), persistent memory, and feedback from prior steps. The model then decides dynamically which tools to call, in what order, and whether to loop or stop, rather than following a predefined code path. Two primary system types are commonly distinguished: (1) Workflows, in which LLMs and tools are orchestrated through predefined code paths, and (2) Agents, in which the LLM itself directs its process and tool usage dynamically. Both can be composed into multi-agent systems where specialized agents collaborate, with one acting as orchestrator and others as subagents. Key design patterns identified by Anthropic (2024) include prompt chaining, routing, parallelization, orchestrator-workers, and evaluator-optimizer loops. Andrew Ng's 2024 taxonomy describes four foundational patterns: Reflection, Tool Use, Planning, and Multi-Agent Collaboration. Formal frameworks model agentic control loops as Partially Observable Markov Decision Processes (POMDPs). The control loop is: perceive state → reason/plan → select action → execute tool → observe result → update state → repeat. Agentic systems introduce risks not present in single-turn models, including hallucination in action, prompt injection through observed content, infinite loops, reward hacking, and tool misuse.

Tool-augmented LLM is an architectural pattern in which a large language model is equipped with access to one or more external tools that it can invoke during inference by generating structured function-call or API-call outputs. The model learns when and how to call tools by producing special tokens or structured output (e.g., JSON function calls) that are intercepted by a host runtime, executed against the tool, and whose results are returned to the model as new context for continued generation. The canonical formalization appeared in the Toolformer paper (Schick et al., Meta AI, 2023), which demonstrated that LLMs can learn to self-supervise their own tool-use through API call annotation without requiring large labeled datasets. Toolformer showed that models trained this way can decide which tools to call, when, and with which arguments, and that tool use substantially improves performance on tasks requiring fresh information, arithmetic, multilingual lookup, and question answering. The pattern encompasses several mechanisms: (1) in-context tool specification, where tool interfaces are described in the system prompt or context (JSON Schema, OpenAPI, natural language); (2) function calling APIs, where the model produces structured output matched to a defined schema and the host dispatches the call; (3) ReAct-style interleaving, where the model alternates reasoning traces with tool-use observations; and (4) parallel tool calling, where the model emits multiple tool calls simultaneously to be executed concurrently. Key implementations include OpenAI function calling (GPT-4, June 2023), Anthropic tool use (Claude, 2023), Google Gemini function calling, and the Model Context Protocol (MCP, 2024) which standardizes tool server connectivity.

Multi-Agent Systems (MAS) are a paradigm in Distributed Artificial Intelligence in which multiple autonomous software entities — agents — interact within a shared environment to achieve individual or collective goals. Each agent perceives its environment through sensors or interfaces, reasons about its state, and acts through actuators or API calls. In the context of LLM-based MAS (emerging prominently from 2023 onward), agents are powered by large language models that provide the cognitive core (planning, reasoning, natural language communication), supplemented by memory modules, tool-use interfaces, and role-specific prompts. The system architecture defines how agents coordinate: coordination topologies include sequential pipelines, hierarchical orchestration (orchestrator-worker), parallel fan-out/fan-in, publish-subscribe messaging, and decentralized peer-to-peer communication. Core agent properties, as defined by Wooldridge and Jennings (1995), include autonomy, social ability, reactivity, and pro-activeness. In LLM-based systems, key components are: the agent (an LLM with a system prompt defining its role), a communication channel (natural language messages, structured function calls, or shared memory), an orchestrator or coordinator (managing task decomposition, routing, and state), tool-use interfaces (external APIs, code execution, web search), and a memory subsystem (short-term context, long-term vector storage). Prominent frameworks implementing LLM-based MAS include AutoGen (Microsoft, 2023), CAMEL (2023), MetaGPT (2023), CrewAI, and LangGraph.