S

Sandbox

• Category: Agents & tools
• What it actually means: An isolated execution environment that restricts an agent's access to files, processes, network destinations, credentials, and host resources.
• Why it matters: Generated code and tool calls can be wrong or malicious. Isolation limits their reach and makes disposable verification practical.
• In practice: Run tests in an ephemeral container with a read-only base, a scoped writable workspace, no production secrets, and an explicit network allowlist.
• Common confusion: A sandbox reduces impact. It does not establish that the code inside is correct or harmless.
• Learn it: Production Agent Runtimes
• Related terms: Least Privilege, Approval Gate, Coding Agent, Guardrails

Saturation

• Category: Reliability & operations
• What it actually means: The degree to which a constrained resource or service has exhausted its capacity, including queued work that cannot begin promptly.
• Why it matters: Utilization alone can appear acceptable while memory, accelerator slots, queue depth, or a downstream quota is already limiting useful throughput.
• In practice: Identify each critical resource, measure active and waiting work, relate saturation to tail latency and errors, and alert before the queue enters an unstable growth regime.
• Common confusion: Saturation is not one universal percentage. The limiting resource and its queueing behavior depend on the workload and architecture.
• Related terms: Observability, Autoscaling, Backpressure, Tail Latency
• Sources: Google SRE: Monitoring Distributed Systems

Scope Contract

• Category: AI-native development
• What it actually means: A concrete agreement that defines a task's goal, allowed and forbidden surfaces, expected artifacts, verification requirements, and stopping conditions.
• Why it matters: It prevents an agent from turning a narrow fix into an unreviewable refactor or from claiming completion without evidence.
• In practice: State that only the parser module and its tests may change, public APIs must remain compatible, and the named test suite must pass.
• Common confusion: A task description says what you want. A scope contract also defines boundaries and proof.
• Learn it: Scope Contracts
• Related terms: Coding Agent, Patch, Verification Gate, Handoff

Self-Attention

• Category: Models & inference
• What people say: Tokens deciding which other tokens matter.
• What it actually means: Attention in which queries, keys, and values are derived from the same sequence representation. Scaled similarity scores are normalized and used to combine values, subject to causal, padding, local, or other masks.
• Why it matters: It builds context-sensitive token representations, but the permitted attention pattern depends on the architecture.
• Common confusion: Not every token can always attend to every other token. Causal and sparse models intentionally restrict connections.
• Learn it: Self-Attention from Scratch
• Related terms: Attention, Transformer, Context Window

Semantic Cache

• Category: AI-native development
• What it actually means: A cache that reuses a previous result when a new request is judged sufficiently similar under a chosen representation and threshold.
• Why it matters: It can reduce latency and cost for repeated intents, but an incorrect match can return stale or user-inappropriate output.
• In practice: Cache low-risk FAQ answers by normalized intent, include tenant and policy version in the key, and bypass the cache for personalized or time-sensitive requests.
• Common confusion: Semantic similarity does not guarantee that two requests have the same correct answer. A semantic cache reuses a prior result, while prefix caching reuses exact-token KV state and prompt caching follows provider or application eligibility rules.
• Related terms: Prompt Cache, Embedding, Cost per Successful Task, Grounding

Semantic Search

• Category: Retrieval & generation
• What people say: Search by meaning instead of exact words.
• What it actually means: Retrieval that represents a query and candidates in an embedding space and ranks candidates using a vector-similarity function.
• Why it matters: It can retrieve paraphrases and conceptually related text, but exact identifiers and rare strings may still need lexical search.
• Related terms: Embedding, Hybrid Retrieval, Vector Database, Reranker

Separation of Duties

• Category: Security & governance
• What it actually means: Dividing conflicting responsibilities or authority across independent roles so one principal cannot complete a high-risk action without another authorized decision.
• Why it matters: A compromised account or mistaken agent should not be able to propose, approve, execute, and conceal the same consequential change.
• In practice: Separate artifact creation from release approval, use distinct identities, preserve both decisions in the audit log, and define emergency access with later review.
• Common confusion: Separation of duties is about conflicting authority, not simply assigning work to several people or agents that share the same credentials.
• Related terms: Approval Gate, Reviewer Agent, Audit Log, Least Privilege
• Sources: NIST SP 800-53 Rev. 5

Service Level Indicator (SLI)

