A Beginner’s Guide to AI Fundamentals and Connections

Start with the foundations

• Supervised Learning
• Unsupervised Learning: When There Are No Human Labels, Structure Comes from Assumptions
• Reinforcement Learning: Learning Decision Policies from Delayed Feedback
• Neural Network
• Gradient Descent: How Direction, Step Size, and Noise Together Shape Learning

Understand language models

• Tokens and Tokenization: The Discrete Language That Models Actually Read and Write
• Embedding
• Attention Mechanism
• Transformer
• Large Language Model (LLM)

Build with AI

• Prompt Engineering
• RAG Retrieval-Augmented Generation
• Retrieval and Semantic Search
• Tool Calling / Function Calling
• AI Agent

All concept explanations

122 reading pages. Each page links to its available translation.

• Advanced RAG: Making Retrieval a Diagnosable, Iterative Evidence Process

  From query rewriting, hybrid retrieval, reranking, multi-hop, corrective retrieval, and answer citation, understand when to upgrade basic RAG.

• Adversarial Robustness: Seeking the worst case within an explicit perturbation set, not claiming the model is “attack-proof”

  From decision boundaries, FGSM/PGD, robust optimization and certified radius, to adaptive attacks, out-of-distribution transformations and system-level loss control, understand the applicable domain of guarantees.

• AI Agent

  From “one question, one answer” to “give it a goal and it gets the whole thing done on its own”

• Agent Frameworks: Abstract the Run Loop, but Don't Outsource Correctness and Control

  From model adaptation, tool registration, state graphs, persistence, and tracing, to abstraction leaks, version migration, and escape hatches, determine when a framework is worth adopting.

• Agent Identity, Authorization, and Secrets Management

  The model states intent; the controlled execution layer proves who can perform which action on what.

• Agent Loop

  Turn a single answer into an observable, verifiable, and stoppable state machine

• Agent Memory: Writable, Findable, and Correctable External State

  Separate conversational context, working state, episodic records, and long-term facts; understand writing, integration, retrieval, forgetting, conflict, and privacy governance.

• Agent Skills: Packaging repetitive tasks into discoverable, verifiable, and governable capability packages

  From trigger descriptions, progressive disclosure, scripts and assets, to selection confusion, permissions, versions, and regressions, understand the boundaries between skills, prompts, tools, and workflows.

• AI Alignment

  Making model behavior align with human intentions and values

• Attention Mechanism

  When processing each word, let the model decide for itself which words in the sentence to 'look at'.

• Audio Generation: Modeling Temporal Structure across Waveforms, Spectrograms, and Discrete Codecs

  From sampling rate, neural codecs, and multi-codebook tokens to autoregressive/diffusion generation, text and melody conditioning, long-range musical structure, and subjective evaluation.

• Backpropagation: Efficiently Assigning the Responsibility of One Result Back to All Parameters

  Starting from computational graphs, local derivatives, and upstream gradients, work through one complete backward traversal by hand, and understand branch accumulation, vector–Jacobian products, activation caching, and gradient checking.

• Batch Normalization: Stabilizing Channel Scale with Batch Statistics

  From the statistical axes of convolutional tensors, training/inference dual paths, and running means to synchronized BatchNorm, understand why it accelerates many visual networks and why it fails with small batches, domain shift, and deployment fusion.

• Bias and Fairness: First Choose the Relationship to Protect, Then Compute Group Differences

  Use the same hiring example to understand representational bias, label bias, proxy variables, demographic parity, equal opportunity, calibration, and the boundaries where they cannot all be satisfied simultaneously.

• Document Chunking: The Evidence Unit That Determines Retrieval Systems

  Understand fixed-length, structural, semantic, and parent-child chunking; handle overlap, context loss, tables, code, and embedding budgets.

• Citation and Evidence Alignment: Connecting Every Verifiable Claim to the Minimal Sufficient Source Text

  From atomic claims, stable anchors, and entailment judgment to citation correctness, completeness, and source quality: build a truly verifiable answer.

• CLIP: Using image–text contrast to align two modalities into the same space

  From dual encoders, a normalized similarity matrix, and symmetric cross-entropy, to zero-shot classification, retrieval, compositional relations, and bias boundaries.

