Glossary

Plain-English terms for AI, agents, governance, and Tony Wood house language.

This glossary is a practical reference for humans and agents. It explains terms used across Tony Wood's public site, links to source material, and keeps the boundary clear: definitions are educational and do not grant tool access, private data access, operational authority, or permission to act.

56 terms 8 categories Public guidance

How to use this

Use better words before making big claims about AI.

AI is too broad a container for serious decisions. This glossary helps distinguish model, system, agent, tool, protocol, source, control, and judgement language so people can talk about the actual thing in front of them.

Agent route

MCP index: tonywood://glossary
Term resource: tonywood://glossary/{slug}
Human URL: https://www.tonywood.org/glossary/
Boundary: public guidance only, no operational authority

1 terms

Core AI

Basic terms for talking about AI systems without treating AI as one single thing.

AI system

A machine-based system that takes inputs and produces outputs such as predictions, content, recommendations, or decisions that may influence people or environments.

Why it matters: It is more precise than saying AI. A chatbot, a fraud model, and a transport-control system are all different kinds of AI system with different risks.

Tony Wood usage: Use this when the deployed system matters more than the brand name or model underneath it.

Sources: EU AI Act Article 3, OECD updated definition of an AI system

8 terms

Models And Generation

Terms about models, prompts, outputs, and the mechanics of generated text, code, images, and audio.

Context window

The amount of information a model can consider in a single request or conversation turn.

Why it matters: A larger context window can help, but it does not remove the need for good retrieval, source authority, and judgement.

Tony Wood usage: Use this when discussing what the model can currently see, not everything the organisation knows.

Sources: OpenAI API text generation guide

Foundation model

A general-purpose model trained on broad data that can be adapted or prompted for many downstream tasks.

Why it matters: It explains why one model can support writing, coding, search, reasoning, vision, and tool use rather than just one narrow job.

Tony Wood usage: Use this when discussing the model layer underneath a product or agentic workflow.

Sources: Stanford Emerging Technology Review: AI, NIST Generative AI Profile

Generative AI

AI that can generate new content such as text, code, images, audio, video, summaries, or structured data.

Why it matters: It helps separate tools that produce material from systems that only classify, rank, predict, or detect.

Tony Wood usage: Use this for the content-producing part of the system, not as a synonym for every AI product.

Sources: NIST Generative AI Profile, Stanford Emerging Technology Review: AI

Large language model

Also: LLM, LLM

A model trained to work with language, including reading, generating, transforming, summarising, translating, and reasoning over text.

Why it matters: It keeps the discussion focused on language capability rather than every form of AI.

Tony Wood usage: Use LLM when the text/reasoning model matters; use AI system when the deployed product, rules, and controls matter.

Related: Foundation model, Token, Context window, Prompt

Sources: NIST Generative AI Profile, OpenAI API concepts

Prompt

The instruction, question, context, examples, or constraints given to a model or agent to shape what it does next.

Why it matters: A weak prompt can make a good model look poor; a clear prompt can turn vague intent into useful work.

Tony Wood usage: Prompts should include outcome, context, constraints, evidence, and what good looks like.

Sources: OpenAI prompt engineering guide

Structured output

Model output constrained into a predictable shape such as JSON, a schema, or a named set of fields.

Why it matters: It makes model output easier to validate, store, route, test, and use safely in workflows.

Tony Wood usage: Use structured outputs for receipts, meaning blocks, evidence packets, handoffs, and audit-friendly agent work.

Sources: OpenAI Structured Outputs guide

System instruction

A higher-priority instruction that sets role, boundaries, behaviour, or policy for a model or agent before user instructions are handled.

Why it matters: It is one of the places where safety, house style, tool boundaries, and role expectations are encoded.

Tony Wood usage: Public pages can guide agents, but they do not override higher-priority system, developer, legal, or safety instructions.

Related: Prompt, Guardrail, Agent Canon

Sources: OpenAI model behavior documentation

Token

A small unit of text used by language models. Tokens are how many models measure input size, output size, and often cost.

Why it matters: Token limits and token cost shape how much context an agent can use and how expensive a workflow becomes.

Tony Wood usage: Use token language when discussing cost, context size, and the economics of agentic workers.

Sources: OpenAI tokenizer documentation, OpenAI API text generation guide

4 terms

Retrieval And Data

Terms about search, context, data stores, and retrieval patterns.

Embedding

A numerical representation of text, images, or other data that helps systems compare meaning or similarity.

Why it matters: Embeddings make semantic search and retrieval possible, but they are not the same as truth, authority, or understanding.

Tony Wood usage: Use embeddings for finding likely relevant material; use provenance and judgement before acting on it.