• Category: Reliability & operations
• What it actually means: A quantitative measure of service behavior at a defined user-relevant boundary, such as successful request ratio or latency below a threshold.
• Why it matters: Reliability discussions become actionable only when the observed behavior, eligible events, and measurement point are explicit.
• In practice: Define numerator, denominator, exclusions, data source, and aggregation window, then validate that the indicator tracks an outcome users actually experience.
• Common confusion: An SLI is the measurement. An SLO is the target applied to that measurement over a defined period.
• Related terms: Service Level Objective (SLO), Availability, Tail Latency, Observability
• Sources: Google SRE: Service Level Objectives

Service Level Objective (SLO)

• Category: Reliability & operations
• What it actually means: A target range or threshold for a service-level indicator over a stated population and measurement window.
• Why it matters: It translates an expected user outcome into an operating boundary for monitoring, capacity, release risk, and incident decisions.
• In practice: Choose an indicator users care about, set the target from product needs rather than current performance, define the window and exclusions, and attach an error-budget policy.
• Common confusion: An SLO is an internal reliability objective. A contractual service-level agreement can include remedies and may use different definitions.
• Learn it: Inference Metrics and Goodput
• Related terms: Service Level Indicator (SLI), Error Budget, Availability, Goodput
• Sources: Google SRE: Service Level Objectives

SFT (Supervised Fine-Tuning)

• Category: Math & training
• What people say: Training on example inputs and desired outputs.
• What it actually means: Fine-tuning a pretrained model on paired inputs and desired responses so it learns the demonstrated behavior under the training distribution.
• Common confusion: SFT can adapt many behaviors beyond chat, and example quality determines what behavior is reinforced.
• Related terms: Fine-tuning, DPO (Direct Preference Optimization), RLHF (Reinforcement Learning from Human Feedback)

Shadow Traffic

• Category: Reliability & operations
• What it actually means: A copy of live request traffic sent to a candidate system for observation while the candidate response remains outside the primary user response path. Because the copied request still executes, its side effects must be isolated.
• Why it matters: It exposes the candidate to real input shapes and load while limiting user impact, which can reveal failures absent from synthetic tests.
• In practice: Remove or tokenize sensitive fields, route tools and dependencies to sandboxed or no-op targets, block writes at capability boundaries, preserve request correlation, and prevent shadow load from competing with user traffic.
• Common confusion: Keeping a candidate response off the primary path does not make execution side-effect-free. A canary release differs because it serves real users from the candidate for a controlled share of traffic.
• Learn it: Shadow, Canary, and Progressive Delivery
• Related terms: Canary Release, Evaluation (Eval), Trace, Model Serving
• Sources: Istio Traffic Mirroring

Shared Embedding Space

• Category: Multimodal systems
• What it actually means: A common vector space in which representations from different modalities can be compared with the same similarity function.
• Why it matters: It enables cross-modal retrieval and matching, such as finding images from text, without requiring both items to share a raw representation.
• In practice: Train paired and unpaired negatives deliberately, normalize vectors when the objective requires it, evaluate both retrieval directions, and inspect subgroup and language performance.
• Common confusion: Sharing a vector dimension does not create a shared semantic space. The training objective and data must establish cross-modal comparability.
• Learn it: CLIP Contrastive Pretraining
• Related terms: Embedding, Cosine Similarity, Modality Alignment, Semantic Search
• Sources: Learning Transferable Visual Models From Natural Language Supervision

Skill Bundle

• Category: Agents & tools
• What it actually means: The complete installable skill directory, including SKILL.md and every reference, script, asset, fixture, or companion file required by the workflow.
• Why it matters: Copying only the entry file can leave valid-looking instructions that point to missing resources or lose the deterministic code the workflow depends on.
• In practice: Install the tree as one unit, record hashes and source revision, validate the installed copy, and show collisions before replacing an existing bundle.
• Common confusion: SKILL.md is the entry point, not necessarily the entire artifact.
• Learn it: Skill Evals, Packaging, and Portability
• Related terms: Agent Skill, Skill Catalog, Reproducible Build, Provenance Attestation
• Sources: Agent Skills specification

Skill Catalog

