Bridging the Skill Gap: Connecting Degreed to AI Agents via MCP

I've spent a significant portion of my career looking at dashboards that nobody uses.

Whether it was old-school CRM reports in 2005 or modern Learning Experience Platforms (LXP) today, the problem is always the same: the data is there, but it's trapped behind a UI. You have all this metadata about what your engineers know, what courses they've completed, and where your talent gaps are, but finding that information requires manual clicking, filtering, and exporting to CSVs just to ask a simple question like "Who on my team is ready for a Node.js migration?"

The Model Context Protocol (MCP) changes this by turning those static UI silos into an actionable toolset for AI agents. I recently spent some time digging into the Degreed MCP implementation on Vinkius, and it's a clear example of how we move from "chatting with a bot" to "orchestrating an intelligent workforce registry."

The Setup: Beyond Simple Search

When people think about integrating an LXP like Degreed into an AI workflow, they usually only think about one thing: searching for content. And yes, the search_learning_catalog tool is there to do exactly that. You can ask your agent to find 'Data Science with Python' courses, and it will return a ranked list of materials based on titles and skill tags.

But if you only use an MCP for searching, you're missing 80% of the value. The real engineering utility lies in the correlation between content, users, and skills.

An agent with access to this specific Degreed integration doesn't just act as a librarian; it acts as a talent analyst. Because the toolset includes list_defined_skills and get_user_profile, you can build complex reasoning loops.

Imagine this workflow:

1. The Query: "We are starting a new project in Go. Do we have enough internal expertise?"
2. Step 1 (Discovery): The agent calls list_defined_skills to see how 'Go' or 'Golang' is represented in the company taxonomy.
3. Step 2 (Mapping): It then iterates through users via get_user_profile or searches for specific skill ratings within the organization.
4. Step 3 (Gap Analysis): Once it identifies a lack of proficiency, it automatically calls search_learning_catalog to suggest an immediate learning path for the team.

This isn't just automation; it's turning unstructured learning behavior into structured organizational intelligence.

Deconstructing the Toolset

To understand how to build these agents, you have to look at what the tools actually expose. The Degreed MCP breaks down into three distinct layers:

1. The Catalog Layer (search_learning_catalog, get_content_details, list_learning_content)

This is your entry point. It handles retrieval of metadata—titles, providers, and durations. If you're building an agent to assist L&D managers, this is where they will spend most of their time. The ability to resolve detailed descriptions through get_content_details allows the LLM to actually understand the substance of a course before recommending it.

2. The Identity & Skill Layer (list_degreed_users, get_user_profile, list_defined_skills)

This is where the 'intelligence' happens. By exposing user metadata including professional titles and organizational affiliations, the agent can perform demographic-based skill analysis. You aren't just looking for a person who knows React; you are looking for a Senior Engineer in the London office who has reached 'Proficient' level via specific pathways.

3. The Observability Layer (list_active_learners, list_user_completions, list_learning_plans)

This is arguably the most critical part for leadership. It allows an agent to monitor progress. You can ask, "Which team members have completed their security training this quarter?" via list_user_completions. This turns competence tracking from a periodic manual audit into a real-time stream of data available via natural language.

The Reality Check: Constraints and Security

I’ve always been a proponent of being honest about what a tool can't do. If you try to use this MCP to automate the administrative side of talent management, you're going to hit a wall.

Currently, this integration is focused on discovery and monitoring. You cannot use the agent to assign new courses or modify user profiles; those actions still happen within the Degraw dashboard or mobile app. The agent is an observer and a researcher, not a writer of the system's state.

From a security perspective, which I know is often where these integrations fall apart in production: this requires OAuth 2.0. You'll need your Degreed Client ID and Client Secret. When setting this up on Vinkius, the connection is handled through secure tokens, but you are still responsible for managing those credentials within your environment.

If you want to see how this looks in a production-grade setup—specifically regarding how we handle the isolated V8 sandboxing and the governance policies that prevent things like SSRF when an agent is querying external APIs—you can check out the implementation here: https://vinkius.com/mcp/degreed.

Why this matters for the next generation of AI agents

We are moving away from LLMs that just 'know things' to agents that 'do things' with our proprietary data. The bottleneck has never been the model's reasoning; it has always been the friction of connecting that reasoning to a reliable, authenticated source of truth.

When you can bridge an agent directly to your company's learning taxonomy, you aren't just building a chatbot. You are building a layer of organizational memory that can respond to change in real-time.

If you're working on L&D automation or talent intelligence, this is the starting point.

---

MCPs are the music of AI Agents. We built the catalog. Discover Vinkius MCP Catalog.