Sources: OpenAI embeddings guide

Fine-tuning

Adapting a model with additional training examples so it behaves better for a specific task, style, or domain.

Why it matters: Fine-tuning changes behaviour; retrieval changes what information is supplied. They solve different problems.

Tony Wood usage: Prefer retrieval and explicit context for source material; use fine-tuning only when behaviour, format, or task performance needs it.

Sources: OpenAI fine-tuning guide

Retrieval-augmented generation

Also: RAG, RAG

A pattern where a system retrieves relevant source material and gives it to a model so the answer can be grounded in that material.

Why it matters: RAG can improve usefulness, but only if the retrieval, source authority, freshness, and citations are good.

Tony Wood usage: Use RAG for context, not as a substitute for governance or source-of-truth decisions.

Sources: OpenAI retrieval guide

Vector search

Also: Vector database, Semantic search

A search method that uses embeddings to find material that is similar in meaning, not just text that matches exact words.

Why it matters: It can surface useful context that keyword search misses, but it still needs source checks and freshness checks.

Tony Wood usage: Use vector search as a retrieval tool, not as proof that a retrieved source is current or authoritative.

Sources: OpenAI embeddings guide

3 terms

Agentic Systems

Terms for AI systems that plan, use tools, hand off work, or act through workflows.

Agent

A system that can use model reasoning, instructions, tools, context, and state to pursue a task or goal through multiple steps.

Why it matters: An agent is not just a chat box. It may plan, call tools, hand off work, and create consequences.

Tony Wood usage: Use agent when the system is doing work across steps, not just replying once.

Sources: OpenAI Agents SDK guide

Agentic system

A system where one or more agents can plan, use tools, coordinate, remember context, escalate, and act inside a controlled workflow.

Why it matters: It shifts the question from a single answer to operating model, oversight, cost, audit, and safety.

Tony Wood usage: Use this for long-running or tool-using AI work that needs governance, receipts, and human judgement.

Related: Agent, Human in the loop, Receipt, Audit trail

Sources: OpenAI Agents SDK guide, IBM: What is agentic AI?

Tool calling

Also: Function calling

A model or agent selecting a defined external function, tool, API, or connector to gather information or perform a bounded operation.

Why it matters: Tool calling is where language meets action, so permissions, schemas, and review boundaries matter.

Tony Wood usage: Treat tool calls as operational events that should be scoped, logged, and reviewed according to risk.

Related: MCP tool, API, Structured output, Guardrail

Sources: OpenAI function calling guide

10 terms

Agent Protocols

Terms for MCP, A2A, NLIP, and other ways agents connect to tools or other agents.

Agent Card

A public descriptor that tells other systems how to understand or contact an agent, including identity, endpoint, capabilities, and supported protocol details.

Why it matters: Discovery only works safely when other agents can tell what an agent is, what it can do, and where its boundaries are.

Tony Wood usage: Use Agent Card for public A2A discovery, not as proof of private authority.

Related: Agent2Agent, Public agent, Agent Canon

Sources: A2A protocol specification

Agent2Agent

Also: A2A, A2A

An open protocol intended to let opaque agentic applications communicate and interoperate with each other.

Why it matters: A2A is about agents finding and coordinating with other agents, not simply connecting one agent to a tool.

Tony Wood usage: Use A2A when discussing agent-to-agent discovery, handoff, and public digital twin communication.

Sources: A2A GitHub project, Google A2A announcement

MCP client

The component inside an MCP host that connects to an MCP server.

Why it matters: The client is the connection point that lets the host discover and call server capabilities.

Tony Wood usage: Use client when explaining the connection from a harness to a specific MCP server.

Sources: MCP clients

MCP host

The AI application or environment that coordinates MCP clients and presents capabilities to the user or agent.

Why it matters: The host is the user-facing environment, so it shapes consent, tool visibility, and the boundary between model and tools.

Tony Wood usage: Use host for the harness or application where the agent is operating.

Sources: MCP architecture

MCP prompt

A reusable prompt template exposed by an MCP server for a client or agent to use in a controlled way.

Why it matters: Prompts can standardise common workflows, but they should not be treated as permission to act outside their boundary.

Tony Wood usage: Use prompts for reusable public guidance only when the source and boundary are clear.

Related: Model Context Protocol, Prompt, Agent Canon

Sources: MCP prompts

MCP resource

A readable item exposed by an MCP server, such as a document, profile, status object, article, topic, or glossary entry.

Why it matters: Resources are usually safer than tools because they retrieve published material rather than perform actions.

Tony Wood usage: Prefer resources for public Tony Wood content and use tools only when the operation needs parameters.