• Clustering: Similarity, Cluster Shape, and Use Case Jointly Determine Grouping

  From manual K-means assignment–update computation to hierarchical clustering, DBSCAN, mixture models, choosing k, stability, and business interpretation.

• Convolutional Neural Network (CNN): Letting the Same Local Detector Scan Across Space

  From discrete convolution, weight sharing, and output shapes, to receptive fields, sampling aliasing, translation equivariance, and modern visual backbones.

• Code Execution and Sandboxing: Let the Model Compute, but Don’t Hand Over the Host to It

  Understand where the generate–execute–observe loop’s capabilities come from, and the isolation boundary made up of processes, files, network, resources, credentials, and human authorization.

• Code Generation / AI Coding

  Let models write code, from completing a line to implementing an entire feature.

• AI Coding Tools: The Evidence Closed Loop from Repository Understanding to Patch Verification

  From search, call-chain localization, and minimal edits to testing, diff review, working tree protection, and safe rollback, understand why repository-level agents are more than code generation.

• Computer-Use Agent: Closing the Loop Between Observation, Action, and State Verification

  From action grounding in screenshots, the DOM, and the accessibility tree, to focus, idempotency, permissions, and recovery, understand why 'knowing how to click buttons' is far from reliably completing tasks.

• Constitutional AI: Using Explicit Principles to Guide Critique, Revision, and Preference Learning

  From principle text, contextual interpretation, and conflict priority to AI feedback training, understand how to reduce per-example human labels and why principle selection remains a governance issue.

• Constrained Decoding: Using Automata to Set Illegal Token Probabilities to Zero

  From JSON Schema, grammar states, and tokenizer boundaries to dead ends, complexity, streaming output, and semantic validation.

• AI Content Detection and Provenance: Distinguishing Statistical Guesses, Watermark Signals, and Signature Origins

  From base rates, ROC, and calibration, to distribution drift in model fingerprints, robust watermarking, C2PA-style signature manifests, chained edits, and “no signal does not equal human creation.”

• Context Compaction: Preserving Decision-Relevant Information Within a Token Budget

  Understand the lossy nature of truncation, summarization, extraction, retrieval, and prompt compression, and design must-not-drop constraints, source tracking, and compaction regression.

• Context Engineering: Designing the Information the Model Can Actually See at This Moment

  Treat prompts, retrieved evidence, tool results, memory, and historical messages as an information system under a limited budget, rather than cramming all the text into the window.

• Contrastive Learning: Using Positive and Negative Pairs to Shape Representation Space

  From InfoNCE, temperature, and gradient direction, to augmentation invariance, large batches, false negative samples, representation collapse, and transfer validation.

• Chain of Thought (CoT)

  Have the model write out step-by-step reasoning before giving an answer—more accurate on complex problems

• Data Drift and Continuous Monitoring: When Distribution Change Actually Harms the System

  From P(x), P(y), and P(y|x) to PSI, delayed labels, proxy metrics, slice alerts, and safe response.

• Data Poisoning: How Attackers Use a Small Amount of Training Signal to Change a Model's Specific Behavior

  Distinguish availability disruption, targeted misclassification, clean-label attacks, and backdoors, and trace from poisoning rates and gradient influence to data lineage, training-time detection, and trigger evaluation.

• Decision Trees and Ensemble Methods: Combining Nonlinear Decisions with Split Rules

  From impurity, information gain, and pruning to random forests and gradient boosting, understand the advantages of tree models for tabular data and the risk of leakage.

• AI Deployment: Turning Offline Capability into a Capacity-Measurable, Canary-Releasable, and Rollbackable Service

  From runtime location, queuing and batching, to version release, idempotent side effects, degradation, and incident response.

• Diffusion Models

  Learn “to denoise from a blob of noise step by step” and “develop” the image.

• Distributed Training: Split along the Four Axes of Data, Tensor, Pipeline, and State

  From global batch and all-reduce, to tensor parallelism, pipeline bubble, ZeRO/FSDP, 3D parallelism, and fault checkpointing.

• Embedding

  Turn text into vectors, making “similar meaning” become “close in distance”

• LLM Application Evaluation: Measuring Whether the Entire System Completes Real Tasks

  Break business goals into observable attributes and locate failures caused by retrieval, generation, tools, and processes.

• Fine-tuning

  Continue training on a pre-trained “generalist” to turn it into a task-specific “specialist”

