TL;DR: A copilot assists a person on request. An agent carries out a task, well-governed ones act with approval and leave a log. An account brain is neither: it's the maintained, sourced state of your accounts that both should be reading from. Teams that skip the distinctions buy the wrong layer, which is one reason Gartner predicted in 2024 that at least 30% of gen AI projects would be abandoned after proof of concept. The teams that get the layers right see results like Sellsy's: 3x accounts per implementation manager.

Sit through three AI vendor demos in a week and you'll hear "copilot," "agent," and "AI workspace" used for products that share almost nothing. The confusion isn't cosmetic: implementation leaders keep budgeting for one layer and receiving another, then wondering why the tracker is still stale. This glossary defines the working vocabulary for delivery teams, one term at a time, with the boundaries that actually decide purchases. For onboarding-process vocabulary (kickoff, go-live, TTV), see the customer onboarding glossary, this one is the AI stack.

The core three

AI copilot: An assistant embedded where a person already works, drafting and summarizing on request. Microsoft's sits across Outlook and Teams from $18 per user per month, Google's ships inside Workspace at $14. Boundary: a copilot amplifies the person asking. It holds no account state and initiates nothing.

AI agent: Software that carries out a multi-step task, gathering context, drafting, acting in tools. The governance line matters more than the label: a production-grade agent names its actions, waits at an approval gate for anything customer-visible or record-changing, and writes an audit trail. Tandem's agents (CRM updates, follow-up drafts, weekly reports, unanswered-client alerts) run exactly that way. An "agent" with none of those three properties is a demo.

Account brain: The maintained, sourced state of each customer account, built continuously from calls, Slack, email, CRM, and tickets, every fact pointing back to its source. It's the layer copilots and agents should read from, and the one most stacks are missing, the full definition and anatomy is here. Also called a project brain. Tandem's implementation is the reference for this glossary's claims.

The boundary table

  • Spreadsheets + Slack (the incumbent). Initiates on its own: No. Holds account state: Hand-typed, stale. Acts in your tools: No. Typical failure when missing: Everything below, simultaneously.
  • Copilot. Initiates on its own: No. Holds account state: No. Acts in your tools: Within its suite. Typical failure when missing: Individual speed, unchanged team outcomes.
  • Chat assistant (ChatGPT, Claude). Initiates on its own: No. Holds account state: Per-project snapshots you curate. Acts in your tools: Per-session, supervised. Typical failure when missing: Confident answers from stale uploads.
  • Agent. Initiates on its own: Sometimes (on triggers). Holds account state: Not inherently. Acts in your tools: Yes, gated. Typical failure when missing: Actions without state = confident mistakes.
  • Enterprise search. Initiates on its own: No. Holds account state: Indexes documents. Acts in your tools: No. Typical failure when missing: Finds files, not truth.
  • Account brain. Initiates on its own: Yes, standing detection. Holds account state: Yes, curated + sourced. Acts in your tools: Via its agents, with approval. Typical failure when missing: This is the missing layer in most stacks.

The supporting cast

Assistant vs copilot: Marketing distinction, mostly. "Assistant" usually means the standalone chat product, "copilot" the embedded one. Neither term implies state or initiative.

MCP (Model Context Protocol): The open standard for connecting AI applications to external systems, "like a USB-C port for AI applications," in the project's own words. It's how a chat assistant reads and writes an account brain. Boundary: MCP is transport. It is not memory, a stack of connectors still holds no state.

RAG (retrieval-augmented generation): Fetching relevant documents at question time and letting the model answer from them. Powerful, and per-question: retrieval varies run to run, and quality falls as the pile grows, the pattern behind context drift. A brain differs by curating facts once, continuously, instead of re-deriving truth per question.

Context window: How much text a model considers at once. Bigger windows didn't solve delivery memory: Chroma's research across 18 models found reliability degrading as input grows.

Proactive (standing) detection: Monitoring that runs on events rather than prompts and raises risks with evidence attached. The single capability that separates outcome-moving deployments from personal productivity, and the one no ask-driven tool provides.

Approval gate / audit trail: The human sign-off before an agent's action lands, and the log of what it did. Non-negotiable vocabulary: any agent pitch missing either word should end the meeting.

AI workspace: The category label for products combining state, detection, agents, and interfaces for a specific job. Tandem is the AI workspace for implementation and deployment teams. Boundary: a workspace is defined by the job it holds state for, a general workspace is a chat product wearing the label.

Hallucination: A fluent answer with no grounding in the sources. The delivery-team defense isn't a better model, it's provenance: answers that carry their evidence can be checked in one click, answers that can't will eventually be checked the hard way.