Sources: MCP resources

MCP server

A server that exposes resources, tools, or prompts to MCP clients.

Why it matters: The server controls what external system capability is made available to agents.

Tony Wood usage: Use server for the public or private endpoint that exposes agent-readable capabilities.

Sources: MCP servers

MCP tool

A callable capability exposed by an MCP server, usually with a defined input schema and output shape.

Why it matters: Tools can create consequences, so the action boundary and permissions need to be explicit.

Tony Wood usage: Use tools for bounded operations; do not expose private or write tools on public MCP surfaces.

Sources: MCP tools

Model Context Protocol

Also: MCP, MCP

An open protocol for connecting AI applications and agents to external systems such as data sources, tools, workflows, and prompts.

Why it matters: MCP gives agents a standard way to reach useful context and tools without every product inventing a different connector shape.

Tony Wood usage: Use MCP when discussing controlled tool and data access for agents.

Sources: Model Context Protocol introduction, Model Context Protocol specification

Natural Language Interaction Protocol

Also: NLIP, NLIP

A standard for natural-language interaction messages between applications and AI systems.

Why it matters: It is another part of the emerging protocol layer for agent and assistant communication.

Tony Wood usage: Use NLIP as a comparison point when discussing agent communication standards.

Sources: ECMA NLIP standards suite, ECMA-430

11 terms

Governance And Safety

Terms for risk, oversight, evidence, controls, and human responsibility.

Audit trail

A record of what happened, who or what did it, when it happened, what evidence was used, and what decision or action followed.

Why it matters: It lets people review decisions, debug workflows, challenge assumptions, and prove that controls operated.

Tony Wood usage: Use audit trail for agent work that creates action, advice, publication, customer impact, or governance consequence.

Related: Receipt, Provenance, Meaning Blocks

Sources: NIST AI Risk Management Framework

Eval

Also: Evaluation

A test or assessment used to check whether a model, agent, prompt, or workflow behaves as expected.

Why it matters: Without evals, teams can mistake a good demo for a reliable system.

Tony Wood usage: Use evals for repeatable checks around quality, safety, source use, boundaries, and regression.

Related: Guardrail, Hallucination, Structured output

Sources: OpenAI Evals guide, NIST AI Risk Management Framework

Guardrail

A rule, check, control, policy, or boundary designed to reduce unsafe, low-quality, unauthorised, or unwanted behaviour.

Why it matters: Guardrails are how intent becomes repeatable behaviour under pressure.

Tony Wood usage: Use guardrails for data access, publishing, tool use, stop-lines, and human escalation.

Related: Human in the loop, Scope, LLM firewall

Sources: NIST AI Risk Management Framework

Hallucination

Also: Confabulation

An output that sounds plausible but is unsupported, wrong, fabricated, or not grounded in the available evidence.

Why it matters: The practical question is not just whether a model can be wrong, but whether the workflow catches unsupported claims before they matter.

Tony Wood usage: Use hallucination carefully: often the failure is a mix of weak context, poor verification, missing evidence, and poor governance.

Related: Eval, Provenance, Source authority, Guardrail

Sources: NIST Generative AI Profile

Human in the loop

Also: Human on the loop

A design where a human reviews, approves, supervises, or can intervene in an AI-assisted workflow.

Why it matters: It keeps responsibility with people when consequences matter.

Tony Wood usage: Use in the loop for approval before action; use on the loop for supervision and monitoring where pre-approval is not required.

Related: Guardrail, Stop-line, Agentic system

Sources: NIST AI Risk Management Framework

LLM firewall

A protective control layer that inspects prompts, context, tool calls, outputs, or routes before an LLM or agent can create harm.

Why it matters: It is a practical way to enforce the spine of an AI workflow: authority, boundary, consequence, and escalation.

Tony Wood usage: Use this as part of Head / Heart / Gut / Spine, especially the spine layer.

Sources: NIST AI Risk Management Framework

Provenance

Information about where something came from, how it was produced, and what sources, people, systems, or activities influenced it.

Why it matters: Provenance helps separate evidence from assertion and source truth from convenient text.

Tony Wood usage: Use provenance when mapping roots, citations, evidence, and source authority.

Related: Source authority, Woodlands, Receipt

Sources: W3C PROV overview

Receipt

A compact record that confirms what an agent or workflow did, what it used, what changed, and whether the result passed checks.

Why it matters: Receipts make agent work inspectable without forcing a person to read every intermediate step.

Tony Wood usage: Use receipts for deploys, handoffs, research packs, agent tasks, and anything that needs proof rather than vibes.

Sources: Agentic Language research paper

Safety-critical AI

