Connect Degreed to AI Agents: Sync learning data and skill ratings

You want to connect Degreed to an AI agent so your system can autonomously analyze learning pathways, assign required training, update skill ratings, and log course completions based on employee context. Here is exactly how to do it using Truto's /tools endpoint and SDK, bypassing the need to build, host, and maintain a custom REST integration from scratch.

Giving a Large Language Model (LLM) read and write access to your Degreed instance is an engineering headache. You either spend weeks reading API documentation, dealing with complex nested payload structures, and maintaining OAuth token lifecycles, or you use a managed infrastructure layer that handles the boilerplate for you. If your team uses ChatGPT, check out our guide on connecting Degreed to ChatGPT, or if you are building on Anthropic's models, read our guide on connecting Degreed to Claude. For developers building custom autonomous workflows, you need a programmatic way to fetch these tools and bind them to your agent framework.

This guide breaks down exactly how to fetch AI-ready tools for Degreed, bind them natively to an LLM using frameworks like LangChain, LangGraph, CrewAI, or the Vercel AI SDK, and execute complex Learning Management System (LMS) workflows. For a deeper look at the architecture behind this approach, refer to our research on Architecting AI Agents and the SaaS Integration Bottleneck.

Why a Unified Tool Layer Matters for Agent Safety

Before writing a line of integration code, you must decide what layer your agent interacts with. This choice determines the reliability, stability, and safety of your production system.

Direct API tools - exposing one tool per raw Degreed endpoint - look convenient on paper but push provider-specific API quirks directly into the LLM's context window. The model has to remember that Degreed uses strict JSON:API formatting, that specific endpoints require complex relationship objects, and that creating content visibility groups requires strict privacy level matching. Every one of those vendor-specific quirks is a hallucination waiting to happen.

Abstracting the API behind a standardized tool layer collapses these complexities. Your agent sees simple, deterministic function signatures like create_a_degreed_skill_rating or list_all_degreed_user_required_learnings instead of raw REST paths. That gives you concrete safety wins:

1. Smaller attack surface for hallucination. The LLM only chooses from explicitly defined, well-scoped function names. It never invents query parameters or payload structures.
2. Deterministic input validation. Every tool has a strict JSON schema. Invalid arguments are rejected at the proxy layer before they ever hit Degreed, meaning a broken tool call fails fast and returns a clear error message to the agent for self-correction.
3. Decoupled authentication. The LLM never sees or handles OAuth tokens. Authentication is managed out-of-band by Truto, completely removing the risk of credential leakage in agent logs.

The Engineering Reality of the Degreed API

Giving an LLM access to external data sounds simple in a prototype. You write a Node.js function that makes a fetch request and wrap it in an @tool decorator. In production against complex enterprise systems like Degreed, this approach immediately collapses.

Degreed's API introduces several specific integration challenges that break standard REST assumptions. If you hardcode these interactions into your agent, you will spend your sprints writing defensive integration code instead of improving your model's reasoning capabilities.

The JSON:API Specification Trap

Degreed strictly adheres to concepts from the JSON:API specification. Standard LLMs are trained to expect flat, intuitive JSON objects. When an agent wants to create a skill rating, it naturally attempts to send a payload like {"user_id": "123", "skill": "Python", "rating": 5}.

Degreed will reject this immediately. The API requires heavily nested structures defining data, type, attributes, and relationships. If you expose the raw API to the LLM, you have to burn massive amounts of context tokens explaining exactly how to format a JSON:API payload. By using Truto's proxy APIs, the heavy lifting of mapping flat arguments to nested relationships is handled by the schema definition, preventing constant HTTP 400 Bad Request errors.

Visibility Group Privacy Constraints

Degreed allows you to assign visibility groups to content (like videos, podcasts, and articles). However, the API enforces strict domain rules: all visibility groups applied in a single call must share one privacy level - they must be entirely Administrative or entirely non-Administrative (Open, Closed, Private). If an LLM attempts to mix these levels, the operation fails. A well-defined proxy tool schema constraints the LLM to valid enums and array structures, enforcing this business logic at the schema level.

Asynchronous Refresh Triggers

Some endpoints in Degreed behave asynchronously based on user activity. For example, fetching data for list_all_degreed_user_todays_learnings only returns fresh data if the user has logged in within the last 48 hours or has daily/weekly digest emails enabled. An autonomous agent polling this endpoint continuously for updates will simply burn through API quota. You must instruct the agent on the nature of this data staleness, and handle rate limiting gracefully when it gets aggressive.