• Category: Agents & tools
• What it actually means: The compact model-visible inventory of eligible skills, usually containing routing metadata such as name, description, and an internal source identifier rather than every skill body.
• Why it matters: A catalog lets an agent discover relevant procedures without loading every installed package into the working context.
• In practice: Validate packages first, apply an explicit duplicate-name policy, measure the serialized catalog budget, and retain diagnostics for entries that were shortened, omitted, or shadowed.
• Common confusion: A catalog entry means the skill is discoverable. It does not mean the body is active or its tools are authorized.
• Learn it: Skill Discovery and Progressive Disclosure
• Related terms: Skill Discovery, Skill Invocation, Progressive Disclosure, Token Budget
• Sources: Agent Skills specification

Skill Discovery

• Category: Agents & tools
• What it actually means: A runtime pipeline that searches configured roots, identifies candidate skill directories, validates their package contract, attaches scope and provenance, resolves collisions, and publishes eligible catalog entries.
• Why it matters: Deterministic discovery makes missing, malformed, shadowed, and unsafe packages diagnosable before model routing begins.
• In practice: Declare search scopes and duplicate behavior, decide how symlinks are handled, reject resource escapes, and log why each candidate was accepted or rejected.
• Common confusion: Skill discovery is not an unrestricted recursive search for filenames called SKILL.md; installation locations and precedence are runtime policy.
• Learn it: Skill Discovery and Progressive Disclosure
• Related terms: Skill Catalog, Skill Bundle, Progressive Disclosure, Trust Boundary
• Sources: Agent Skills client implementation guide

Skill Invocation

• Category: Agents & tools
• What it actually means: The runtime-mediated process in which an eligible human, model, application, or other skill selects a skill and causes its instructions to enter the working context.
• Why it matters: Explicit user access, implicit model routing, activation, argument binding, tool permission, and execution are separate decisions with different failure modes.
• In practice: Define actor policy, evaluate descriptions with positive and near-miss requests, record the selected package identity, and keep host-specific invocation fields in tested adapters.
• Common confusion: Invocation activates instructions. It does not automatically execute a command or bypass approval and sandbox policy.
• Learn it: Skill Invocation and Routing
• Related terms: Agent Skill, Skill Catalog, Approval Gate, Sandbox
• Sources: Evaluating Agent Skills

Softmax

• Category: Math & training
• What people say: A function that turns logits into normalized positive values.
• What it actually means: A function defined by softmax(x_i) = exp(x_i) / sum(exp(x_j)), implemented with numerical stabilization. Its outputs are positive and sum to one, so they can parameterize a categorical distribution.
• Common confusion: Softmax values are not automatically calibrated probabilities about real-world correctness.
• Related terms: Temperature, Cross-Entropy, Attention

Software Bill of Materials (SBOM)

• Category: Security & governance
• Aliases: SBOM
• What it actually means: A structured inventory of software components and relationships associated with a product or artifact, often including versions, suppliers, licenses, and identifiers.
• Why it matters: You need a component inventory to assess affected dependencies, license obligations, and supply-chain exposure when software changes or vulnerabilities emerge.
• In practice: Generate the SBOM during the trusted build, bind it to the release artifact, verify it in policy checks, and update it whenever dependencies or packaging change.
• Common confusion: An SBOM is an inventory, not proof that components are secure, correctly licensed, or actually present unless generation and provenance are trustworthy.
• Related terms: Provenance Attestation, Reproducible Build, Data Provenance, Audit Log
• Sources: SPDX 3.0.1 specification

Speculative Decoding

• Category: Models & inference
• What it actually means: An inference method in which a cheaper draft process proposes several tokens and the target model scores those draft positions in parallel. In exact sampling variants, an acceptance and correction rule preserves the target model's output distribution.
• Why it matters: It can reduce serial target-model decoding work when drafts are accepted, without requiring a change to the target model's trained weights.
• In practice: Measure acceptance rate and end-to-end latency on real prompts, include draft-model overhead, and verify that the implementation preserves the intended decoding distribution.
• Common confusion: Speculative decoding is not ordinary model routing or unverified autocomplete. Exact variants preserve the target distribution through acceptance and correction, while approximate variants may trade that guarantee for speed.
• Related terms: Autoregressive, KV Cache, Decoding Strategy, Tokens per Second (TPS)
• Sources: Fast Inference from Transformers via Speculative Decoding

Stateless MCP