System of record: The tool a team treats as authoritative for a data type, Jira for tasks, the CRM for the relationship. An account brain doesn't replace systems of record. It reads them, reconciles them against what was actually said, and writes back through sync.

Human in the loop: The design principle that a person approves consequential actions. In vendor demos, test it with one question: show me an action the agent proposed and a human rejected, and where that rejection is logged.

Two-way sync: Changes propagate in both directions between the brain and the tracker, so one update never has to be typed twice. The difference between an integration and a read-only mirror.

Grounding vs fine-tuning: Two ways to make a general model useful on your data. Grounding feeds it current facts at answer time and is what brains and RAG do. Fine-tuning bakes patterns into the model itself, expensive, slow to update, and the wrong tool for account state, which changes daily. If a vendor says "we fine-tune on your data" in a delivery context, ask them why.

Workflow automation vs agent: Automation runs a fixed recipe on a trigger (call ends, post the summary). An agent decides steps within a goal and boundary. Both are useful, automations are cheaper and more predictable, and plenty of "agentic" marketing describes automations. The tell is whether the software ever chooses between actions or just executes the one it was wired to.

How to use this vocabulary in a vendor meeting

The glossary earns its keep in evaluations, so here's the 15-minute script. Open by asking the vendor to place their product in the boundary table above: which layer are you? Products that claim all layers at once get the follow-ups, products that name their layer honestly get shortlisted.

Then three questions, one per layer. For state: "Show me one fact about a real account, and click through to its source." Timing matters, watch whether provenance is native or a scramble. For detection: "What did your product surface last week that nobody asked for, and what evidence came with it?" Demos are rehearsed around the pull, this question tests the push. For action: "Walk me through one agent action end to end, proposal, approval, execution, log." If any of the four steps is missing, you've found the demo's edge.

Close with the stack question: "What do you read from, and what reads from you?" A copilot should name its suite. An agent should name its state source. A brain should name its sources and its MCP surface. A product that can't answer is a product that hasn't decided what it is, and your delivery team shouldn't fund the discovery process.

Why the vocabulary pays

Because each term prices differently and fails differently. Copilot seats run $14 to $32 and make individuals faster. Agents without state make confident mistakes. Brains without agents are well-informed and idle. The stack that moves delivery numbers is all three in order, state underneath, detection on top, agents acting with approval, interfaces wherever your team lives, which is the pillar guide's whole argument. Terms in hand, the evaluation collapses to one question per vendor: which layer is this, and what does it read from? Sellsy bought the state layer and runs 3x the accounts per manager with the same team.

What stays manual

Definitions don't decide anything. Your team still owns scope, promises, and escalations, agents act only with approval, and a brain needs your playbooks configured before its plans mean much. One more boundary worth keeping: a forward deployed engineer is an engineer who spends roughly half their time with customers understanding the problem and half building the solution for that specific customer, and no layer in this glossary replaces that judgment.

Test the vocabulary against a live stack: a 20-minute demo shows all three layers on your own accounts, labeled.

FAQs

What's the difference between an AI copilot and an AI agent?

A copilot assists the person asking, drafting and summarizing on request. An agent carries out tasks, and a governed one acts through an approval gate with an audit trail. The practical test: who initiates, and does anything land in a system of record?

Is an account brain just a knowledge base?

No. A knowledge base stores documents people wrote. An account brain maintains facts extracted continuously from live sources, each with provenance, and retires what's superseded. The full definition covers what goes in one.

Do I need all three layers?

At small scale, no, a copilot may be plenty. Past roughly 15 accounts per manager, outcomes live in the state and detection layers, and skipping them is how teams end up in the 37%-see-no-EBIT-impact statistic.

A vendor calls their product an "AI teammate." Which layer is that?

Marketing for one of the three, and the boundary table sorts it in two questions: does it hold state, and does it act with an approval gate? "Teammate," "co-worker," and "digital employee" usually describe an agent bundle, so run the agent tests, named actions, approval, audit trail. If it also claims to remember your accounts, ask to click from one remembered fact to its source.

Where does MCP fit in the stack?

Between interfaces and everything else: it's the standard that lets your assistant read and write external systems, including an account brain. Transport, not state.

Key terms

Copilot: Request-driven assistant embedded in a person's tools. Amplifies individuals.

Agent: Task-executing software, production-grade means approval gates plus an audit trail.

Account brain: Maintained, sourced per-account state with standing detection. Reference implementation.

MCP: Open standard connecting AI applications to external systems. Transport layer.

Standing detection: Event-driven monitoring that raises risks unprompted, with evidence attached, the capability that separates a brain from every ask-driven layer above it.

Audit trail: The log of every agent action, who approved it, and what changed.