• Flow Matching: Directly Learning the Velocity Field That Continuously Transports Noise to Data

  From probability paths, conditional and marginal velocities, to straight-line paths, ODE sampling, numerical error, coupling design, and the relationship with diffusion/continuous flows.

• Generative Adversarial Network (GAN): Letting the Generator Learn the Data Distribution Against a Dynamic Discriminator

  From minimax games, optimal discriminators, and JS divergence, to non-saturating loss, mode collapse, training oscillation, Wasserstein distance, and evaluation boundaries.

• AI Governance: Turning Risk Judgments into an Accountable, Evidence-Preserving, Stoppable System

  From system inventory, risk classification, and responsibility matrix to go-live gate, change approval, incident response, and decommissioning, understand how governance translates principles into lifecycle evidence.

• Gradient Descent: How Direction, Step Size, and Noise Together Shape Learning

  Starting from one-dimensional slopes and directional derivatives, work through one update by hand, then see why learning rate, curvature, mini-batch, momentum, and Adam change the training trajectory.

• AI Guardrails: Using Defense-in-Depth Controls to Limit the Blast Radius of Probabilistic Systems

  From five layers of control—input, context, output, tool, and runtime—to threshold cost, policy composition, and fault injection, understand what AI Guardrails can and cannot guarantee.

• Hallucination

  Fluent, confident, but fabricated — why this is structural, not 'just make it bigger'.

• Human-in-the-loop: put scarce human judgment at the points where it can change risk

  From risk stratification, escalation thresholds, review interfaces, and queue capacity to automation bias and feedback sampling, design a human-machine loop that truly reduces harm.

• Generative Image Editing: Changing target attributes while proving the rest is preserved

  From mask inpainting, img2img noise strength, attention control, and instruction editing, to inversion, locality, identity consistency, reversibility, and edit provenance.

• Image Generation

  Turn a sentence into a picture nobody has ever taken.

• In-context Learning

  Learn a new task using just a few examples in the prompt, without changing a single parameter

• Inference Optimization: First Locate Whether the Bottleneck Is Prefill, Decode, KV, or Queuing

  From TTFT/TPOT, arithmetic intensity, and continuous batching, to PagedAttention, FlashAttention, quantization, speculative decoding, and real-workload validation.

• Information Theory and Entropy: From Probability to Coding Cost

  First distinguish the true distribution P from the model distribution Q, then derive cross-entropy, KL divergence, and perplexity step by step from self-information and entropy.

• Model Interpretability: From Input Attribution to Causal Intervention, Distinguishing Story, Evidence, and Mechanism

  Comparing feature attribution, probes, counterfactuals, activation replacement, sparse features, and circuit analysis to understand fidelity, stability, completeness, and “readable does not equal true.”

• Jailbreak Attacks: Using Adversarial Instructions to Find Policy Boundaries, but System Risk Depends on Whether Assets Can Be Reached

  From direct/indirect, multi-turn, encoding, suffix optimization, and multimodal jailbreaking to threat models, base rates, defense in depth, adaptive red teaming, and false rejection of legitimate requests.

• Kernel Methods and SVM: Just Computing Similarity Can Learn Nonlinear Boundaries

  Understand the capabilities, hyperparameters, and scale limitations of linear, RBF, and polynomial kernels through maximum margin, the dual problem, and the kernel trick.

• Knowledge Graphs: Organizing Identity, Relationships, Time, and Evidence into Queryable Facts

  From ontologies, entity resolution, and temporal edges to path retrieval and GraphRAG, understand when graphs outperform similarity and how they propagate errors.

• Large Language Model (LLM)

  From “predicting the next word” to “conversing like an assistant”

• Logprobs and Confidence: Model Preference Does Not Equal Answer Trustworthiness

  Understand when logprob is useful from token log probabilities, sequence likelihood, calibration, and selective prediction, and how tokenization and semantic equivalence mislead thresholds.

• Loss Function: Turning ‘Where It Went Wrong’ into a Learnable Direction

  From business cost to a differentiable proxy, from single-sample error to empirical risk; using the same numerical example, see how the loss, gradient, and parameter update connect into a closed loop.

• Lost in the Middle: When context fits, why might the model still fail to find it?

  Understand position effects in long contexts, learn to measure them with controlled experiments, and use retrieval, reordering, and structural design to reduce the probability that key evidence is ignored.