• Category: Agents & tools
• What it actually means: The MCP 2026-07-28 request model in which every request carries the protocol version and client capabilities in params._meta, while results carry an explicit resultType; no protocol state is keyed by an initialization handshake, connection, or Mcp-Session-Id.
• Why it matters: Any worker can validate and process a request from its contents and authorization context, which avoids hidden connection affinity and makes horizontal routing easier to reason about.
• In practice: Implement server/discover, rebuild request metadata on every call, validate transport headers against the JSON-RPC body, and pass server-minted application handles as ordinary tool arguments when continuity is required.
• Common confusion: Stateless MCP removes protocol sessions, not application state, transport connections, streaming responses, tasks, or explicit handles.
• Learn it: MCP Fundamentals
• Related terms: MCP (Model Context Protocol), Multi Round-Trip Request (MRTR), Tool Contract, Idempotency
• Sources: MCP 2026-07-28 key changes; MCP Streamable HTTP

Stochastic Gradient Descent (SGD)

• Category: Math & training
• Aliases: SGD
• What it actually means: An optimizer family that updates parameters from a gradient estimated on a sampled example or minibatch rather than the complete training dataset.
• Why it matters: It is the baseline for understanding gradient noise, momentum, batch scaling, and the adaptive optimizers used in modern training.
• In practice: Record batch sampling, learning rate, momentum if used, and schedule, then compare validation behavior under equal update or token budgets.
• Common confusion: In current practice, SGD usually means minibatch SGD, and its useful learning rate does not follow one universal batch-scaling rule.
• Related terms: Gradient Descent, Batch Size, Learning Rate, Optimizer
• Sources: Optimization Methods for Large-Scale Machine Learning; Accurate, Large Minibatch SGD

Stop Sequence

• Category: Models & inference
• What it actually means: An application-specified token or text pattern that causes generation to stop when the decoding system encounters it.
• Why it matters: Stop sequences bound output protocols and multi-part generation without waiting for the model to decide semantically that it is finished.
• In practice: Choose unambiguous delimiters, test tokenization and partial streaming matches, and still enforce output length and schema validation.
• Common confusion: A stop sequence is a mechanical decoding condition, not proof that the answer is complete or that an agent goal is satisfied.
• Related terms: Decoding Strategy, Structured Output, Token, Termination Condition
• Sources: Transformers text-generation documentation

Streaming

• Category: Models & inference
• What people say: Showing output as it is generated.
• What it actually means: Delivering incremental response events before the complete result is ready. A stream may contain token text, structured deltas, tool-call arguments, usage metadata, or status events depending on the API.
• Why it matters: It improves perceived responsiveness, but it does not reduce the model's actual time to produce a complete answer.
• Common confusion: Network transport, event shape, and chunk boundaries are provider-specific and are not guaranteed to align with words or tokens.
• Learn it: Production LLM Application
• Related terms: Time to First Token (TTFT), Autoregressive, Observability

Structured Output

• Category: Agents & tools
• What it actually means: Model output constrained or validated against a machine-readable schema so application code can consume fields without parsing free-form prose.
• Why it matters: It reduces format ambiguity at the model-to-software boundary and enables field-level validation and retries.
• In practice: Require an incident triage result with an allowed severity enum, evidence array, and nullable escalation reason, then reject any response that fails the schema.
• Common confusion: Schema-valid output can still contain incorrect values. Structure is not factual verification.
• Learn it: Structured Outputs
• Related terms: Function Calling, Tool Contract, Verification Gate

Swarm

• Category: Agents & tools
• What people say: Many agents collaborating without one fixed controller.
• What it actually means: A loosely coordinated multi-agent pattern in which local agent decisions and message exchange produce system-level behavior. The term is used inconsistently, so the actual topology, state ownership, and termination rules must be specified.
• Common confusion: Multiple named agents do not guarantee useful specialization or emergent coordination.
• Related terms: Agent, Reviewer Agent, Handoff, Agent State

System Prompt

• Category: Prompting & context
• What people say: Developer-controlled instructions for a model interaction.
• What it actually means: A provider-defined instruction message or configuration supplied by the application to establish behavior and constraints within that provider's instruction hierarchy.
• Why it matters: System instructions can guide behavior, but they are not guaranteed to remain secret and should not be treated as a security boundary.
• Common confusion: Priority rules, message roles, persistence, and visibility differ across APIs. Check the current provider contract.
• Learn it: Instructions as Executable Constraints
• Related terms: Prompt Engineering, Prompt Injection, Context Engineering, Guardrails