Guida agli Agenti AI
Home / / Ch. 16

16. Glossary and Resources

16.1 Glossary

A

AI Agent — Software system that uses an LLM to decide actions, executes them via tools, observes the result and repeats in a loop until a goal or stop. (Ch. 1, 3)

Hallucination — Plausible but false statement generated by an LLM. Caused by the fact the model predicts plausible tokens, not verified ones. (Ch. 13)

API key — Credential to authenticate calls to provider APIs (OpenAI, Anthropic, etc.). Must be kept secret.

Agentic architecture — Structural pattern of an agent: ReAct, Plan-and-Execute, multi-agent, etc. (Ch. 4)

Assistant message — Message produced by the model in a conversation, both textual and with tool calls. (Ch. 2)

B

Exponential backoff — Retry strategy that doubles the wait at each attempt (1s, 2s, 4s, 8s). Standard for rate limits. (Ch. 10)

C

Cache (prompt caching) — Mechanism that allows you to pay less for prompt parts reused across calls. (Ch. 10)

Chain-of-Thought (CoT) — Prompting technique that asks the model to reason step by step before answering. (Ch. 5)

Chunking — Splitting a document into pieces (chunks) for indexing in a vector store. Typically 200-500 words with overlap. (Ch. 7)

Claude — LLM model family from Anthropic. Main models: Opus (powerful), Sonnet (balanced), Haiku (fast/cheap).

Claude Code — Anthropic's CLI, terminal-based agent for developers. (Ch. 9)

Compaction — Automatic compression of history when approaching the context window limit. (Ch. 7)

Context window — Maximum number of tokens the model can "see" in one call. (Ch. 2)

D

Evaluation dataset (eval set) — Set of representative examples used to measure an agent's quality. (Ch. 14)

Determinism — Property of a system that, given the same input, always produces the same output. LLMs are not deterministic by default. (Ch. 12)

E

Embedding — Numeric representation (vector) of a text's meaning. Similar texts have close embeddings. (Ch. 7)

Eval / evaluation — Structured measurement of an agent on a test dataset. (Ch. 14)

Extended thinking / reasoning mode — Mode of some modern models where they do internal chain-of-thought before responding. (Ch. 2, 5)

F

Few-shot prompting — Prompting technique that includes input/output examples to guide the model. (Ch. 5)

Fine-tuning — Additional training of a model on a specific dataset to specialize it. Expensive, static (not real-time).

Function calling — See tool use. (Ch. 6)

G

GPT — LLM model family from OpenAI (Generative Pre-trained Transformer).

Gemini — LLM model family from Google.

GDPR — European regulation on personal data protection. Relevant for agents processing EU user data. (Ch. 13)

Guardrails — Constraints and validations to prevent the agent from doing unwanted things (e.g. PII filtering, toxic check).

H

Hallucination — See above.

Hook — In Claude Code (and other systems), script automatically run in response to events (e.g. after an edit). (Ch. 9)

Human-in-the-loop (HITL) — Pattern in which the human intervenes to approve or decide at critical agent steps. (Ch. 12)

I

Idempotency — Property of an operation that, repeated multiple times with the same parameters, produces the same result. Important for tools with side effects. (Ch. 12)

Inference — Execution of a pre-trained model to generate output. The "runtime" part you pay for via the API.

J

JSON mode / structured output — API mode that guarantees valid JSON output conforming to a schema. (Ch. 5, 10)

K

Knowledge cutoff — Date of the model's last training. Beyond, the model doesn't know events/facts without tools. (Ch. 2)

Knowledge base — Set of documents on which an agent does RAG.

L

LangChain / LangGraph — Python framework for building LLM applications and agents. (Ch. 11)

LLM (Large Language Model) — Large language model (Claude, GPT, Gemini, Llama, etc.). (Ch. 2)

Loop (agent loop) — The cycle perceive → reason → act → observe → repeat that defines an agent. (Ch. 3)

Lost-in-the-middle — Effect by which models "forget" information in the middle of very long prompts. (Ch. 2)

M

MCP (Model Context Protocol) — Open standard for exposing tools to compatible agents. (Ch. 6, 9)

Long-term memory — Information saved outside the context to persist across sessions. (Ch. 7)

Episodic memory — Log of the agent's past actions, for debugging and learning. (Ch. 7)

Multi-agent — Architecture with multiple cooperating agents (orchestrator-worker, debate, swarm). (Ch. 4)

N

Non-determinism — See determinism.

O

Observability — Ability to see what the system does in production (logs, traces, metrics). (Ch. 11, 12)

Orchestrator — Component coordinating an agent's subsystems (model, tools, memory). (Ch. 3, 4)

P

Pairwise comparison — Evaluation technique: instead of absolute scoring, "between A and B which is better." (Ch. 14)

Plan-and-Execute — Agentic architecture: first a complete plan, then execution. (Ch. 4)

Prompt — All the text the model sees before generating: system, user, history, tool result. (Ch. 5)

Prompt caching — See cache.

Prompt engineering — Discipline of writing effective prompts. (Ch. 5)

Prompt injection — Attack in which malicious instructions in text read by the agent hijack it. (Ch. 13)

Privilege separation — Security pattern: powerful tools separated from contexts that read untrusted external data. (Ch. 13)

R

RAG (Retrieval-Augmented Generation) — Pattern: retrieve relevant chunks from a knowledge base, include them in the prompt, generate the response. (Ch. 7)

ReAct — Reason + Act pattern: the model alternates reasoning and tool calls. (Ch. 4)

Reflexion / self-critique — Pattern in which the agent criticizes and revises its own output before delivering. (Ch. 4)

Re-ranker — Model that re-orders retrieval results to improve quality. (Ch. 7)