Hero Tools for Degreed AI Agents

Instead of exposing the entire Degreed surface area, you should provide your agent with high-leverage proxy tools. Truto automatically generates a comprehensive JSON object that represents how the underlying API behaves, mapping resources to predictable methods.

Here are the most powerful tools to expose to your Degreed AI agent.

list_all_degreed_user_user_skills

This tool retrieves all skills associated with a specific user. It handles the pagination of up to 1000 records per page and accepts identification via Degreed ID, Employee ID, or email address. This is critical for agents performing skill gap analyses.

"Fetch the complete skill profile for employee ID 84729. I need to know their current proficiency levels in cloud architecture and Python to determine if they meet the Senior Engineer baseline."

create_a_degreed_user_skill

When a user demonstrates a new competency, this tool allows the agent to associate a new skill with their profile. If the skill does not already exist in the organization's ontology, Degreed creates it automatically.

"Add 'Kubernetes Administration' to John Doe's profile. He just provided proof of his CKA certification in our internal ticketing system."

list_all_degreed_user_required_learnings

Retrieves the mandatory learning items assigned to a specific user. This is vital for compliance agents ensuring that employees have completed required security or HR training within a specified date range.

"Check the required learning queue for sarah.smith@company.com. If she has any pending SOC 2 compliance training that is overdue, send an escalation alert."

create_a_degreed_completion

