OpenAdminOS: AI Tools for M365 Admins

Key insights

• OpenAdmin OS, Lokka 2.0, Microsoft Graph Skill and MCP form a new admin story where AI agents act on Microsoft 365 and Azure using natural language.
  They use Microsoft Graph as the control plane and MCP as the connector layer to turn requests into API actions.


• MCP (Model Context Protocol) is an open standard that connects AI models to external tools and services.
  MCP mediates requests so an AI assistant can translate plain-language tasks into Microsoft Graph API calls safely.


• Lokka 2.0 is an open-source MCP server that lets admins manage tenants with natural language and supports Graph API version control.
  It runs on Node.js (22.10+) and works with clients like desktop agents or VS Code–based tools for interactive administration.


• Security and Microsoft Entra authentication limit what these tools can do; actions follow granted Graph scopes and tenant permissions.
  Authentication can use MSAL interactive sign-in, app certificates or client secrets, and token-based methods to keep access explicit and auditable.


• AI automation and less scripting help admins complete tasks faster by describing outcomes instead of writing PowerShell or manual Graph calls.
  Tools like Graph Studio and enhanced explorer experiences make iterative workflows and testing more practical.


• Local LLMs offer lower-latency and privacy options compared with cloud models, but you must keep data and models current for reliable results.
  Expect trade-offs in performance, and validate any automated changes before applying them in production.

Overview of the video

The YouTube video by Merill Fernando examines how AI agents and local models are shaping admin work for Microsoft 365 and Azure tenants. The host walks viewers through demos and core ideas, especially around tools like OpenAdminOS and Lokka 2.0, and explains how they connect to the platform via Microsoft Graph. Consequently, the episode frames a practical story: natural language requests can translate into real administrative actions when an intermediary protocol handles commands. Overall, the piece aims to show both promise and the real-world limits administrators should expect.

First, the program introduces the central protocol, MCP (Model Context Protocol), and explains how it standardizes AI access to external tools. Then, the presenter demonstrates live use cases, focusing on local deployment and agent-driven workflows that reduce the need for manual scripting. In addition, the video stresses that permissions, identity, and Graph API scopes remain the key controls that determine what agents actually can do. Finally, the episode ends with reflections on usability, security, and next steps for admins.

Key technologies explained

The video clarifies the role of MCP as a bridge between LLM-based agents and service APIs, meaning an AI can request a Graph API action instead of requiring the admin to write REST or PowerShell code. It also highlights Lokka 2.0 as an open-source server that implements MCP-style behavior so agents like Claude Desktop or VS Code–based tools can operate against tenant resources. Furthermore, the host contrasts the community tools with Microsoft's own preview of an MCP Server for Enterprise, which exposes similar functionality in a managed preview form. Therefore, viewers learn a clear architecture: agent -> MCP server -> Microsoft Graph.

In technical terms, the video notes practical requirements such as a recent Node.js runtime and Microsoft Entra authentication for Graph access, and it shows how Lokka supports both interactive sign-in and app credentials. It also points out that Lokka can choose Graph API versions per request, which helps test newer features while offering a way to lock to stable releases in production. These details speak to administrators who must balance agility and stability when enabling agents. Thus, the technology is presented as flexible but dependent on careful configuration.

Practical demos and admin workflows

The demonstrations focus on everyday admin tasks, from querying tenant state to making configuration changes, and they emphasize how natural language simplifies repetitive work. For example, instead of drafting a script to list users or check licenses, an admin can ask an agent and let MCP translate that intent into Graph calls. Additionally, the video shows interactive controls such as setting access tokens and requesting more scopes, which support iterative troubleshooting and development. As a result, the workflow appears faster for many tasks, especially for teams that want to prototype changes quickly.

However, the host also points out tradeoffs: the faster, language-driven approach risks over-reliance on agents if teams skip understanding the underlying APIs or permission boundaries. Moreover, while agents can speed routine checks, admins still need to verify outputs and understand rollback steps in case of mistakes. Therefore, Merill recommends using agent-driven automation as an augmentation rather than a full replacement for human oversight. This balance is central to the demonstrations and informs realistic adoption strategies.

Security, privacy and deployment tradeoffs

The episode discusses local versus cloud approaches and highlights that local LLMs and self-hosted MCP servers can improve data privacy because tenant data stays on premises or in controlled environments. At the same time, the host warns that local deployments require more infrastructure, regular model updates, and performance tuning, which raises operational cost and complexity. In contrast, cloud-hosted services reduce maintenance but require careful controls over telemetry and data flows. Consequently, teams must weigh privacy gains against the operational burden of local hosting.

Also, permission scope and identity design are central to safety: MCP only acts within the rights granted to the connected identity, so careful role design limits what agents can do. The video stresses best practices such as least-privilege permissions, multi-tenant isolation when needed, and auditing of agent actions to detect unexpected behavior. Finally, the host underscores that version control for Graph API access, and options to avoid beta endpoints in production, reduce risk when agents call newer features. Thus, security posture depends on both deployment choices and governance.

Challenges and future directions

Merill ends the video by discussing remaining challenges, including keeping AI responses up to date, managing model drift, and ensuring that multi-tenant or large-scale environments remain reliable under agent-driven changes. He notes that tools like Graph Studio and local Graph query models are promising but need better developer documentation and polished workflows for wide enterprise adoption. As a result, the path forward involves both product maturity and stronger operational patterns from admins. In short, the concept is compelling but still requires careful rollout planning.

Looking ahead, the video suggests that improved connectors, clearer standards, and more enterprise-grade MCP implementations could make AI-assisted administration mainstream. Nevertheless, organizations must adopt a staged approach: pilot in safe environments, tune permissions and observability, and evaluate whether to host models locally or use cloud services. In conclusion, the episode by Merill Fernando provides a practical snapshot of where admin-focused AI stands today and offers a roadmap for thoughtful adoption.

https://hubsite365cdn001img.azureedge.net/SiteAssets/TopicImages/marvin-meyer-SYTO3xs06fU-unsplash.jpg

Keywords

AI for Microsoft 365 admins, OpenAdminOS guide, Lokka 2.0 features, Microsoft Graph Skill tutorial, MCP exam M365, M365 admin AI tools, AI-driven automation for M365, OpenAdminOS vs Lokka comparison