• MCP Model Context Protocol

  Let any tool and data plug into AI applications through the same standard interface.

• MCP Architecture: Enabling the MCP Host to Connect External Capabilities Within an Isolation Boundary

  From MCP Host–MCP Client–MCP Server, JSON-RPC, capability negotiation, and three types of primitives, understand what MCP standardizes, and who remains responsible for authorization and execution security.

• Model Evaluation and Benchmarks: Turning "Stronger" into Reproducible Evidence

  From estimation target, sampling budget, and pass@k, to contamination, judge bias, confidence intervals, and release thresholds.

• Model Families: Understanding Capability Boundaries from Information Flow and Training Objectives

  Instead of memorizing brand rankings, use four axes—architecture, objectives, modality, and product layer—to judge why a model excels at a particular type of task.

• Model Merging: Combining Weight Deltas in a Shared Coordinate System

  From checkpoint averaging, model soups, and task vectors, to permutation alignment, sign conflict, TIES/DARE, coefficient search, and safety regression.

• Model Routing and Cascades: Assign Requests of Different Difficulties to Sufficient Capability

  From direct routing, small-then-large, and quality-gap prediction, to escalation thresholds, cascade latency, fairness risk, and online recalibration.

• Model Selection and Cost: Finding the Minimal Viable Solution That Satisfies Constraints

  From task distribution, strong-model upper bound, and multidimensional gates, to cost per successful task, Pareto frontier, and exit strategy.

• Mixture of Experts (MoE): Have each token activate only a few feed-forward networks

  From top-k routing and weighted outputs, to load balancing, capacity overflow, all-to-all, expert specialization, and inference batching.

• Multi-agent Systems: Organizing Complex Tasks with Boundaries, Parallelism, and Independent Verification

  From task dependency graphs, communication topologies, and shared state to critical paths, handoff losses, and common-source errors, determine when multi-agent truly outperforms single-agent.

• Multimodal Models

  One model that understands images, sounds, and text all at once.

• Neural Network

  From “Why We Need It” to “How It Learns Through Backpropagation”

• Normalization: Controlling Representation Scale, Stabilizing Deep Optimization

  From LayerNorm's centering and RMSNorm's root-mean-square scaling, to Pre-Norm/Post-Norm and implementation acceptance, understand exactly which axis normalization computes statistics along, what it retains, and what it discards.

• LLM Observability and Tracing: Reconstructing Why an AI Request Got This Result

  Use traces, spans, versions, quality signals, and minimized data to turn “occasional wrong answers” into locatable, replayable, regression-testable problems.

• Optimizers and Learning Rate Schedules: Turning Instantaneous Gradients into a Controllable Training Trajectory

  From the state updates of SGD, Momentum, Adam, and AdamW, to warm-up, plateau, decay, batch size, and mixed precision; understand why a training recipe must be tuned as a whole.

• Overfitting: How models mistake chance in a finite sample for regularity

  Starting from the separation of empirical risk and unknown risk, learn to read training/validation curves, recognize leakage, repetition, and tuning contamination, and understand the boundaries of capacity, double descent, and large model memorization.

• PEFT / LoRA: Freezing the backbone, learning only low-rank weight increments

  From ΔW=BA, rank, and scaling, to trainable parameter accounting, QLoRA, target modules, merged versions, and multi-adapter interference.

• Agent Planning: Turning Goals into Executable, Revisable State Diagrams

  Understand planning–execution separation, rolling planning, checkpoints, and local replanning through goals, preconditions, artifacts, and completion predicates.

• Positional Encoding and RoPE: Making Attention Know Order and Distance

  From permutation equivariance, sinusoidal absolute positions, and relative bias to rotary position embeddings, understand how order enters attention and why long-context extension is not simply changing a window number.

• Post-training

  Pre-training provides capabilities; post-training determines how those capabilities are invoked and presented.

• Assistant Response Prefilling: Letting the Model Continue from a Given Answer Prefix

  Understand how the assistant prefix changes the conditional distribution, and strictly distinguish it from input prefill, prompt caching, and constrained decoding.

• Pre-training

  Self-supervised learning on massive unlabeled text, instilling “general capabilities” into the model in one go

