All 30 AI Terms — Searchable Glossary | Infotech Management Consulting

Core 10

AI Model

The trained system behind the output+

Plain EnglishA model is the trained system that turns an input into an output — a set of statistical weights learned from data, not a piece of software running hand-written rules.

In practiceWhen a vendor says their platform "uses AI," ask which model, whose data trained it, and where it runs — the answer changes your privacy and procurement posture entirely.

Common mix-upThe model gets treated as the whole product. It's one component — the application wrapped around it does most of the work of making it safe and useful.

Core 10

LLM

A language specialist+

Plain EnglishAn LLM is a model trained on enormous volumes of text to predict what comes next — the technology behind tools like ChatGPT and Claude.

In practiceAn LLM can draft a stakeholder briefing or summarize a lengthy standards document in seconds — but it has no access to your organization's records unless something connects it to them.

Common mix-up"LLM" and "AI" get used interchangeably. LLMs are one category of AI — strong on language, not inherently strong on math, current facts, or structured data.

Core 10

Token

The unit models read and write in+

Plain EnglishA token is the small chunk of text — roughly a word or part of a word — that a model processes and generates, one at a time.

In practiceVendor pricing and "usage limits" are almost always quoted in tokens, not pages. Worth translating into a real document count before you sign anything.

Common mix-upA token isn't a word or a character — it's somewhere in between, which is why the same document can vary in token count across models.

Core 10

Prompt

What you ask for, right now+

Plain EnglishA prompt is the instruction or question given to a model — the input that determines what comes back out.

In practiceThe gap between a mediocre AI-drafted policy summary and a genuinely useful one is almost always the quality of the prompt, not the model behind it.

Common mix-upPeople treat prompting like a search query. It's closer to briefing a fast, literal new analyst — more context and structure produces a better result.

Core 10

Context

What the model can see right now+

Plain EnglishContext is the background information available to a model when it responds — prior messages, documents, or data supplied alongside the prompt.

In practiceA model asked about "the migration timeline" with nothing attached will guess. The same question with the actual project plan attached will answer accurately.

Common mix-upContext isn't memory. Most tools don't retain what you tell them once a session ends, unless the product is specifically built to persist it.

Core 10

Context Window

How much fits in one session+

Plain EnglishThe context window is the total amount of text — prompt, documents, and conversation combined — a model can consider in a single exchange, measured in tokens.

In practiceA short context window means a long RFP or standards document has to be split into pieces. A longer one lets you hand over the whole thing at once.

Common mix-upA bigger window doesn't guarantee even attention to everything inside it — models can still skim past specifics buried in the middle of a long document.

Core 10

Reasoning

Working through the problem in steps+

Plain EnglishReasoning describes a model working through intermediate steps before producing a final answer, rather than jumping straight to a response.

In practiceFor a multi-step task like reconciling data fields across two systems, a reasoning-capable model is more likely to catch inconsistencies than one that answers in a single pass.

Common mix-upVisible "reasoning" is still generated text, not verified logic. It should raise your confidence, not replace review — especially on anything regulatory or clinical.

Core 10

Harness

The machinery around the model+

Plain EnglishA harness is the surrounding software that manages a model's inputs, outputs, tools, and guardrails — the scaffolding that turns raw model output into a usable, controlled product.

In practiceTwo vendors can run the identical underlying model and deliver very different results, because the harness — how it's prompted, constrained, and connected to your systems — is where most of the engineering happens.

Common mix-upBuyers evaluate "the AI" when they should be evaluating the harness — the access controls, audit logging, and failure handling built around it.

Core 10

Project

A durable workspace+

Plain EnglishIn an AI tool, a project is a persistent workspace that groups a set of files, instructions, and conversations together, so the model has consistent context every time you return to it.

In practiceSetting up a project for a specific standards review or vendor evaluation means you're not re-explaining the background every session.

Common mix-upA project isn't the same as fine-tuning a model — it organizes what you feed the model, it doesn't change the model itself.

Core 10

Agent

A goal-directed action loop+

Plain EnglishAn agent is a system that uses a model to take multi-step action toward a goal — searching, calling tools, and deciding what to do next with limited human input along the way.

In practiceAn agent might be asked to gather status from three systems and draft a summary, deciding on its own which lookups to run — a meaningfully different risk profile from a model that only answers what it's asked.

Common mix-upNot everything marketed as "agentic" actually takes independent action. Some products are still single-step assistants wearing agent branding.

Pattern

The Cold Start Problem

Every new session starts blank+

The patternA model can know a great deal in general and still know nothing about your organization, your role, or the initiative in front of you until you supply it.

What helpsKeep a short standing brief — who you are, what success looks like, current constraints — and open with it, or store it in a persistent project.

