# Glossary > Short definitions of the terms these pages use, such as action, coordinator, specialist, confirmation, channel, MCP and A2A. - URL: https://docs.mentoragent.net/reference/glossary - Verified with: MentorAgent 1.0.0 - Last updated: 2026-10-13 - Packages: Novior.MentorAgent This page defines the words that the MentorAgent documentation uses. Each word has one meaning on every page. ## Agents, actions and tools Agent : A model with instructions and tools, run by Agent Framework. "The agent" is the one your application runs: the coordinator, with its specialists and teams. Coordinator : The main agent. It receives every message from the user, calls your actions, specialists and teams, and writes the reply. Specialist : An agent with its own instructions and tools, defined by a class with `[MentorAgent]` or by a YAML file. The coordinator hands requests to it. Handoff : Passing a request from the coordinator to a specialist, through the `route_to_specialist` tool and a small router agent. Router : The small agent, with none of your tools, that chooses which specialist gets a handed-off request. Team : A group of agents, defined by a class with `[MentorTeam]`, that discuss a request in an Agent Framework group chat before the coordinator answers. Team member : One agent of a team, defined by a `[TeamMember]` property with a role and instructions. Remote agent : An agent on another host, listed in `RemoteAgents`. The coordinator reaches it over A2A in the same way as a specialist. `[MentorAgent]` : The attribute that marks a specialist. Without brackets, MentorAgent is the library. Action : A public method of one of your services that MentorAgent offers to the model as a tool, because it has `[Description]` or `[MentorAction]`. Read-only action : An action that you declare as one that only reads, with `ReadOnly` on `[MentorAction]` or with `IsReadOnlyAction`. MentorAgent takes your word for it. An action that needs confirmation is never read-only. Tool : Anything the model can call during a turn: your actions, MCP tools, the methods of skills, team tools, and built-in tools such as `route_to_specialist` and `navigate_to`. Tool name : The name the model sees: the method name in snake case, without a trailing `Async`. So `CloseCaseAsync` becomes `close_case`. Required call : A tool call that the first model call of a turn must make. `RequireLookupForRecordQuestions` and `RequireActionForChangeRequests` ask for one when a classifier says that the message calls for it. Core tools : The tools that tool filtering always sends: navigation, memory, delegation to specialists and teams, skills and UI actions. Skill : Instructions the agent loads only when a request needs them: a class with `[MentorSkill]` or a `SKILL.md` file, turned on with `EnableSkills`. Page context : The data that an interactive page gives the agent through `IMentorPageContext`, such as the record the user has selected. UI action : An action that runs on the current page, registered by the page through `IMentorPageContext`. Turn : One user message and everything the agent does to answer it, model calls and tool calls included. Member turn : One time a team member speaks in the group chat. `MaxIterations` limits how many there are. ## Rules: roles and confirmation Role : A role claim of the signed-in user (`ClaimTypes.Role`), checked against the `RequiredRoles` of an action. Confirmation : The question the user answers before an action runs. A `[MentorAction]` asks for it when it declares `RequiresConfirmation = true`. With the default `RequireConfirmationForWrites`, it also asks when it declares neither `ReadOnly = true` nor `RequiresConfirmation`. A tool matched by `RequiresApproval` asks too. Confirmation box : The box the widget shows with the action, its arguments, and the Confirm and Cancel buttons. Approval : Agent Framework's name for a confirmation. These pages use it only in API names (`RequiresApproval`, `AutoApprovalRules`, `/mentor/approve`) and for the approvals that hosted MCP servers ask for. Gated : Said of an action or tool that has a rule: a required role, a confirmation, or both. "Role-gated" means it has `RequiredRoles`. Withheld : Not offered to the caller: the action is missing from the tool list, and a call by its name runs nothing. Refused : The call reaches MentorAgent, the method does not run, and the model receives an error. Grounding rule : The rule MentorAgent adds to the prompts it writes: state only facts that a tool returned. User : The person who writes to the agent: a signed-in user, or an anonymous user who has not signed in. Caller : Whatever sends a request to an endpoint: a user's client, an MCP client or another agent. Stop : The request that ends the current turn: the widget's Stop button, or `POST /mentor/cancel`. ## Channels, hosts and clients Channel : The way a client reaches the agent: the widget, the SignalR hub, Server-Sent Events, the MCP server or the A2A server. Host : The .NET application that calls `AddMentorAgent()` and runs the agent: an ASP.NET Core app, or a .NET MAUI app. Backend : An ASP.NET Core host with `Novior.MentorAgent.Server` that serves clients running elsewhere: a WebAssembly client, a JavaScript front end or a mobile app. Client : Whatever sends messages to the agent: the widget, your own UI, an MCP client or another agent. Front end : The user interface: the widget, or your own UI in React, Angular, Vue or a mobile app. Widget : The ready-made chat UI of MentorAgent, ``, for Blazor and .NET MAUI apps. Circuit : The connection that Blazor Server keeps with each browser tab. Each circuit has its own coordinator and conversation. Hub : The SignalR hub of `Novior.MentorAgent.Server` at `/mentor-hub`. A conversation lasts as long as the connection. Server-Sent Events (SSE) : The `/mentor/chat` endpoint, which streams one answer as a series of events. Each request is a new conversation. MCP (Model Context Protocol) : An open protocol that lets AI applications list and call tools. Your app is an MCP server at `/mcp`, and an MCP client of the servers in `McpServers`. A2A (Agent-to-Agent protocol) : An open protocol that lets agents send tasks to each other. Your app is an A2A server at `/a2a`, and calls the remote agents in `RemoteAgents`. Agent card : The JSON document at `/.well-known/agent-card.json` that describes your agent to other agents: name, description, A2A skills and endpoint. A2A skill : An entry of the agent card that tells callers one thing your agent can do. MentorAgent lists one for each action without rules. Task : A request that another agent sends to your A2A server. MentorAgent runs it as one full turn, in a new session, and returns the whole reply. Orchestrator : A program or agent that splits a job among other agents and sends them tasks, for example over A2A. It is not the coordinator. .NET MAUI Blazor Hybrid : A .NET MAUI app whose UI is Blazor inside a `BlazorWebView`. MentorAgent builds for Android and Windows inside it. Windows is the platform that has been run; iOS and Mac Catalyst are not checked. ## Models, knowledge and conversation Model key : The API key of your model provider. Model provider : The service that runs the model, such as OpenAI, Azure OpenAI or Ollama. History provider : The `ChatHistoryProvider` that stores the messages of a conversation. Without one, MentorAgent keeps them in memory. Path A, Path B : The two ways to give MentorAgent a model. Path A is `ChatClient`, and MentorAgent builds the agent. Path B is your own `AIAgent` in `Agent`. Embedding model : A model that turns a text into a list of numbers that represents its meaning, so that MentorAgent can compare texts. RAG (retrieval-augmented generation) : For each message, before the coordinator answers, MentorAgent adds to the prompt the most relevant documents from your own knowledge base. RAG source : The class that searches your documents for RAG. It implements `IMentorRagSource`. Tool filtering : With `EnableToolFiltering`, the model receives only the actions closest in meaning to the message, not all of them. When none is close enough, it receives the three best-ranked actions that need no confirmation and no role. Model routing : Choosing, for each turn, between `ChatClient` and a stronger, more expensive `StrongChatClient`. Hosted tool : A tool that runs at the model provider, not in your app, such as web search or the code interpreter. Roles and confirmation do not apply to it. Classifier : The model that makes MentorAgent's own short decisions: the safety checks, the off-topic check, the facts to remember, and the question behind `RequireLookupForRecordQuestions` and `RequireActionForChangeRequests`. You set it in `ClassifierChatClient`. Safety check : An extra model call, before the answer, that checks each message for prompt injection, jailbreaks and attempts to extract the system prompt or credentials (`EnableSafetyCheck`). The output safety check (`EnableOutputSafetyCheck`) checks the reply before the user sees it. Off-topic check : A check on whether a message is about your application. `RefuseOutOfScope` refuses a message that plainly has nothing to do with it, and answers when unsure. `HostedToolDomainCheck` is stricter: it keeps hosted tools away from a message that is not about your application. Context window : The amount of text that the model reads at once. Conversation : The messages between a user and the agent, from the first message until a reset. Session : The object on the server that holds the state of one conversation (Agent Framework's `AgentSession`). Snapshot : The saved state of a conversation. `SerializeSessionAsync` returns it in clear, so keep it on the server or in `ProtectedLocalStorage`. `GET /mentor/session` returns a protected form that only the user who saved it can restore. History : The messages of the current conversation, which the model receives again at each turn. Reducer : The component that keeps the in-memory history short. The default, `MentorChatReducer`, removes whole turns, oldest first, and keeps every tool call with its result. Memory : Facts about a user that MentorAgent keeps across conversations, with `UseMemoryContext`. Prerelease : A version whose number has a suffix, such as `-rc.N`. `dotnet add package` installs it only when you pass the version or the `--prerelease` option. Pin : Give a package reference one exact version, such as `[1.17.0-preview.260804.1]`. --- - Previous: [Configuration options](https://docs.mentoragent.net/reference/options.md) - Next: [Changelog](https://docs.mentoragent.net/changelog.md)