AI used in contexts where errors can materially affect physical safety, legal rights, health, employment, finance, infrastructure, or other serious interests.

Why it matters: The higher the consequence, the stronger the evidence, control, testing, and human accountability need to be.

Tony Wood usage: Use this when a workflow crosses from convenience into consequence.

Related: AI system, Human in the loop, Stop-line

Sources: EU AI Act Article 3, NIST AI Risk Management Framework

Source authority

The question of which source is allowed to define the current truth for a claim, decision, record, or operational fact.

Why it matters: Agents can retrieve many documents; they still need to know which one should be trusted for action.

Tony Wood usage: Use source authority when deciding whether a retrieved item is an entry point, evidence, branch, or trunk.

Related: Provenance, Woodlands, Meaning Blocks

Sources: Woodlands research paper

Stop-line

A rule that requires an agent or system to pause rather than continue when a defined risk threshold is reached.

Why it matters: It gives agents a clear line between challenge, comply, escalate, and stop.

Tony Wood usage: Use stop-lines for privacy, data loss, legal exposure, unsafe publication, irreversible actions, or material commitments.

Sources: When The Agent Thinks You Are Wrong

9 terms

Agent-Readable Web

Terms for making public websites and services easier for agents to understand safely.

Agent-readable web

A design approach where public websites expose clear routes, structured data, plain claims, source links, and machine-readable indexes so agents can understand them safely.

Why it matters: Websites built only for human attention can be hard for agents to inspect, cite, compare, or act on responsibly.

Tony Wood usage: Use this for site design that serves people and agents without hiding core facts behind visual persuasion.

Related: llms.txt, schema.org, Content index, MCP resource

Sources: Stop Paying The Data Tax

API

Also: Application Programming Interface

A defined interface that lets software request data or actions from another system.

Why it matters: Good APIs make tools easier for agents to use; weak or absent APIs push people back into slow manual interfaces.

Tony Wood usage: Use API when a tool exposes a stable machine interface, even if it is not MCP or A2A.

Related: Tool calling, Model Context Protocol, OAuth

Sources: MDN API overview

Content index

A structured generated index of public site content, metadata, routes, and machine-readable resources.

Why it matters: It gives agents a safer, lighter way to discover published content than scraping every page.

Tony Wood usage: Tony Wood uses a generated public content index to feed search, MCP, topics, protocols, and agent-readable routes.

Related: MCP resource, llms.txt, Topic

Sources: Tony Wood public content index

JSON-LD

A JSON-based format for linked data that can describe entities and relationships in a machine-readable way.

Why it matters: It helps agents and search systems understand what a page is about without guessing from layout alone.

Tony Wood usage: Use JSON-LD for public structured data that supports people, search, and agents.

Related: schema.org, Agent-readable web, Provenance

Sources: JSON-LD

llms.txt

A proposed public file that gives AI systems a concise map of useful site routes, content, and instructions.

Why it matters: It helps agents find the right public material before scraping or guessing.

Tony Wood usage: Tony Wood uses llms.txt as a public route map for writing, research, protocols, topics, Agent Canon, and glossary pages.

Related: Agent Canon, MCP resource, Sitemap

Sources: llms.txt proposal

OAuth

An authorization framework used to let one application access another system on a user's behalf without sharing the user's password.

Why it matters: Agentic tools need scoped, revocable access rather than broad credentials.

Tony Wood usage: Use OAuth and scopes when discussing controlled access for public or private agent tools.

Related: Scope, MCP tool, Guardrail

Sources: OAuth 2.0 RFC 6749

schema.org

A shared vocabulary for describing things such as articles, people, organisations, events, products, and datasets on the web.

Why it matters: It gives public pages a common structured language that machines can parse.

Tony Wood usage: Use schema.org vocabulary where public pages need predictable metadata.

Related: JSON-LD, Agent-readable web, Content index

Sources: schema.org getting started

Scope

A named permission boundary that limits what an access token, API client, or integration is allowed to do.

Why it matters: Scopes help keep agent access narrow, revocable, and easier to audit.

Tony Wood usage: Use scopes to describe what an agent can read, suggest, or act on.

Related: OAuth, Guardrail, Human in the loop

Sources: OAuth 2.0 scope definition

Sitemap

A machine-readable list of site URLs intended to help crawlers discover public pages.

Why it matters: Sitemaps make public routes easier to discover and keep in sync with generated content.

Tony Wood usage: Use the sitemap for public route discovery; use MCP or content-index JSON for richer public metadata.

Related: llms.txt, Content index, Agent-readable web

Sources: Sitemaps protocol

10 terms

Tony Wood House Language