In practiceAsk for a stakeholder briefing without naming the health authority or initiative, and you'll get a briefing that could describe almost anyone.

Not the same asThis isn't evidence the model is unreliable — general capability and knowledge of your specific situation are two different things.

Pattern

Hallucination

A confident detail that isn't true+

The patternWhen the real evidence is missing, a plausible-sounding answer can come out just as fluently as a well-supported one.

What helpsAsk for named, checkable sources, verify any figure before it reaches a client document, and explicitly permit "I don't have that."

In practiceA draft summary cites a section number in a standard that turns out not to exist.

Not the same asA citation formatted correctly isn't a citation that's true — formatting isn't evidence.

Pattern

Sycophancy

Agreeing instead of testing the plan+

The patternA system built to be helpful can mirror your framing and preferred conclusion more readily than it challenges them.

What helpsAsk directly for the counter-case, the biggest risk, and the conditions under which the plan should be rejected.

In practiceDescribe a vendor you're already leaning toward, and the model finds reasons the choice is sound while skipping past the procurement risk.

Not the same asAn agreeable tone isn't the same thing as a sound recommendation.

Pattern

The Premature Build

Rushing to a finished draft+

The patternAsked for a document, it can skip straight to a polished draft rather than surfacing the open questions first.

What helpsAsk for a plan, an outline, or three open questions before authorizing the full build.

In practiceA request for a project charter returns a fully formatted document before scope or sponsorship has actually been agreed.

Not the same asA polished, complete-looking output can hide the fact that the real decisions were never made.

Pattern

First-Draft Anchoring

Patching instead of rethinking+

The patternThe first output becomes a gravity well — later feedback tends to mutate it rather than cleanly revisit the underlying approach.

What helpsFor a genuine redirect, start a fresh request from a clean brief rather than iterating on a flawed foundation.

In practiceA steering committee deck gets a dozen rounds of wording edits when the real issue is that it's telling the wrong story.

Not the same asIterating on solid evidence is normal practice — getting stuck editing a flawed first draft is a different thing entirely.

Pattern

Context Rot

A long thread turning unreliable+

The patternSuperseded drafts, dropped directions, and old decisions pile up in a long thread, and the signal gets harder to use reliably.

What helpsStart fresh sessions at natural milestones, and keep durable facts in a project file rather than buried in chat history.

In practiceA months-long procurement thread resurfaces an evaluation criterion that was explicitly dropped two revisions earlier.

Not the same asA large context window means more text can fit — it doesn't mean every detail inside it gets equal, reliable weight.

Pattern

Outdated or Ungrounded Knowledge

Answering from stale training data+

The patternA policy, a software version, or an org chart can change after a model's training ends, and it has no built-in way to know that.

What helpsSupply current source documents directly for anything time-sensitive, rather than relying on the model's own memory.

In practiceGuidance on a system's integration approach references an older version that no longer matches what's actually deployed.

Not the same asWeb access doesn't guarantee the authoritative source gets found — retrieval quality still needs a human check.

Pattern

The Average Trap

Drifting toward generic phrasing+

The patternAn underspecified request tends to land near the statistical middle of everything the model has seen — competent, and indistinguishable from anyone else's.

What helpsSupply real examples, a point of view, and specific language to avoid, so the model has something to differentiate against.

In practiceAn executive summary arrives full of phrases no actual sponsor would recognize as their own.

Not the same asClean grammar and a confident tone aren't the same as a substantive point of view.

Pattern

Probabilistic Variability

Same request, different answer+

The patternGeneration works probabilistically rather than as a fixed lookup, so repeated runs of the same prompt can diverge.

What helpsFor anything that needs to be repeatable, add constraints — templates, rubrics, worked examples — and review proportional to the stakes.

In practiceRun the same risk-assessment prompt twice in one week and the emphasis, or even the recommendation, may shift.

Not the same asVariability isn't randomness for its own sake — it means repeatable work needs guardrails, not that the tool is unreliable.

Pattern

Reasoning Failure

Sound-looking logic, wrong premise+

The patternMore visible reasoning helps with many tasks, but it doesn't guarantee the underlying assumption or calculation is correct.

What helpsCheck the starting assumptions independently, and verify any calculation against the actual source data.

In practiceA budget projection walks through its logic clearly but starts from the wrong baseline year.

Not the same asA detailed explanation is not proof — the conclusion still needs to be checked against the numbers.

Pattern

Bias

Uneven treatment carried forward+

The patternA model learns patterns from human-produced data and from how a task is framed — both can carry uneven treatment forward.

What helpsTest outputs across a range of real cases, and keep an accountable person reviewing anything that affects people's outcomes.

