AI glossary

$json

The json part of the item currently entering this node.

    Acceptance Criteria

    Specific, checkable conditions, written before running, that decide whether an output is accepted.

      Accountability

      Clarity about who answers for a decision and its consequences.

        ACME

        A protocol that automates getting and renewing TLS certificates by proving domain control.

          Action Boundary

          The line between what a system does itself and what it only proposes.

            Adapter

            Small code translating the program's common interface to one provider's API.

              Agent Loop

              The repeated cycle of choosing an action, running it, seeing the result and deciding the next step, until a stop condition is met.

                Aggregate

                Turning many items into one item holding their list.

                  AI Agent

                  A system in which the model decides its own steps and tool use.

                    AI Assistant

                    Direct human conversation with a model; the human decides the path each turn.

                      AI Disclosure

                      Telling the audience that content or a decision involved AI.

                        Alert

                        A message to an owner stating what failed, where, when and the next step, without sensitive data.

                          Alert Fatigue

                          When alerts are so many or so repetitive that people stop reading them and the important one gets lost.

                            Anonymization

                            Changing data by removal, substitution or generalization so a person is not identifiable.

                              API

                              An interface through which programs connect to a service; a successful response can still contain incorrect content.

                                API Key

                                A string issued by a service to identify requests as yours; valid until revoked.

                                  Approval Gate

                                  A point where a workflow pauses until a named human decides.

                                    Approval Timeout

                                    When the approver has not decided in time and the workflow follows a preset path.

                                      Assistant Spec

                                      A tool-independent document holding an assistant's instructions, knowledge list, I/O contract, tests and version log.

                                        Attack Surface

                                        All the ways someone can reach a system or make it act; every extra door is extra risk.

                                          Audit Log

                                          An immutable record of who did or approved what, and when.

                                            Auto-fixing Output Parser

                                            An output parser that asks the model to fix a failed parse, at the cost of an extra call.

                                              Automated Sender

                                              A message sent by a system (newsletter, auto-reply, bounce) that an email assistant must not answer.

                                                Batch Processing

                                                Sending non-urgent requests in batches, usually cheaper with slower results.

                                                  Batching

                                                  Processing items in small groups, usually pausing between groups to respect rate limits.

                                                    Bearer Token

                                                    A credential sent as Authorization: Bearer; whoever holds it is accepted.

                                                      Blast Radius

                                                      The maximum harm possible if a system is fooled or fails; depends on its access.

                                                        Bot Token

                                                        The key a platform issues for a bot; whoever has it can act as the bot.

                                                          Branch

                                                          A lightweight pointer to a commit that gives a separate line of change until it is merged.

                                                            Branching

                                                            Sending items down different paths based on conditions, with If or Switch.

                                                              Calibration

                                                              Agreement between expressed confidence and actual accuracy.

                                                                Channel-agnostic Design

                                                                Separating bot logic from platform details so switching channels is configuration only.

                                                                  Chat Completions API

                                                                  An endpoint that takes a list of messages and returns the model's reply with token usage.

                                                                    Chat Memory

                                                                    A session's message history, stored and re-sent to the model each turn.

                                                                      Checklist

                                                                      A short list of specific checks always done before delivery.

                                                                        Claim

                                                                        A statement that can be true or false; the smallest unit of verification.

                                                                          Claimed Completion

                                                                          When an agent says it did something but the actual tool result does not show it.

                                                                            Classification

                                                                            Choosing one label from a closed list for an input.

                                                                              Commit

                                                                              A snapshot of staged files with message, author and time that you can return to.

                                                                                Community Node

                                                                                A node written by someone other than n8n and installed on an instance; it runs with full access to the machine and workflow data.

                                                                                  Compose File

                                                                                  A YAML file defining several services, networks, volumes and their configuration for Docker Compose.

                                                                                    Configuration

                                                                                    Any value that differs between deployments (addresses, limits, keys); kept separate from code.

                                                                                      Constant-time Comparison

                                                                                      A comparison whose duration does not depend on where values differ, preventing timing attacks.

                                                                                        Constraint

                                                                                        A boundary the output must not cross, ideally stated with its reason.

                                                                                          Container

                                                                                          An isolated process run from an image; whatever is written to its writable layer is lost when it is removed.

                                                                                            Context

                                                                                            Everything sent with a request: instructions, conversation history, documents; the model's working memory.

                                                                                              Context Rot

                                                                                              Degradation of accuracy and recall as the number of tokens in context grows.

                                                                                                Context Selection

                                                                                                Deciding which information goes into the prompt for a task, using four filters: necessary, authoritative, fresh, permitted.

                                                                                                  Context window

                                                                                                  The maximum tokens a model considers in one request, including its output; overflow is not always reported.

                                                                                                    Conversation History

                                                                                                    Earlier messages resent to the model on every turn.

                                                                                                      Credential

                                                                                                      Where n8n stores keys or logins encrypted; nodes only reference it.

                                                                                                        Data Mapping

                                                                                                        Transforming one node's data into the shape the next node expects.

                                                                                                          Data Minimization

                                                                                                          Sending the least data needed, especially personal data, to do the task.

                                                                                                            Data retention

                                                                                                            How long and why a provider keeps inputs and outputs; not training is not the same as not retaining.

                                                                                                              Deduplication

                                                                                                              Dropping an input whose identifier was already processed, before any action repeats.

                                                                                                                Delimiter

                                                                                                                A marker such as <input>…</input> tags or ### that separates a prompt section, especially input data, from instructions.

                                                                                                                  Deterministic Step

                                                                                                                  A step that always gives the same output for the same input.

                                                                                                                    Direct Prompt Injection

                                                                                                                    A user's own message attempting to change the model's behavior.

                                                                                                                      DNS A Record

                                                                                                                      A DNS record pointing a name to a server's IPv4 address (AAAA for IPv6).

                                                                                                                        Docker Volume

                                                                                                                        Persistent storage outside a container that survives container removal.

                                                                                                                          Draft Guardrail

                                                                                                                          Code rules that check model output before it is shown or sent, e.g. rejecting discount or refund promises.

                                                                                                                            Duplicate Delivery

                                                                                                                            The same event arriving more than once; normal for many senders after errors or delays.

                                                                                                                              Duplicate Execution

                                                                                                                              Running the same work twice for one input so that an action happens twice.

                                                                                                                                Edge Case

                                                                                                                                An unusual input that raises the chance of failure: empty, very long, ambiguous or rule-breaking.

                                                                                                                                  Edit Fields

                                                                                                                                  An n8n node that creates, renames or removes fields.

                                                                                                                                    Embedding model

                                                                                                                                    Converts text to vectors to find semantically similar text; does not generate text.

                                                                                                                                      Encryption Key

                                                                                                                                      The key n8n uses to encrypt credentials in its database; backups of credentials are unreadable without it.

                                                                                                                                        Endpoint

                                                                                                                                        A specific API address that performs a specific operation.

                                                                                                                                          Environment

                                                                                                                                          A specific deployment of a program, such as dev, test or prod, with its own configuration values.

                                                                                                                                            Environment Variable

                                                                                                                                            A value set in the runtime environment outside the code and read by the program at run time.

                                                                                                                                              Error Output

                                                                                                                                              A separate node branch passing failed items with error details onward.

                                                                                                                                                Error Workflow

                                                                                                                                                A separate workflow starting with Error Trigger that runs when another workflow fails.

                                                                                                                                                  Evaluation set

                                                                                                                                                  Real samples of your task with scoring criteria, including edge cases, to compare options fairly.

                                                                                                                                                    Evaluator-Optimizer

                                                                                                                                                    A pattern where one model step generates and another evaluates against criteria and gives feedback.

                                                                                                                                                      Exact Match Grading

                                                                                                                                                      Automatic comparison of output to the correct answer; for closed answers.

                                                                                                                                                        Exception Path

                                                                                                                                                        The definition of cases outside the procedure and the role that handles them.

                                                                                                                                                          Execution

                                                                                                                                                          One run of a workflow, with each node's data and result recorded.

                                                                                                                                                            Execution path

                                                                                                                                                            How you run exercises: a legally available hosted service, a local model, or prepared sample runs.

                                                                                                                                                              Exponential Backoff

                                                                                                                                                              Increasing the wait exponentially after each failed attempt so the server can recover.

                                                                                                                                                                Expression

                                                                                                                                                                Short code inside {{ }} in a node field, evaluated per item at run time.

                                                                                                                                                                  Extraction

                                                                                                                                                                  Pulling specific fields out of free text.

                                                                                                                                                                  Fail-fast Validation

                                                                                                                                                                  Checking all configuration at start-up and refusing to run when it is invalid, instead of failing later.

                                                                                                                                                                    Fallback Branch

                                                                                                                                                                    A path for items matching no condition so they are not silently lost.

                                                                                                                                                                      Few-shot Prompting

                                                                                                                                                                      Including a few input/output examples in the prompt so the model picks up the pattern.

                                                                                                                                                                        Field Path

                                                                                                                                                                        The address of a nested value, such as data[0].items[0].title.

                                                                                                                                                                          Fine-tuning and RLHF

                                                                                                                                                                          Steps turning a pretrained model into an instruction-following assistant; they do not remove errors and can encourage agreement.

                                                                                                                                                                            Firewall

                                                                                                                                                                            Rules deciding which incoming connections reach which ports; Docker-published ports may bypass it.

                                                                                                                                                                              Flattening

                                                                                                                                                                              Turning nested data into table rows with a clear rule for each column's level.

                                                                                                                                                                                General level (B1–B5)

                                                                                                                                                                                A description of general AI capability across six competencies, assigned from assessment evidence, not lesson count.

                                                                                                                                                                                  Generation

                                                                                                                                                                                  Writing new text such as a reply draft.

                                                                                                                                                                                    GPU and VRAM

                                                                                                                                                                                    The graphics card and its memory; a local model that fits in VRAM runs fast, otherwise it falls back to CPU and RAM and slows down.

                                                                                                                                                                                      Grounding

                                                                                                                                                                                      Basing an answer on specific text in context, usually with quotes.

                                                                                                                                                                                        Hallucination

                                                                                                                                                                                        A plausible but false statement produced by a model.

                                                                                                                                                                                          Header Auth

                                                                                                                                                                                          A generic credential adding a named header and value to each request.

                                                                                                                                                                                            Healthcheck

                                                                                                                                                                                            A periodic command or request showing a service is actually ready, not just running.

                                                                                                                                                                                              Heartbeat Monitoring

                                                                                                                                                                                              A scheduled job records 'alive' after each successful run, and an outside watcher alerts when that record gets old.

                                                                                                                                                                                                History Window

                                                                                                                                                                                                The number of most recent turns sent to the model.

                                                                                                                                                                                                  HMAC Signature

                                                                                                                                                                                                  A code computed from the payload with a shared secret so the receiver can verify origin and integrity.

                                                                                                                                                                                                    Hosted model

                                                                                                                                                                                                    A model run on the provider's servers, subject to its terms and data policy.

                                                                                                                                                                                                      HTTP Header

                                                                                                                                                                                                      A name-value pair carrying message metadata, such as content type or credentials.

                                                                                                                                                                                                        HTTP Method

                                                                                                                                                                                                        The verb stating the purpose of a request, such as GET to read and POST to create.

                                                                                                                                                                                                          HTTP Request

                                                                                                                                                                                                          The message a client sends: method, URL, headers and sometimes a body.

                                                                                                                                                                                                            HTTP Response

                                                                                                                                                                                                            The message a server returns: status code, headers and usually a body.

                                                                                                                                                                                                              Human in the Loop

                                                                                                                                                                                                              A design where a named human, with time, criteria and authority to reject, approves output before it takes effect.

                                                                                                                                                                                                                Human Queue

                                                                                                                                                                                                                Where uncertain or out-of-scope items go, with a clear reason, for a person to handle.

                                                                                                                                                                                                                  Human Review

                                                                                                                                                                                                                  Provider staff reading some submitted data, e.g. for safety or product improvement.

                                                                                                                                                                                                                    Idempotency Key

                                                                                                                                                                                                                    A unique ID per logical operation sent with a side-effecting request so the server can detect retries.

                                                                                                                                                                                                                      Idempotent

                                                                                                                                                                                                                      A property where repeating an identical request has the same server-side effect as doing it once.

                                                                                                                                                                                                                        Ignore Rules

                                                                                                                                                                                                                        Patterns in .gitignore that keep secrets, local data and build output out of Git's suggestions.

                                                                                                                                                                                                                          Image

                                                                                                                                                                                                                          An immutable bundle of the files, libraries and settings a service needs; changes mean building a new image.

                                                                                                                                                                                                                            Import cURL

                                                                                                                                                                                                                            Building HTTP Request node settings from a curl command; overwrites existing settings.

                                                                                                                                                                                                                              Indirect Prompt Injection

                                                                                                                                                                                                                              Instructions hidden in external content (web, email, files, knowledge-base documents) that influence the model when it reads them.

                                                                                                                                                                                                                                Inference

                                                                                                                                                                                                                                Using a trained model to generate output; the model does not learn from your conversation.

                                                                                                                                                                                                                                  Input and output tokens

                                                                                                                                                                                                                                  Tokens sent to and generated by the model; usually priced separately, output costing more.

                                                                                                                                                                                                                                    Input Data

                                                                                                                                                                                                                                    The material the model works on; it is data, not instructions.

                                                                                                                                                                                                                                      Instruction

                                                                                                                                                                                                                                      The part of a prompt that states what to do and under which rules.

                                                                                                                                                                                                                                        Instruction Hierarchy

                                                                                                                                                                                                                                        The rule for which layer's instruction wins in a conflict; a trained preference, not a security boundary.

                                                                                                                                                                                                                                          Intermediate Output

                                                                                                                                                                                                                                          The output of a chain step, checked before the next step.

                                                                                                                                                                                                                                            Item

                                                                                                                                                                                                                                            The unit of data passed between n8n nodes; each node takes and returns a list of items.

                                                                                                                                                                                                                                              Item Linking

                                                                                                                                                                                                                                              n8n's record of which earlier item each item was produced from.

                                                                                                                                                                                                                                                Jailbreak

                                                                                                                                                                                                                                                An injection aimed at making the model ignore its safety rules.

                                                                                                                                                                                                                                                  Jitter

                                                                                                                                                                                                                                                  Adding randomness to retry delays so clients do not retry in lockstep.

                                                                                                                                                                                                                                                    JSON

                                                                                                                                                                                                                                                    A standard text format for data exchange with objects, arrays, strings, numbers, booleans and null.

                                                                                                                                                                                                                                                      JSON Array

                                                                                                                                                                                                                                                      An ordered list of values in brackets, indexed from zero.

                                                                                                                                                                                                                                                        JSON Mode

                                                                                                                                                                                                                                                        A setting that guarantees valid JSON only, not schema conformance.

                                                                                                                                                                                                                                                        JSON Object

                                                                                                                                                                                                                                                        A set of name-value pairs in braces; names should be unique.

                                                                                                                                                                                                                                                          JSON Schema

                                                                                                                                                                                                                                                          A standard vocabulary for describing the allowed shape of JSON data: field types, required fields and allowed values.

                                                                                                                                                                                                                                                          Key Rotation

                                                                                                                                                                                                                                                          Regularly replacing a key with a new one and revoking the old.

                                                                                                                                                                                                                                                            Knowledge cutoff

                                                                                                                                                                                                                                                            The date up to which a model's knowledge is most reliable, usually earlier than the training data end.

                                                                                                                                                                                                                                                              Lab notebook

                                                                                                                                                                                                                                                              A table recording each experiment so it can be repeated and compared.

                                                                                                                                                                                                                                                                Latency

                                                                                                                                                                                                                                                                Time from sending a request to receiving the response.

                                                                                                                                                                                                                                                                  Lateral Reading

                                                                                                                                                                                                                                                                  Checking a claim or source by consulting other sources rather than trusting the text's appearance.

                                                                                                                                                                                                                                                                    Learning Path

                                                                                                                                                                                                                                                                    An ordered set of courses toward a larger goal; everyone starts with the foundations path.

                                                                                                                                                                                                                                                                      Least Privilege

                                                                                                                                                                                                                                                                      Granting only the access needed for the task, nothing more.

                                                                                                                                                                                                                                                                        License (model)

                                                                                                                                                                                                                                                                        Terms for using an open model; read the license text, not only its name.

                                                                                                                                                                                                                                                                          Local Inference

                                                                                                                                                                                                                                                                          Running a model on your own computer or server, without sending text to an external provider.

                                                                                                                                                                                                                                                                            Local model

                                                                                                                                                                                                                                                                            A model running on your own hardware; text is not sent to an external server, but quality is not on par with the best hosted models.

                                                                                                                                                                                                                                                                              Long Polling

                                                                                                                                                                                                                                                                              A request the server holds open until new data arrives or a timeout.

                                                                                                                                                                                                                                                                                Lost in the middle

                                                                                                                                                                                                                                                                                Accuracy drops when key information sits in the middle of a long context.

                                                                                                                                                                                                                                                                                  Mail Loop

                                                                                                                                                                                                                                                                                  Two automated systems endlessly replying to each other.

                                                                                                                                                                                                                                                                                    Manual Trigger

                                                                                                                                                                                                                                                                                    A trigger fired from the editor's run button; for building and testing.

                                                                                                                                                                                                                                                                                      Max output

                                                                                                                                                                                                                                                                                      The maximum response length, separate from the context window.

                                                                                                                                                                                                                                                                                        Merge

                                                                                                                                                                                                                                                                                        Combining two item streams into one, appended or matched on a field.

                                                                                                                                                                                                                                                                                          Message Roles

                                                                                                                                                                                                                                                                                          The label of each message in a conversation: system or developer, user and assistant.

                                                                                                                                                                                                                                                                                            Metrics Endpoint

                                                                                                                                                                                                                                                                                            An address that exposes a system's counters and gauges in a standard text format for monitoring tools.

                                                                                                                                                                                                                                                                                              Model Grader

                                                                                                                                                                                                                                                                                              An LLM that scores qualitative properties with a rubric, preferably a different model from the generator.

                                                                                                                                                                                                                                                                                                Model Tiering

                                                                                                                                                                                                                                                                                                Small models for simple steps, large only for hard ones, each validated.

                                                                                                                                                                                                                                                                                                  Monitoring

                                                                                                                                                                                                                                                                                                  Regular review of run outcomes by a named owner, with alerts for unusual patterns.

                                                                                                                                                                                                                                                                                                    MTok (million tokens)

                                                                                                                                                                                                                                                                                                    Common pricing unit; cost = tokens × price ÷ 1,000,000.

                                                                                                                                                                                                                                                                                                      n8n

                                                                                                                                                                                                                                                                                                      A visual node-based workflow automation tool available as a cloud service or self-hosted.

                                                                                                                                                                                                                                                                                                        Nested Data

                                                                                                                                                                                                                                                                                                        An object or array inside another object or array.

                                                                                                                                                                                                                                                                                                          Net Time Saving

                                                                                                                                                                                                                                                                                                          Time actually freed after subtracting review, correction, setup and maintenance time.

                                                                                                                                                                                                                                                                                                            Next-token prediction

                                                                                                                                                                                                                                                                                                            The core loop of a language model: score continuations, pick a token, append, repeat.

                                                                                                                                                                                                                                                                                                              Node

                                                                                                                                                                                                                                                                                                              One step of an n8n workflow, such as a trigger, HTTP request, condition or data change.

                                                                                                                                                                                                                                                                                                                Non-retryable Error

                                                                                                                                                                                                                                                                                                                An error that retrying will not fix, such as an invalid key or incomplete input.

                                                                                                                                                                                                                                                                                                                  OAuth

                                                                                                                                                                                                                                                                                                                  A way for a user to grant an app limited access on the service's own page without sharing a password.

                                                                                                                                                                                                                                                                                                                    Offset

                                                                                                                                                                                                                                                                                                                    An ID telling the platform not to send earlier updates again.

                                                                                                                                                                                                                                                                                                                      Open-weight model

                                                                                                                                                                                                                                                                                                                      A model with published weights that can be self-run, still subject to its license.

                                                                                                                                                                                                                                                                                                                        OpenAI-compatible Endpoint

                                                                                                                                                                                                                                                                                                                        Another provider's endpoint that mimics the OpenAI API shape, usually with differences.

                                                                                                                                                                                                                                                                                                                          Output Contract

                                                                                                                                                                                                                                                                                                                          An explicit agreement between the prompt and the consuming program about fields, types and meaning.

                                                                                                                                                                                                                                                                                                                          Output Format

                                                                                                                                                                                                                                                                                                                          The expected shape, length and structure of the response, ideally checkable.

                                                                                                                                                                                                                                                                                                                          Output Parser

                                                                                                                                                                                                                                                                                                                          An n8n sub-node that requests a format from the model and converts the reply into structure.

                                                                                                                                                                                                                                                                                                                            p95 Latency

                                                                                                                                                                                                                                                                                                                            The latency 95% of requests are faster than.

                                                                                                                                                                                                                                                                                                                              Pagination

                                                                                                                                                                                                                                                                                                                              Reading large data in successive requests, page by page, until a stop condition.

                                                                                                                                                                                                                                                                                                                                Parse Failure

                                                                                                                                                                                                                                                                                                                                When a model reply does not match the requested format and cannot be parsed.

                                                                                                                                                                                                                                                                                                                                  Payload

                                                                                                                                                                                                                                                                                                                                  The body of a request, especially a webhook, carrying event data.

                                                                                                                                                                                                                                                                                                                                    Payload Validation

                                                                                                                                                                                                                                                                                                                                    Checking the shape and values of incoming data before any action and rejecting invalid input explicitly.

                                                                                                                                                                                                                                                                                                                                      Personal Data

                                                                                                                                                                                                                                                                                                                                      Information relating to an identified or identifiable person.

                                                                                                                                                                                                                                                                                                                                        Pinned Data

                                                                                                                                                                                                                                                                                                                                        A fixed output kept on a node so later nodes can be tested without re-running it.

                                                                                                                                                                                                                                                                                                                                          Polling

                                                                                                                                                                                                                                                                                                                                          Regularly asking a service whether anything new has happened.

                                                                                                                                                                                                                                                                                                                                            Predefined Credential Type

                                                                                                                                                                                                                                                                                                                                            A credential type n8n provides for a specific service.

                                                                                                                                                                                                                                                                                                                                              Pretraining

                                                                                                                                                                                                                                                                                                                                              Initial training on a large text corpus to predict the next word.

                                                                                                                                                                                                                                                                                                                                                Primary Source

                                                                                                                                                                                                                                                                                                                                                Where a fact originates, such as an official document or original report, not a retelling.

                                                                                                                                                                                                                                                                                                                                                  Procedure Owner

                                                                                                                                                                                                                                                                                                                                                  The role that maintains a procedure, approves changes and answers questions.

                                                                                                                                                                                                                                                                                                                                                    Processing Ledger

                                                                                                                                                                                                                                                                                                                                                    A table recording what happened to each input id so nothing is processed twice.

                                                                                                                                                                                                                                                                                                                                                      Prompt

                                                                                                                                                                                                                                                                                                                                                      The text given to a model to perform a task, including instructions, context and input data.

                                                                                                                                                                                                                                                                                                                                                        Prompt Caching

                                                                                                                                                                                                                                                                                                                                                        Storing a fixed prompt prefix at the provider so re-reading it costs less.

                                                                                                                                                                                                                                                                                                                                                          Prompt Chaining

                                                                                                                                                                                                                                                                                                                                                          Running prompts in sequence where each output feeds the next.

                                                                                                                                                                                                                                                                                                                                                            Prompt Injection

                                                                                                                                                                                                                                                                                                                                                            Input that alters a model's behavior or output in unintended ways; direct or indirect.

                                                                                                                                                                                                                                                                                                                                                              Prompt Template

                                                                                                                                                                                                                                                                                                                                                              A fixed, tested prompt with slots for input, run by a human.

                                                                                                                                                                                                                                                                                                                                                                Provider abstraction

                                                                                                                                                                                                                                                                                                                                                                A layer between your work and the model that makes switching providers a configuration change.

                                                                                                                                                                                                                                                                                                                                                                  Pseudonymization

                                                                                                                                                                                                                                                                                                                                                                  Replacing identifiers with labels that can be reversed using a separate table.

                                                                                                                                                                                                                                                                                                                                                                    Publish

                                                                                                                                                                                                                                                                                                                                                                    Making a saved workflow version live for production runs in n8n 2.x.

                                                                                                                                                                                                                                                                                                                                                                      Pull Request

                                                                                                                                                                                                                                                                                                                                                                      A proposal to merge a branch that is reviewed and discussed before merging.

                                                                                                                                                                                                                                                                                                                                                                        Quality Criteria

                                                                                                                                                                                                                                                                                                                                                                        Measurable properties of acceptable output, each with a threshold and a way to measure it.

                                                                                                                                                                                                                                                                                                                                                                          Rate Limit

                                                                                                                                                                                                                                                                                                                                                                          A service's cap on requests or tokens per time window; exceeding it usually returns 429.

                                                                                                                                                                                                                                                                                                                                                                            Readiness Check

                                                                                                                                                                                                                                                                                                                                                                            A check that answers 'ready to take work', not just 'alive'; in n8n, the database is connected and migrated.

                                                                                                                                                                                                                                                                                                                                                                              Reasoning Model

                                                                                                                                                                                                                                                                                                                                                                              A model that generates reasoning tokens before its final answer; better at multistep work, slower and usually costlier.

                                                                                                                                                                                                                                                                                                                                                                                Reasoning tokens

                                                                                                                                                                                                                                                                                                                                                                                Tokens a reasoning model produces before answering; usually hidden but billed as output.

                                                                                                                                                                                                                                                                                                                                                                                  Reconciliation

                                                                                                                                                                                                                                                                                                                                                                                  Checking the real state of an external system before repeating an action that may or may not have happened.

                                                                                                                                                                                                                                                                                                                                                                                    Regression

                                                                                                                                                                                                                                                                                                                                                                                    A case that passed in the previous version and fails in the new one.

                                                                                                                                                                                                                                                                                                                                                                                      Repository

                                                                                                                                                                                                                                                                                                                                                                                      A project folder together with its full Git history.

                                                                                                                                                                                                                                                                                                                                                                                        Response Format

                                                                                                                                                                                                                                                                                                                                                                                        A parameter requesting JSON or schema-conforming output, if the provider enforces it.

                                                                                                                                                                                                                                                                                                                                                                                        Restore Test

                                                                                                                                                                                                                                                                                                                                                                                        Restoring a backup on a separate instance and checking that data and secrets are really usable.

                                                                                                                                                                                                                                                                                                                                                                                          Retention Period

                                                                                                                                                                                                                                                                                                                                                                                          How long data is kept before deletion.

                                                                                                                                                                                                                                                                                                                                                                                            Retry On Fail

                                                                                                                                                                                                                                                                                                                                                                                            An n8n node setting that re-runs the node after a failure.

                                                                                                                                                                                                                                                                                                                                                                                              Retry-After

                                                                                                                                                                                                                                                                                                                                                                                              A response header saying how long to wait before retrying.

                                                                                                                                                                                                                                                                                                                                                                                                Retryable Error

                                                                                                                                                                                                                                                                                                                                                                                                An error likely to resolve on retry after a short wait, such as a temporary outage.

                                                                                                                                                                                                                                                                                                                                                                                                  Reverse Proxy

                                                                                                                                                                                                                                                                                                                                                                                                  A service that receives outside requests, usually terminates TLS and forwards them to internal services.

                                                                                                                                                                                                                                                                                                                                                                                                    Reversibility

                                                                                                                                                                                                                                                                                                                                                                                                    How easily and cheaply a wrong outcome can be undone.

                                                                                                                                                                                                                                                                                                                                                                                                      Risk-proportional verification

                                                                                                                                                                                                                                                                                                                                                                                                      The harder an error is to reverse, the stricter the check before acting.

                                                                                                                                                                                                                                                                                                                                                                                                        Role Prompting

                                                                                                                                                                                                                                                                                                                                                                                                        Assigning a role for the model to answer in; it changes tone and focus, not knowledge or authority.

                                                                                                                                                                                                                                                                                                                                                                                                          Rollback Plan

                                                                                                                                                                                                                                                                                                                                                                                                          Pre-written steps to return to the previous healthy state after a failed change or upgrade.

                                                                                                                                                                                                                                                                                                                                                                                                            Rule-based Task

                                                                                                                                                                                                                                                                                                                                                                                                            Work done with clear, repeatable rules rather than fresh judgment each time.

                                                                                                                                                                                                                                                                                                                                                                                                              Run Evidence

                                                                                                                                                                                                                                                                                                                                                                                                              Outputs, event logs and counts showing a system and its failure modes were actually tested.

                                                                                                                                                                                                                                                                                                                                                                                                                Safe Stop

                                                                                                                                                                                                                                                                                                                                                                                                                When a requirement fails, the assistant withholds its main output and states exactly what is missing instead of guessing.

                                                                                                                                                                                                                                                                                                                                                                                                                  Sampling and temperature

                                                                                                                                                                                                                                                                                                                                                                                                                  Controls sampling randomness; even at zero, identical outputs are not guaranteed.

                                                                                                                                                                                                                                                                                                                                                                                                                    Schedule Trigger

                                                                                                                                                                                                                                                                                                                                                                                                                    A trigger that runs a workflow at set times.

                                                                                                                                                                                                                                                                                                                                                                                                                      Schema Validation

                                                                                                                                                                                                                                                                                                                                                                                                                      Automatic check that data conforms to a schema.

                                                                                                                                                                                                                                                                                                                                                                                                                        Schema-in-Prompt

                                                                                                                                                                                                                                                                                                                                                                                                                        Putting the output format in the prompt instead of provider enforcement; no guarantee.

                                                                                                                                                                                                                                                                                                                                                                                                                        Secret

                                                                                                                                                                                                                                                                                                                                                                                                                        Any value that lets someone act as you: a key, token, password or signing key.

                                                                                                                                                                                                                                                                                                                                                                                                                          Secret Manager

                                                                                                                                                                                                                                                                                                                                                                                                                          A service that stores secrets encrypted, restricts and logs access and simplifies rotation.

                                                                                                                                                                                                                                                                                                                                                                                                                            Security Audit

                                                                                                                                                                                                                                                                                                                                                                                                                            A periodic report of unused credentials, risky nodes, unprotected entry points and settings; n8n audit in n8n.

                                                                                                                                                                                                                                                                                                                                                                                                                              Self-check

                                                                                                                                                                                                                                                                                                                                                                                                                              A step asking the model to verify its answer against criteria before finishing; not a substitute for external checks.

                                                                                                                                                                                                                                                                                                                                                                                                                                Self-hosting

                                                                                                                                                                                                                                                                                                                                                                                                                                Running software on your own machine or server, owning install, security, backups and updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                  Semantic Validation

                                                                                                                                                                                                                                                                                                                                                                                                                                  Checking that values are correct and supported, beyond shape; e.g. that an order ID appears in the input.

                                                                                                                                                                                                                                                                                                                                                                                                                                    Sensitive Data

                                                                                                                                                                                                                                                                                                                                                                                                                                    Data whose disclosure causes serious harm: health, financial and card data, children's data, confidential documents.

                                                                                                                                                                                                                                                                                                                                                                                                                                      Session ID

                                                                                                                                                                                                                                                                                                                                                                                                                                      An identifier separating one conversation's messages from others; comes from the channel, not user text.

                                                                                                                                                                                                                                                                                                                                                                                                                                        Session Isolation

                                                                                                                                                                                                                                                                                                                                                                                                                                        Ensuring no session sees another session's messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Simplest Sufficient Solution

                                                                                                                                                                                                                                                                                                                                                                                                                                          The least complexity that meets the success criteria.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Source Metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                            Labels such as title, date and owner attached to each document so its origin is clear.

                                                                                                                                                                                                                                                                                                                                                                                                                                              Specialist badge

                                                                                                                                                                                                                                                                                                                                                                                                                                              Three independent badges for building capability, separate from the general level, requiring execution evidence and review.

                                                                                                                                                                                                                                                                                                                                                                                                                                                SSH Key Pair

                                                                                                                                                                                                                                                                                                                                                                                                                                                A private key on your computer and a public key on the server: login without sending a password.

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Stable Instructions

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Standing text present in every conversation of an assistant, stating mission, scope, style, red lines, examples and fallback behavior.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Staging Area

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Where you choose exactly what goes into the next commit; git add stores the file as it is at that moment.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Standard Procedure

                                                                                                                                                                                                                                                                                                                                                                                                                                                      A written description of a recurring task: inputs, steps, output, checks, exceptions and owner.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        State Summary

                                                                                                                                                                                                                                                                                                                                                                                                                                                        A short note of facts, decisions and open items carried forward instead of the full history.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Status Code

                                                                                                                                                                                                                                                                                                                                                                                                                                                          A three-digit result code; the first digit is its class: 2xx success, 4xx client error, 5xx server error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Step Budget

                                                                                                                                                                                                                                                                                                                                                                                                                                                            The maximum number of steps, tool calls or cost an agent run may use.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Step Ledger

                                                                                                                                                                                                                                                                                                                                                                                                                                                              A table recording, per event, which external steps are done, in progress or pending, so a rerun resumes correctly.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Step Zero

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Checking input before any work: required columns, units, summary and incomplete rows; stop and ask if a requirement fails.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Stop And Error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  A node that deliberately fails an execution to trigger the error workflow.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Stop Condition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A rule written in advance that says when and in what state an agent run ends: success, partial or immediate stop.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Structured Output

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Machine-readable output such as JSON or a table that can be validated against a schema.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Structured Output Parser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An output parser converting output to a JSON object per a schema.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Sub-workflow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A workflow called by another workflow, with defined input and output.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Summarization

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Shortening text while keeping key points.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Sustainable Use License

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              n8n's main license allowing internal, personal and consulting use but not offering n8n to others to build workflows.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Sycophancy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                A tendency to agree with the user even when wrong; tested with neutral questions and pushback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  System Prompt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The builder's fixed message for a conversation or system, holding rules, role and examples.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Task Decomposition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Breaking complex work into steps with defined input, output and check.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Task Inventory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A table of a role's repetitive tasks with frequency, time and risk attributes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Task Runner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A separate process that runs Code node code so user code does not run inside n8n itself; external mode in production.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Terms of service and supported regions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Rules defining who may use a service, where and how; a hard filter before comparing quality.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Test Set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Fixed inputs with expected answers or criteria used to measure each version consistently.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The maximum time to wait for a response; after it the outcome is unknown.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TLS Certificate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                A document proving the server controls the domain, used to encrypt traffic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Token

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The smallest unit a model processes and bills; counts depend on language and tokenizer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Token Usage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Input and output token counts reported in a response; the basis for cost.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Tokenizer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The rule that splits text into tokens; changing it can change the cost of the same text substantially.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Total Cost of a Step

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Model cost plus retries, human review and fixed infrastructure cost for one workflow step.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Trigger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The event that starts a workflow run, such as an incoming email, a schedule or a new row.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Untrusted Content

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Any text you did not write that enters the context; it may contain instruction-like sentences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              An event a messaging platform sends to a bot, with a numeric ID.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Upsert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                A write that updates the record with the same key or creates it; repeating it never creates a second record.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Usage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Response fields reporting actual input and output tokens; the right basis for cost estimates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Value-Risk Matrix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Placing opportunities on value and risk axes to set the order of work.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Verification Log

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A table of claims with checked source, status and action.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Verification Status

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The outcome label of a claim check: verified, false, unverifiable or needs internal confirmation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Version Log

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A record of each prompt or model change, its reason and its result on the test set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Version Pinning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Running an exact version instead of a moving tag like latest, so upgrades happen only by decision.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Version-bound Approval

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Approval valid only for the exact version shown to the approver.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Webhook

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                An HTTP request a service sends to your URL when an event happens.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Webhook Authentication

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  A condition a webhook request must meet (secret header, JWT or HMAC signature) before the workflow runs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Workflow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A predefined path of steps that runs automatically; the builder decides the path.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Workflow Versioning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Keeping every version of a workflow elsewhere (for example Git) so changes can be seen, reviewed and undone.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Zero-shot Prompting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A prompt with instructions only, no examples.