Public Tony Wood terms used in research, protocols, Agent Canon notes, and agent-facing pages.

Agent Canon

A public Tony Wood format for agent-facing guidance that remains readable by humans and does not grant private access or authority.

Why it matters: It lets public pages teach agents how to interpret Tony Wood safely without pretending the page is a private instruction channel.

Tony Wood usage: Use Agent Canon for public guidance, standards, and interpretation notes for agents.

Related: llms.txt, MCP resource, Agent Moves

Deeper protocol: Agent Canon Format

Sources: Agent Canon on Tony Wood, Agent Canon Format protocol

Agent Communication Packet

A compact packet of claim, evidence, uncertainty, owner, risk, route, next action, success condition, and human note for agent handoffs.

Why it matters: It stops handoffs becoming vague prose and makes it easier for another agent or person to understand what is being asked.

Tony Wood usage: Use this for agent-to-agent and agent-to-human handoffs.

Related: Agent Moves, Meaning Blocks, Receipt

Deeper protocol: Agent Communication Packet

Sources: Agent Communication Packet protocol

Agent Moves

Also: OAL/1: Orchistra Agent Language, OAL/1, Orchistra Agent Language

A typed register for naming what an agent is doing, such as inform, request, propose, commit, refuse, clarify, handoff, escalate, decide, or error.

Why it matters: Typed moves make agent communication easier to audit and safer to route than raw prose alone.

Tony Wood usage: Use Agent Moves when agents need to make the kind of action visible before the work becomes ambiguous.

Deeper protocol: Agent Moves / OAL/1

Sources: Agent Moves protocol

Head / Heart / Gut / Spine

Also: HHGS, HHGS

A judgement grammar for separating evidence, human impact, anomaly sensing, authority, and purpose.

Why it matters: It keeps agentic judgement from becoming only data and logic; people, trust, pressure, and authority matter too.

Tony Wood usage: Use Head for evidence, Heart for dignity and trust, Gut for weak signals, and Spine for authority and boundary.

Related: Trigger, LLM firewall, Guardrail

Deeper protocol: Head / Heart / Gut / Spine

Sources: Head / Heart / Gut / Spine protocol

Meaning Blocks

Also: OMB/1: Orchistra Meaning Block, OMB/1, Orchistra Meaning Block

A storage-facing meaning record that preserves canonical meaning while raw prose remains available as evidence.

Why it matters: It gives agents a safer way to store and route meaning without treating every sentence as equally authoritative.

Tony Wood usage: Use Meaning Blocks for claim, ask, evidence, confidence, risk, owner, next action, and success condition.

Deeper protocol: Meaning Blocks / OMB/1

Sources: Meaning Blocks protocol

Orchistra

Tony's public term for an agentic work-room pattern: a Slack-like place where agents can work in lanes and channels using defined language.

Why it matters: Shared rooms need shared meanings. Without a clear vocabulary, agents can move fast while misunderstanding each other.

Tony Wood usage: Use Orchistra for the coordination environment and its public language layer, not as a disclosure of private implementation details.

Sources: Orchistra, Agentic Language research paper

Public agent

A deterministic public representative agent that can answer from published material but has no private memory, no private access, and no authority to act as Tony.

Why it matters: Public agents can be useful without being dangerous if their identity, boundaries, and sources are explicit.

Tony Wood usage: Use this for Tony Wood's public A2A and MCP-facing representative surfaces.

Related: Agent Card, Agent Canon, MCP resource

Sources: Tony Wood Public Agent

Topic

A generated public reading layer that groups Tony Wood writing, research, protocols, and Agent Canon notes around recurring themes.

Why it matters: Topics help people and agents find the right route when they know the problem but not the article.

Tony Wood usage: Use topics as navigation, not as the canonical article source.

Related: Content index, llms.txt, MCP resource

Sources: Tony Wood topics

Trigger

Also: Signal

A named signal that helps an agent or person decide that attention, routing, memory, review, or constraint is needed.

Why it matters: Long-running systems need words for surprise, fear, pressure, confusion, care, and other signals before they become failures.

Tony Wood usage: Use Triggers as a signal language, not as a claim that machines have human emotions.

Deeper protocol: Triggers Signal Language

Sources: Triggers Signal Language protocol

Woodlands

Tony's model for connected memory: native systems keep bodies while Woodlands keeps identity, meaning, pointers, boundaries, links, revisions, tombstones, and audit.

Why it matters: It gives people and agents orientation across many stores without copying everything into one unsafe pile.

Tony Wood usage: Use Woodlands when discussing source authority, roots, trunks, boundaries, and safe connected memory.

Sources: Woodlands research paper