• AI Privacy: Controlling Identifiability, Memorization, and Unauthorized Use Along Data Flows

  From collection, prompts, retrieval, logs, vendors, to model weights, understand station by station how personal data spreads, and how to reduce risk through minimization, isolation, and verifiable deletion.

• Prompt Caching: Reusing KV Computation for Shared Prefixes

  From longest common token prefix, KV footprint, and hit value, to prompt ordering, routing affinity, invalidation, and tenant isolation.

• Prompt Engineering

  Design the wording and structure of inputs so that the model consistently produces the results you want.

• Prompt Injection

  Hiding malicious instructions in content the model reads to hijack its behavior

• Quantization: Compressing Continuous Parameters onto a Finite Lattice

  From scale, zero-point, and rounding error, to granularity, outliers, PTQ/QAT, weights/activations/KV, and hardware kernels.

• RAG Retrieval-Augmented Generation

  Before answering, first retrieve relevant materials, letting the model 'answer with the book open' rather than making things up from memory.

• ReAct: Closing the Loop on Reasoning, Action, and Observation

  Use external evidence to revise assumptions instead of letting a reasoning chain run its course unsupported

• Reasoning Models

  Use more training and inference compute for search, verification, and correction in exchange for accuracy on hard problems.

• Reflection and Self-Correction: Making Failure Evidence Change the Next Action

  Distinguish vague self-assessments, external feedback, and verifiable corrections; use minimal changes, stopping conditions, and versioned experience to avoid “thinking it over again” producing more confident errors.

• Regularization: Constraining How Models Learn with Interpretable Preferences

  Starting from L2/L1, AdamW, Dropout, data augmentation, and early stopping, understand how four types of constraints—on parameters, representations, data, and training paths—change generalization, instead of treating regularization as a one-size-fits-all knob.

• Reinforcement Learning: Learning Decision Policies from Delayed Feedback

  Use MDPs, returns, value functions, Bellman equations, exploration, and policy gradients to understand how an RL agent optimizes long-term outcomes through interaction.

• Reranking: Making Fine-Grained Relevance Judgments Among High-Recall Candidates

  Understand two-tower retrieval, cross-encoders, late interaction, Large Language Model (LLM) reranking, and position bias, and design evaluation from Recall@k to end-to-end answers.

• Residual Connections: Preserving an Identity Information Highway for Deep Transformations

  Starting from the forward increment y=x+F(x) and the backward Jacobian I+JF, understand depth degradation, projection shortcuts, branch scaling, zero initialization, and Transformer's Pre-Norm/Post-Norm.

• Retrieval and Semantic Search

  Surface the most relevant snippets from a knowledge base and feed them to the model for answering.

• RLHF and Preference Alignment: Turning “What People Prefer” into a Trainable Signal

  From demonstration data, preference comparisons, reward models, to policy optimization, understand what RLHF optimizes and why it cannot be equated with “making the model absolutely safe.”

• Recurrent Neural Network (RNN): Compressing History into a Continuously Updated State

  From shared recurrence, time unrolling, and BPTT, to gradient multiplication, LSTM gating, teacher forcing, and streaming deployment.

• Sampling and Decoding Parameters: From Logits to Final Sequence

  Use a set of hand-computable candidate distributions to tie together temperature, top-k, top-p, repetition penalty, stopping conditions, and random seed, and understand which step each knob changes and what it cannot guarantee.

• Scaling Laws: Using Power Laws to Plan Parameters, Data, and Compute

  From log-log straight lines and diminishing marginal returns to compute-optimal allocation, and then to data quality, capability thresholds, and total lifecycle cost.

• Self-supervised Learning: Letting Data Generate Its Own Training Targets

  A unified understanding of autoregression, masked reconstruction, contrastive learning, and self-distillation, and tracing how pretext objectives transfer, take shortcuts, or become misaligned.

• Speech systems: converting between text, linguistic content, speaker identity, and acoustic waveforms

  Put speech recognition, speech synthesis, and voice cloning into the same pipeline, understanding acoustic features, alignment, vocoders, streaming latency, WER, and identity authorization.

• State Space Models (SSM): Compressing Long Sequences with Controllable Dynamical Systems

  From continuous state equations, discretization, and convolution equivalence, to selective scanning, linear complexity, stability, and random-access boundaries.

• Streaming Output: Turning One Generation into a Cancelable, Resumable Event Protocol

  From tokens, UTF-8 byte chunks, and SSE events, to TTFT, backpressure, structural buffering, safety review, and final commit.