In practiceA draft position posting emphasizes different qualifications depending on subtle cues in a candidate's background, even when the qualifications are equal.

Not the same asBias isn't limited to overtly offensive language — it can show up as omissions, defaults, or uneven error rates.

Supporting

Agency

How much freedom the system has+

Plain EnglishAgency describes how much freedom an AI system has to choose and carry out actions toward a goal, without a person approving each step.

In practiceA low-agency assistant might search one document you name explicitly; a higher-agency system could plan several searches, compare findings, and revise its own approach before reporting back.

Common mix-upMore agency isn't inherently better — useful agency still needs to sit inside clear tools, permissions, and stopping points, with a person accountable for the outcome.

Supporting

Memory

What persists beyond this moment+

Plain EnglishMemory is information a system stores and can recall across separate sessions, rather than starting blank each time.

In practiceA persistent project can retain your preferred report format or standing context, so you're not re-explaining the basics in every new conversation.

Common mix-upMemory and active context aren't the same thing — a stored fact still has to be retrieved and pulled into the current conversation to actually shape the answer.

Supporting

System Instructions

The standing operating brief+

Plain EnglishSystem instructions are the standing guidance that defines how a tool should behave — its role, boundaries, and expected output — sitting above whatever you type in any given moment.

In practiceA tool built for standards review might carry a permanent instruction to always cite the specific clause it's referencing and flag anything it can't verify.

Common mix-upInstructions shape behavior, but they don't guarantee compliance — they're not a substitute for testing, permissions, and actual review.

Supporting

Prompt Engineering

Shaping the request+

Plain EnglishPrompt engineering is the practice of writing the immediate request clearly enough that the goal, constraints, and expected format are unambiguous.

In practiceInstead of "review this," asking the model to name the three highest-risk assumptions and the evidence behind each produces a far more usable answer.

Common mix-upA better-written prompt can't make up for missing source documents, unavailable tools, or a workflow that was never going to work.

Supporting

Context Engineering

Shaping the evidence+

Plain EnglishContext engineering is deciding what information a model actually needs for a task, and organizing it so the most relevant material is what actually gets used.

In practiceA well-built research assistant pulls in only the current, relevant policy sections — not the entire shared drive — so the signal doesn't get buried.

Common mix-upMore context isn't automatically better context. Relevance, how current it is, and how it's structured all matter more than sheer volume.

Supporting

Harness Engineering

Shaping the working system+

Plain EnglishHarness engineering is designing the tools, permissions, and checks around a model — the difference between a system that can only suggest an answer and one that can safely look things up, calculate, and act.

In practiceA dependable reporting tool might combine live data access, a calculation step, a source check, and a human approval gate before anything gets published.

Common mix-upA stronger harness makes a model genuinely more useful — but it also creates real governance and security responsibilities that need to be owned.

Supporting

Multimodal

More than text+

Plain EnglishA multimodal model can work across more than one kind of information — text, images, audio, or files — rather than text alone.

In practiceA photo of a whiteboard from a working session can be turned directly into organized notes and a draft brief.

Common mix-upMultimodal access doesn't mean equal skill in every format — extraction from messy scans or handwriting still needs a human check.

Supporting

Tool Use / Connectors

Reaching beyond the answer+

Plain EnglishTool use describes the ways a system reaches beyond generating text — searching, calculating, reading a database, or calling another piece of software through a defined connection.

In practiceAn assistant connected to your project tracker can pull current status directly rather than working from what you remember to tell it.

Common mix-upHaving access to a tool isn't the same as using it with good judgment — permissions, error handling, and verification still need to be built around it.

Supporting

Human in the Loop

Judgment at the right checkpoint+

Plain EnglishHuman in the loop means a person reviews, approves, or redirects the work at meaningful points, rather than the system running entirely on its own.

In practiceA model might draft a stakeholder update and update an internal tracker, while a person approves the update before anything goes out externally.

Common mix-upReview only helps if it happens before anything irreversible, and if the reviewer can actually see the evidence behind the decision — not just the polished output.

Find it fast. Go as deep as you need.

AI Model

LLM

Token

Prompt

Context

Context Window

Reasoning

Harness

Project

Agent

The Cold Start Problem

Hallucination

Sycophancy

The Premature Build

First-Draft Anchoring

Context Rot

Outdated or Ungrounded Knowledge

The Average Trap

Probabilistic Variability

Reasoning Failure

Bias

Agency

Memory

System Instructions

Prompt Engineering

Context Engineering

Harness Engineering

Multimodal

Tool Use / Connectors

Human in the Loop

We'll walk your team through the vocabulary a specific proposal or vendor is using.