The AI agents of your applications, under your control.

MentorAgent runs inside your .NET application. It takes what your systems already do, applies your rules, and brings the same agent to every place your users work: the browser, a phone, an AI assistant, another agent or a script.

• Open beyond .NET

  The core is .NET; what surrounds it can be written in other languages. Front ends connect through SignalR or Server-Sent Events; tools and agents through MCP and A2A, which have official SDKs for Python, JavaScript, Java, Go and more.

• Installs where your app runs

  It's a library inside an ASP.NET Core app on .NET 10: Windows or Linux, a container, the cloud or your own servers. It sends no telemetry to its authors.

• Your model, cloud or local

  Azure OpenAI, OpenAI, or a local model with Ollama. With a local model, the conversation and the data your actions read stay inside your network.

Read the full story on the blog

Your code decides what the agent can do. Who may run each action, what needs a confirmation, which limits apply and what it costs: you declare it in C#, next to your methods, and MentorAgent applies it on every channel. A rule in a prompt can be talked around; a check in your code cannot.

• Who can do what

  Each action lists in RequiredRoles the roles that may run it. MentorAgent checks them against the signed-in user before anything else: without the role, the model is not even offered the action. For rules per company or per record, MentorAgent asks your own IMentorActionPolicy before every call.

• A confirmation before changes

  A [MentorAction] that changes data asks the user first and shows the values it is about to use. Actions that only read declare ReadOnly = true and run straight away.

• The same rules on every channel

  Widget, SignalR hub, SSE, MCP and A2A apply the same checks. Where nobody can confirm, as over MCP and A2A, actions that need a confirmation are not offered.

• Limits and checks

  Messages per user and their length, questions outside your application, checks on incoming messages and on replies. You set each one in the options.

• Costs in view

  Only the tools a message needs reach the model, long conversations are shortened, and the stronger model answers only the turns that need it. A dashboard shows tokens and estimated cost per model.

• Visible in your monitoring

  Turns, tool calls, errors and blocked messages go to OpenTelemetry as traces and metrics, following the conventions for generative AI, into the tools you already use. Every decision on an action, who confirmed it included, also reaches an IMentorActionObserver of yours.

All of it ships in 1.2.0.

• One attribute, one action

  Put an attribute on a C# method and the agent can call it; you decide who may, and whether the user confirms first.

• Agents that delegate

  A main agent hands a request to a specialist, or several agents talk it through in a group chat before answering.

• The front end you prefer

  Drop in the ready-made Blazor widget, or build your own chat in React, Angular, Vue or a mobile app over SignalR or SSE.

• Open to other agents

  Publish your actions as an MCP server or an A2A agent, and let your agent call remote MCP tools and A2A agents.

• Your model, your costs

  OpenAI, Azure OpenAI, Foundry or a local model such as Ollama. Simple questions go to a cheaper model, the dashboard shows what each one costs, and every turn can be traced with OpenTelemetry.

• Answers from your knowledge

  RAG over your documents, per-user memory and Agent Skills. Each one runs only where you turn it on.

In a Blazor Web App with Server interactivity, with MentorAgent and your model's package installed (for OpenAI, Microsoft.Extensions.AI.OpenAI):

1. Describe the methods

   Mark the methods the agent may call with [MentorAction]: ReadOnly = true on those that only read. The others ask for confirmation.

2. Register the agent

   In Program.cs: the service with your methods, the model and the assembly to scan.

   Program.cs

   builder.Services.AddScoped<CaseService>();
   builder.Services.AddMentorAgent(options =>
   {
       options.AppName = "Case management";
       options.ChatClient = new OpenAIClient(builder.Configuration["OpenAI:Key"]
               ?? throw new InvalidOperationException("OpenAI:Key is missing: run "
                   + "dotnet user-secrets set OpenAI:Key <your-key>"))
           .GetChatClient("gpt-4o-mini")
           .AsIChatClient();
       options.ScanAssemblies = [typeof(Program).Assembly];
   });

3. Add the widget

   Add @using Novior.MentorAgent.Abstractions.Components to _Imports.razor and the widget to the layout.

   MainLayout.razor

   <ChatWidget />

Facts about how MentorAgent is built and released, each with the public source where you can check it.

• 23

  versions released since June 2026

  20 under the old name MentorAgent, then Novior.MentorAgent from 1.0.0. Today 1.2.0.

  NuGet ↗ (external site)

• No surprise breaking changes

  Every version is checked against 1.1.0: if a class or method your code uses would change in an incompatible way, the release stops.

  Directory.Build.props ↗ (external site)

• A list of what's inside every package

  Each package carries its SBOM, the standard list of the files and components it contains, so your security team can check it. Since 1.1.0.

  SECURITY.md ↗ (external site)

• Open source, traceable to the commit

  Apache 2.0. Every version since 1.0.0 has its tag and release notes on GitHub, and each package says which commit it was built from.

  GitHub ↗ (external site)

• Controlled releases

  Every version is built on clean cloud machines, never on a developer's laptop, and reaches NuGet only after a person approves it.

  SECURITY.md ↗ (external site)