Logs a new completed learning event for a user. This is heavily used by agents that monitor external systems (like a vendor's certification portal or an internal Wiki) and sync those accomplishments back into Degreed.

"Log a completion record for Marcus for the 'Advanced TypeScript Patterns' external course. Set the completion date to today and attach the provided certificate ID."

create_a_degreed_skill_rating

Submits a new skill rating (Manager, Peer, or Self-rating) for a user. AI agents can use this tool to aggregate feedback from pull requests, Jira tickets, or peer reviews and programmatically update the user's standing in Degreed.

"Based on the quarterly peer review data, submit a Manager skill rating of 4 out of 5 for Elena's 'Project Management' skill."

list_all_degreed_skill_plans

Fetches all skill plans available in the current Degreed organization. Agents use this to understand what structured learning pathways exist before deciding which one to recommend to an employee.

"List all active skill plans in the organization. Find the one most relevant to 'Data Engineering' and return its ID so I can assign it to the new hires."

To view the complete inventory of available proxy tools, authentication parameters, and OpenAPI schemas for Degreed, visit the Truto Degreed integration page.

Workflows in Action

Providing an LLM with isolated tools is just the foundation. The real value emerges when the agent chains these tools together to execute complex, multi-step workflows autonomously.

Scenario 1: Automated Skill Gap Analysis and Assignment

The Prompt:

"Analyze Jane's current skills. If she lacks 'React Native' proficiency required for her new role, assign her the mobile development skill plan and log an initial baseline self-rating of 1."

Agent Execution:

1. list_all_degreed_user_user_skills: The agent fetches Jane's existing skill array to verify if 'React Native' is present and at what level.
2. list_all_degreed_skill_plans: The agent queries the organization's catalog to find the ID of the mobile development skill plan.
3. create_a_degreed_user_skill: Seeing a gap, the agent creates the 'React Native' skill association on Jane's profile.
4. create_a_degreed_skill_rating: The agent submits the initial baseline rating of 1 to establish her starting proficiency.

The Result: The system autonomously prepares the employee for her new role transition without HR intervention, ensuring her LMS profile accurately reflects her current state and targets.

Scenario 2: Syncing External Certifications to Completions

The Prompt:

"Monitor the external certification webhook. When an employee passes an AWS exam, log the completion in Degreed and update their cloud architecture skill rating to 5."

Agent Execution:

1. list_all_degreed_users: The agent takes the email address from the webhook payload and resolves it to a Degreed user ID.
2. create_a_degreed_completion: The agent logs the AWS certification as a completed external item, providing the exact timestamp and certification metadata.
3. create_a_degreed_user_skill: The agent ensures 'AWS Cloud Architecture' is listed on the user's profile.
4. create_a_degreed_skill_rating: The agent sets the skill proficiency rating to 5 based on the certification pass.

The Result: Your organization's skill matrix stays perfectly up-to-date in real-time, eliminating the manual data entry typically required to sync external learning platforms with your internal LMS.

Building Multi-Step Workflows

To execute these workflows in production, you need to connect your agent framework to Truto's proxy APIs. Truto handles the OAuth authentication, pagination normalization, and schema validation.

Every integration on Truto operates as a comprehensive JSON object, exposing Resources and Methods. You interact with the GET /integrated-account/<id>/tools endpoint to retrieve these schemas and bind them to your LLM.

Here is how to structure this using the Truto SDK and Langchain.js. This exact pattern applies to the Vercel AI SDK, CrewAI, or any framework that supports native tool calling.

import { ChatOpenAI } from "@langchain/openai";
import { AgentExecutor, createToolCallingAgent } from "langchain/agents";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { TrutoToolManager } from "truto-langchainjs-toolset";
 
async function runDegreedAgent(integratedAccountId: string, userPrompt: string) {
  // 1. Initialize the Truto Tool Manager with your API key
  const toolManager = new TrutoToolManager({
    apiKey: process.env.TRUTO_API_KEY
  });
 
  // 2. Fetch all proxy APIs for the specific Degreed integrated account
  // You can filter by method types (e.g., read, write, custom) using query parameters
  const tools = await toolManager.getTools(integratedAccountId);
 
  // 3. Initialize your LLM
  const llm = new ChatOpenAI({
    modelName: "gpt-4o",
    temperature: 0,
  });
 
  // 4. Bind the Truto proxy tools to the LLM natively
  const llmWithTools = llm.bindTools(tools);
 
  // 5. Define the agent's behavior and system constraints
  const prompt = ChatPromptTemplate.fromMessages([
    ["system", `You are an autonomous HR and LMS administrator.
    You manage user skills, ratings, and learning completions in Degreed.
    Always verify a user's existing skills before adding new ones.
    If you encounter an HTTP 429 error, you must stop and wait.`],
    ["human", "{input}"],
    ["placeholder", "{agent_scratchpad}"],
  ]);
 
  const agent = createToolCallingAgent({
    llm: llmWithTools,
    tools,
    prompt,
  });
 
  const executor = new AgentExecutor({
    agent,
    tools,
    maxIterations: 10,
  });
 
  try {
    const result = await executor.invoke({ input: userPrompt });
    console.log("Workflow Complete:", result.output);
  } catch (error) {
    console.error("Agent execution failed:", error);
  }
}

Handling Rate Limits (HTTP 429)

When building autonomous agents that execute API calls in tight loops, rate limiting is your biggest operational threat. An LLM executing a for loop to update 50 user skills will quickly trigger Degreed's rate limit thresholds.

Crucial Architectural Note: Truto does not retry, throttle, or apply backoff on rate limit errors automatically. When the upstream Degreed API returns an HTTP 429, Truto passes that error directly to the caller.

However, Truto normalizes the upstream rate limit information into standardized HTTP headers per the IETF specification:

• ratelimit-limit: The maximum number of requests permitted in the current window.
• ratelimit-remaining: The number of requests remaining.
• ratelimit-reset: The time at which the rate limit window resets.

Your agent execution loop is responsible for handling these errors. You must intercept the 429 response, read the ratelimit-reset header, and halt the agent execution until the window clears. Relying on the LLM to "try again later" will just result in immediate failures and wasted tokens. Implement explicit backoff logic in your tool execution wrapper.

sequenceDiagram
    participant App as Agent Framework
    participant Truto
    participant Degreed as Degreed API

    App->>Truto: GET /integrated-account/<id>/tools
    Truto-->>App: Returns JSON tool schemas
    App->>App: bindTools() to LLM
    App->>Truto: Execute create_a_degreed_user_skill
    Truto->>Degreed: Proxies request with auth & pagination
    Degreed-->>Truto: 429 Too Many Requests
    Truto-->>App: 429 Error with ratelimit-reset header
    App->>App: Parse header & sleep thread
    App->>Truto: Retry execution after reset
    Truto->>Degreed: Proxies request
    Degreed-->>Truto: 200 OK + payload
    Truto-->>App: Standardized JSON response

The Strategic Advantage of Proxy APIs

Building AI agents requires shifting your engineering focus from building point-to-point integration infrastructure to orchestrating model reasoning.

By leveraging Truto's proxy APIs and /tools endpoint, you offload the complexity of JSON:API formatting, OAuth token management, and pagination logic. Your agent interacts with a clean, deterministic schema that significantly reduces hallucination and execution errors.

Stop spending your engineering cycles writing defensive fetch requests for Degreed. Provide your agents with standardized, strongly-typed tools and let them focus on solving complex business problems.