LLM (Large Language Model)
The actual AI bit — the engine that generates text, answers questions, and follows instructions. Examples you've probably heard of: ChatGPT, Claude, Gemini, Grok. GitHub Copilot and similar products also run on LLMs underneath.
Analogy: Think of an LLM as an extremely well-read assistant who has read most of the public internet. They can write, summarise, explain, brainstorm — but on their own, they can't do anything in your world. They just talk.
Agent shell (coding agent app)
An app that uses an LLM to actually do things — read your files, edit documents, run commands, talk to other tools, publish web pages. It's not just chat: it's chat plus the ability to take action.
Examples: OpenCode, Grok Build, Cursor, Claude Code, Windsurf, VS Code Copilot Chat. They all do roughly the same job — give an LLM hands — with different UIs and config.
Analogy: If the LLM is the brain, the agent shell is the hands. The brain knows things; the hands get things done in the real world.
Model access / model provider
How your agent shell gets an LLM to reason with. Sometimes that's bundled (e.g. an org GitHub Copilot seat, or a product's built-in models). Sometimes you connect an API key or a personal subscription (Claude, OpenAI, xAI, etc.).
You can often switch models inside the same agent shell — a cheaper/faster model for routine work, a heavier one for hard problems.
Agentic / Agent
An AI that can take a series of actions on its own to complete a task, instead of just answering one question and stopping. It plans, does, checks the result, and adjusts — without you having to spell every step out.
If you ask an agent "publish a page summarising this document", it may read the doc, draft the page, save the file, push it, and confirm when it's live. That whole sequence is agentic behaviour.
Chat AI vs agentic app
Chat AI (ChatGPT, Claude.ai, Gemini in the browser, etc.): you ask, it answers. You still copy, paste, and do the work in other tools.
Agentic app: you describe a task; it can read your files, run commands, and use connectors. Use free chat tools to think and research; save the agent for work that needs files, tools, or multi-step action. See Efficient Usage.
Context
Everything the agent "knows" during a single session — your prompts, the files you've shared, what's been said so far in the conversation, and any standing instructions it's read.
Analogy: Context is the working memory of one conversation. When you start a new session, that memory resets — which is why putting the right files and standing instructions in the right place matters so much.
Prompt
Anything you type into the agent. Your message. Your question. Your instruction. That's a prompt.
The quality of your prompts has a huge effect on the quality of what you get back — but you don't need fancy "prompt engineering" tricks. Clear, specific, and complete usually does the job.
Skill / recipe / custom command
A reusable instruction set — a recipe for the agent to follow whenever you invoke it — so you don't have to re-explain how you want something done every time.
Different tools use different names: Skills (OpenCode, Claude, Grok), slash commands, custom instructions. Same idea. Example: a "weekly status update" recipe with your format and audience. See Using Skills.
Standing instructions (AGENTS.md / rules / CLAUDE.md)
A special file (or set of rules) in a folder that tells the agent standing instructions whenever it works there. Things like "this is a marketing project", "always use Australian English", "the stakeholders are X and Y", "use this tone".
Common filenames: AGENTS.md, CLAUDE.md, Cursor rules, project rules in Grok. Different tools, same job brief.
Analogy: Like a job brief the agent reads at the start of every session in that folder, so you don't have to repeat yourself.
Plan mode / Build mode (and similar)
Many agent shells have a read-only or planning mode (explore, plan, ask) and a full-action mode (build, agent, edit). Plan first to agree an approach; build when you're ready to change files. Names differ by product; the habit is universal.
MCP (Model Context Protocol) / MCP Server
A connector that lets your agent talk to another tool — email, chat, wiki, tickets, GitHub, almost anything. Once an MCP is set up, the agent can read from or write to that tool as part of a session.
Analogy: An MCP is like a USB cable between the agent and another system. The "server" part sounds technical, but it's just the bit doing the connecting — most MCPs are set up once and then forgotten about.
API (Application Programming Interface)
The way one piece of software talks to another. When an agent pulls a wiki page or posts a message to chat, it's using that tool's API behind the scenes.
Analogy: An API is like a service counter at a shop. You walk up, ask for something specific in a format the shop understands, and get something back. APIs are how every connected app on your phone talks to its servers.
API Key / Token
A password that lets the agent (or any other tool) use an API on your behalf. When you connect an agent to email or chat, you often give it a token so the service knows the requests are allowed.
Treat them exactly like passwords. Don't paste them into chats, don't share them in screenshots, don't put them in files that get shared. See Handling API Keys & Tokens Safely.
Repository / Repo
A folder of files stored on GitHub, with a full history of every change ever made to it. You work on a local copy on your laptop, and the master version lives in the cloud.
Analogy: Think of it as a folder with built-in version control and a permanent backup. Everything is saved, nothing is lost, and you can roll back if you make a mess.
GitHub / GitHub Enterprise
A place on the internet where files (especially code, but really anything text-based) live, with version history and access controls. The world's most popular place to store and share software.
Many large organisations also run their own private "GitHub Enterprise" instance — same product, but only accessible to their employees and behind their corporate network. If your workplace has one, it's safe for internal documents, playbooks, and team-shared files in the same way Confluence is.
The cloud
Just means "stored on a server somewhere on the internet, not on your laptop." That's it. Confluence, OneDrive, GitHub, Webex, Gmail — all cloud tools. The phrase makes it sound fluffy and abstract, but it really just means "not local."
Clone / Push / Pull / Commit
The four words you'll hear about GitHub. They sound technical but the ideas are simple — and agents can usually do all of these for you once you know roughly what they mean:
- Clone = download a repository to your machine for the first time.
- Commit = save a snapshot of your changes locally, with a short note describing what changed.
- Push = send your committed changes up to GitHub so they're saved in the cloud.
- Pull = grab the latest version from GitHub down to your machine (useful if you or someone else made changes elsewhere).
You don't have to type any of these as commands. Just ask the agent to "save my changes to GitHub" and it handles them.
Token (the other meaning — model context)
Confusingly, "token" means something different here than an API token. In the LLM world, a token is a small chunk of text the model processes — roughly three-quarters of a word. So "approximately" is one or two tokens; "OpenCode" is two or three.
Why it matters: every model has a limit on how many tokens it can hold in one conversation. Bigger limit = more context it can handle. You'll hear people talk about "context windows" measured in tokens (e.g. 200K tokens). For most non-technical use, you don't need to worry about it.
Hallucination
When an LLM confidently makes something up. The model doesn't always know what it doesn't know — so sometimes it invents a name, a date, a quote, or a fact that sounds plausible but isn't real.
This is a genuine risk to be aware of. The way to mitigate it: give the model good source material as context (so it has the real answer to draw from), and verify anything important before you publish or send it on. Don't take confident-sounding outputs at face value just because they sound right.