• Structured Outputs: Connecting Probabilistic Text to Deterministic Software Contracts

  From minimal schema, constraint generation, and layered validation to version migration, limited repair, and secure execution.

• Super-resolution: Inferring high resolution from degraded observations does not equal recovering true detail.

  From blur–downsampling–noise models, pixel loss and perceptual loss, to Generative Adversarial Network (GAN)/diffusion priors, blind super-resolution, hallucination boundaries, and task-oriented evaluation.

• Supervised Learning

  Learn from “input + target” samples and make reliable predictions on unseen data.

• Synthetic Data: Generating Candidates Is Easy, Increasing Useful Information Is Hard

  From teacher demonstrations, programmatic ground truth, self-training, and augmentation, to verifier selection bias, coverage ratios, feedback loops, and model collapse.

• System Prompts: Declare Behavioral Contracts in Probabilistic Models, Not Security Boundaries

  From message sequences, instruction priority, conflict resolution, and context assembly to injection, leakage, versioning, and contract testing—understand what system prompts can control.

• Test-time Compute and Verifiers

  Without changing the weights, use sampling, search, tools, and checking to convert extra computation into more reliable answers.

• Tokens and Tokenization: The Discrete Language That Models Actually Read and Write

  From Unicode, pre-tokenization, BPE/Unigram, byte fallback, and special tokens, understand why the same text yields different lengths, different costs, and different capability boundaries.

• Tool Calling / Function Calling

  Give a model that can only talk a pair of “hands” that can look things up, calculate, and do things.

• Training Data Governance: Making What Models Learn Traceable, Auditable, and Actionable

  From sources and licensing, lineage, filtering, deduplication, and mixing ratios, to contamination, deletion requests, training snapshots, and incident response.

• Transformer

  Packaging attention into a standard building block that can be stacked deeply and trained in parallel.

• Tree of Thoughts (ToT): Searching and Backtracking Across Multiple Intermediate Solutions

  Understand states, candidate generation, value evaluation, BFS/DFS, pruning, and search budget, and distinguish between expanding the search space and getting the answer right.

• Uncertainty and Calibration: Making “80% Confidence” Really Mean About 80% Correct

  From confidence scores, reliability diagrams, and ECE to selective prediction, rejection thresholds, and distribution shift.

• Unsupervised Learning: When There Are No Human Labels, Structure Comes from Assumptions

  Using clustering, dimensionality reduction, density estimation, and generative modeling to understand the objective design, non-uniqueness, Pseudo-structure, and validation when there is “no standard answer”.

• Variational Autoencoder (VAE): Compressing Data with a Sampleable Probabilistic Latent Space

  From the encoding distribution, reparameterization, and the ELBO, to the KL–reconstruction trade-off, posterior collapse, latent-space interpolation, and limits of generation quality.

• Vanishing and Exploding Gradients: How Depth Turns Local Derivatives into Exponential Effects

  From scalar products to matrix Jacobians, from sigmoid saturation to RNN unrolling over time; use numerical examples to understand how initialization, gating, residuals, normalization, and gradient clipping each change which segment of the path.

• Vector Databases: Approximate Nearest Neighbor Search in Large-Scale Embeddings

  Understand vectors, distance metrics, HNSW/IVF/PQ, filtering, updates, and consistency, and separate index recall, latency, and end-to-end Retrieval-Augmented Generation (RAG).

• Video Generation: Jointly Modeling Spatial Appearance, Temporal Motion, and Cross-Shot State

  From video latent variables, spatiotemporal attention, and diffusion, to image-to-video, cascaded super-resolution, identity consistency, physics failures, long video planning, and temporal evaluation.

• Voice Cloning

  Split "what is said" and "who it sounds like" into two conditions, then accept using intelligibility, naturalness, speaker similarity, and authorization together

• Workflow Orchestration: Carrying Probabilistic Models with Persistent State and Deterministic Control

  From DAGs, state machines, and durable execution, to idempotency, retries, compensation, version migration, and human tasks, build recoverable, auditable AI processes.

• World Models: Predicting the World After Actions in Internal States

  From state representations, transition and reward models, to imagined rollouts, model predictive control, uncertainty, and model exploitation, understand how “trying things out in the mind” helps and misleads agents.