Role / system prompt — Base instructions that shape the model's behavior. (Ch. 2, 5)

S

Sampling — Process of picking the next token from a probability distribution. Controlled by temperature, top-p, top-k. (Ch. 2)

Sandbox — Isolated environment for executing AI-generated code without access to the host system. (Ch. 13)

SDK — Software Development Kit, provider library to access the API. (Ch. 10)

Self-consistency — Technique: call the model N times, take the most frequent answer. (Ch. 5)

Streaming — Receiving tokens as the model generates them, for better UX. (Ch. 10)

Subagent — Agent launched by another agent for delegated tasks. (Ch. 4, 9)

System prompt — See role.

T

Temperature — Sampling parameter regulating creativity vs. determinism. (Ch. 2)

Token — Unit in which models split text. ~4 characters or 0.75 English words. (Ch. 2)

Tokenizer — Component that converts text to tokens and vice versa.

Tool / function — Function the model can call. Agent = LLM + tools. (Ch. 6)

Tool call — Model's request to execute a tool with specific parameters. (Ch. 6)

Tool result — Tool's output that returns to the model. (Ch. 6)

Top-p / top-k — Sampling parameters alternative/complementary to temperature. (Ch. 2)

TTL (Time To Live) — How long data stays valid in cache. For prompt cache: ~5 minutes. (Ch. 10)

V

Vector store — DB optimized for searching similar embeddings. (Ch. 7)

W

Web search tool — Tool allowing the agent to search the web during a response.

16.2 Resources to go deeper

Official documentation

Courses and tutorials

  • DeepLearning.AI short courses (deeplearning.ai/short-courses) — Andrew Ng + providers, free, brief (1-2 hours), very practical. Start with: "ChatGPT Prompt Engineering for Developers", "Building Agentic AI Apps", "AI Agentic Design Patterns with AutoGen".
  • Anthropic Cookbook (github.com/anthropics/anthropic-cookbook) — Runnable notebooks with real patterns.
  • OpenAI Cookbook (cookbook.openai.com) — Same on OpenAI side.
  • LangChain Academy (academy.langchain.com) — Free courses on their frameworks.
  • Promptingguide.ai — Community-driven reference on prompt engineering.

Books

  • "AI Engineering" — Chip Huyen (2024). The most complete guide to the lifecycle of AI applications. Highly recommended.
  • "Hands-On Large Language Models" — Jay Alammar, Maarten Grootendorst (2024). From theory to practice, illustrated.
  • "Designing Machine Learning Systems" — Chip Huyen. Pre-LLM but still relevant for infrastructure.

Reference papers

  • "Attention Is All You Need" (Vaswani et al., 2017) — the transformer.
  • "Language Models are Few-Shot Learners" (Brown et al., 2020) — GPT-3, few-shot.
  • "ReAct: Synergizing Reasoning and Acting" (Yao et al., 2022).
  • "Reflexion" (Shinn et al., 2023).
  • "Toolformer" (Schick et al., 2023).
  • "Constitutional AI" (Bai et al., 2022) — Anthropic, safety.

All on arxiv.org with DOI or ID. Search by name.

Newsletters and blogs

  • The Batch (DeepLearning.AI) — Weekly, AI overview. (deeplearning.ai/the-batch)
  • Import AI (Jack Clark) — Weekly, long but deep.
  • Lilian Weng's blog (lilianweng.github.io) — Detailed technical articles on agents, RLHF, etc. Excellent.
  • Simon Willison's blog (simonwillison.net) — Practical, experiments with everything, writes well.
  • Anthropic blog (anthropic.com/news) — Updates on models and research.

Community

  • r/LocalLLaMA (Reddit) — Self-hosted community, open models.
  • r/MachineLearning (Reddit) — More academic.
  • Hugging Face (huggingface.co) — Open model hub, datasets, demos.
  • Discord of LangChain, LlamaIndex, various providers — Technical questions, support.
  • AI Engineer Summit (conferences.aiengineer.com) — Practical talks.

Tools and platforms to try

  • Models and APIs: Anthropic Console, OpenAI Playground, Google AI Studio, Together AI (open models hosted), Groq (very fast inference).
  • CLI agents: Claude Code, Aider, Cursor.
  • Consumer agents: ChatGPT, Claude.ai, Gemini, Perplexity.
  • Managed vector stores: Pinecone, Weaviate Cloud, Qdrant Cloud.
  • Self-hosted vector stores: Chroma, Qdrant, pgvector.
  • Observability: Langfuse (OSS), LangSmith, Helicone, Braintrust.
  • Eval: Promptfoo, DeepEval, Ragas.
  • Code execution sandbox: E2B, Modal, Daytona.

To stay updated (2026 and beyond)

The field moves fast. Strategy that works:

  1. One weekly newsletter seriously followed (not 10 half-read).
  2. One Twitter/X account or Bluesky with reference practitioners (Andrej Karpathy, Simon Willison, Hamel Husain, Eugene Yan, etc.).
  3. One hands-on per month: try a new model, framework, pattern. Build something.
  4. One paper per month (or a thread that explains it well). Not to be a researcher, but to understand the direction.

More important than "staying updated": having a list of your problems you want to solve with AI. From there, news auto-filters.

16.3 To remember at the end of everything

If of this whole guide you had to keep just five things:

  1. An agent is LLM + tools + loop + goal. Everything else is details.
  2. The prompt is code. Version it, test it, iterate it.
  3. Without evals you fly blind. Build the dataset before the code.
  4. Smaller, simpler, more observable. The most complex system is almost always the problem, not the solution.
  5. Build something. Reading gives you vocabulary, building gives you intuition.

Have a good journey.