For developers

An LMS built agent-first, with the API to match.

A 120-tool MCP server means an AI assistant can read a folder of documentation or a quarter of recorded calls and assemble a complete course: lessons, quizzes, media, all through the same service layer the admin screens call. Everything the agent can do, your code can do, over a documented REST API.

Book a demo

Start a seven-day free trial. Sandbox workspaces and test keys included.

Most learning platforms are a UI with an export button.

The training surface ends up being the one part of the stack nobody can build on: no real API, no way to run it inside your own product, and an integration story that stops at a scheduled file drop.

  • No programmatic authoring

    A course is something a person clicks together in somebody else's editor, so it cannot be generated, tested, or kept in step with a repo.

  • An embed, not a platform

    What you get to put in your own app is an iframe with somebody else's chrome around it and their session cookie inside it.

  • Data behind glass

    Progress exists and reaches you as a nightly file rather than as an event you can subscribe to and act on.

Agent-first

The MCP server is the product surface, not a wrapper on it.

Peerfold's MCP server is a thin adapter over the same service layer the admin UI and the REST API call. An agent authors through the product's own rules rather than around them, and the guardrails stay server-side where they cannot be argued with.

How it goes

  1. 1Connect Claude, Cursor, or any MCP-compatible assistant to a workspace with a scoped key.
  2. 2Ask it to build a course from a documentation folder or a set of call transcripts. It drafts the outline, writes the lessons, authors the quizzes and places the media.
  3. 3Publish is its own explicit tool and never a side effect, and every write it made is in the audit log.
  • 40+ MCP tools across authoring, enrollment, commerce and reporting
  • WebMCP page tools: the admin publishes tools to the browser's agent surface, and they stage rather than press
  • An Agent DevKit that hands any coding assistant the files it needs, and never carries a secret

A public API, three delivery modes, one service layer.

The hosted portal, a HubSpot Content Hub site and your own React app all read the same API. Nothing about the product is reachable from only one of them.

01

The API

OpenAPI 3.1, spec first

  • A complete REST API

    The learner plane and the admin plane, both documented, with API keys, per-tenant CORS, rate limits and idempotency keys.

  • The spec is the source of truth

    The OpenAPI document generates the route validation, the typed client and the agent tool schemas, and CI fails on drift between them.

  • Signed webhooks

    A twenty-three-event catalog, HMAC-signed, with delivery management and replay in the app.

  • Errors you can branch on

    Every non-2xx response is an RFC 7807 problem document with a stable machine code, and the reference is public.

02

Headless

The whole product, inside your app

  • Headless LMS

    Courses, SCORM, exams, certificates, deadlines and progress served to your own frontend. The full platform, not a stripped-down embed.

  • Headless community

    Spaces, discussions, profiles and standing living inside your app instead of next to it, on the same member identity.

  • SDKs and embeds

    A typed API client, React hooks, a small browser bundle, and an embeddable cart for a marketing site you do not control.

  • Sandbox and headless auth

    PKCE flows, token exchange, and sandbox tenants with test keys, so an integration gets built somewhere it cannot hurt anybody.

03

Where it runs

Hosted, HubSpot, or your own frontend

  • Hosted portal

    The white-label learner portal on the customer's own domain, with managed SSL and no code at all.

  • HubSpot Content Hub

    Companion modules keep the learner experience inside a HubSpot website, and progress flows back to Peerfold and the CRM.

  • Your own app

    Next.js, a HubSpot React theme, or anything that can call an API. Your screens, your routing, your design system.

  • Passwordless learner sign-in

    Magic codes by email, recognition of returning contacts, and post-purchase claim links. There is no password store for you to own.

What it looks like in practice

A platform team ships the academy inside the product

For example

  1. 1The team keeps its own navigation and design system and calls the Peerfold API for the catalog, the lessons and the progress.
  2. 2Learners are already signed in to the product, so a token exchange stands in for a second login.
  3. 3Completions still write to the CRM through the outbox, because the sync does not care which frontend rendered the lesson.

The payoff: The academy looks like the product, because it is the product.

Read the reference, then build against it.

Sandbox workspaces with test keys, a typed client, and an MCP server your assistant can drive before lunch.

Book a demoAPI error reference
  • OpenAPI 3.1 with generated clients
  • 40+ MCP tools, every write audit-logged
  • Sandbox tenants and test keys