AI SCORM Generator: Making SCORM Content With Agents

Nobody goes looking for an AI SCORM generator because they find SCORM interesting.

They go looking because an activity has to run inside a learning platform somebody else administers, there’s no authoring seat free for it, and the deadline is closer than procurement could ever deliver one. SCORM is the toll booth between a finished interaction and a completion record in a system you can’t log into.

The useful part is that a SCORM 1.2 package is a much smaller object than the tooling around it implies, and an agent can produce one.

The unhelpful part is that an agent writing SCORM plumbing without a tested template fails in four specific ways. Three of the four stay invisible until the package is live in somebody else’s platform. This is what has to be in the package, how to get an agent to produce one, what those four failures look like, and the review that catches them before a client sees the file.

Draft the activity itself from a document you already have, then decide how it ships.

Key Takeaways

• A SCORM 1.2 package is a zip holding your content, a manifest describing it, and JavaScript that reports back to the platform running it. Nothing in that requires a licence.
• Two values carry the weight for a graded activity: cmi.core.lesson_status and cmi.core.score.raw. A package that writes a score and never sets status can sit as permanently incomplete in a strict system and look finished in a forgiving one.
• Generate SCORM 1.2 unless you can name the reason you need 2004. There are two that hold up, and both are about the course rather than the activity.
• Four failures recur in agent-written SCORM: the session is never closed, status is never set, the manifest names a file that isn’t there, and the zip has a wrapper folder around the manifest.
• Review the package in a validator first and in the target platform second. The two stages catch different things, and only the second one settles an argument with a client.

What an Agent Actually Has to Produce

Three things in a zip, and you already know two of them.

The content. HTML, CSS, JavaScript, images — a self-contained thing that runs in a browser with no server behind it. It’s the part an agent is genuinely good at, and the part you’ll review as a designer rather than as an engineer.

imsmanifest.xml. The file that tells the platform what’s inside, what to call it, and which file to open first. It sits at the root of the zip, not inside a folder inside the zip. Of the four errors a platform typically gives on a failed import, three are about this file or about where it sits.

The run-time calls. JavaScript that locates the platform’s SCORM API object and reports to it. The package isn’t handed an API reference — it goes looking, climbing the chain of parent windows and then trying the window that opened it. If it finds nothing, it gives up, and the activity keeps playing regardless.

That one mechanism is why a package can run perfectly and record nothing, and it’s worth understanding before you sign off on anything an agent wrote. What’s actually inside the zip walks the manifest and the discovery sequence attribute by attribute.

There’s no server component, no run-time to install and no per-seat licence in any of that. SCORM is a file format, which is exactly why it’s the right answer when the activity has to work inside a system somebody else controls.

The Two Values the Package Must Write

For a graded activity, two elements of the data model carry almost all of the weight.

Value	What it does	What the package should set
cmi.core.lesson_status	Whether the learner completed or passed	completed, or passed / failed where a mastery score is configured
cmi.core.score.raw	The numeric score	A number on the declared range of 0 to 100
cmi.core.session_time	Time in the activity	Useful where an auditor asks for it, ignored elsewhere
cmi.suspend_data	State to resume from	Only where the activity can be left and re-entered

Two rows in that table catch people out.

• The score has to be converted. SCORM 1.2 declares a raw score range of 0 to 100, so a rubric marked out of 40 has to be turned into a percentage before it’s reported. An agent that passes the raw rubric total straight through hands the gradebook a number that’s either rejected or meaningless.
• Resume state isn’t private. cmi.suspend_data is stored by the platform and readable by its administrators, so a well-built activity never puts free-text learner answers there. That point is in Mini Course Generator’s own open-source Skill documentation and almost nowhere else.

Then there’s the failure that produces the confusing support ticket: a score recorded with no completion. A package that writes score.raw and never sets lesson_status leaves the attempt unfinished.

How visible that is depends entirely on the platform. Moodle’s SCORM 1.2 run-time quietly sets a still-untouched status to completed when it stores data, and recomputes passed or failed from the score where a mastery score is configured with override on. A silent package therefore looks fine in Moodle and sits permanently incomplete somewhere stricter.

Moodle is the worked example throughout this article because its import and run-time behaviour is documented in the open. Other platforms are less forgiving, and they word the same things differently.

So have the package set status explicitly. Never let it infer completion from the presence of a score.

Which Version to Generate

Generate SCORM 1.2 unless you can name the reason you need 2004.

SCORM 1.2 dates from 2001 and is the version the widest range of platforms accepts without argument. SCORM 2004 adds sequencing and navigation rules, a second status field and a richer score model. Support for it is less uniform than the version number suggests, because sequencing is the part platforms implement least consistently — “supports SCORM 2004” and “runs your SCORM 2004 sequencing rules” are different claims.

Two reasons to choose 2004 hold up, and the popular third one doesn’t.

The reason	Does it hold up?	Why
An auditor needs completion and pass as two separate facts about the same person	Yes	1.2 has one status field holding one value at a time. 2004 splits it into two fields the package sets independently
The course is long or branching enough to outgrow the resume-state ceiling	Yes	That ceiling is far lower under 1.2. It’s a length-of-course question, not an activity question
Future-proofing	No	No new version of SCORM is coming, so there’s no future to proof against

Neither of the two that hold up usually applies to one graded interaction dropped into a course somebody else built, which is the situation this page is about. The full version comparison has the six differences that are real, plus the check for which run-time your package is actually being given.

“No new version is coming” isn’t an argument for abandoning the format either. SCORM 1.2 is still what platform imports overwhelmingly accept. Where genuinely detailed interaction data is the requirement, the answer is a different standard, and xAPI against SCORM is where that decision belongs.

Two Ways to Get an Agent to Produce One

The routes differ on whether the deliverable is a file or a course.

	The packaged route	The platform route
What you get	One self-contained activity as a zip	A whole course, exported when it’s finished
Where it’s authored	In your coding agent, in plain English	In a platform your assistant is connected to
Editing later	Re-generate and re-export the activity	Edit in place, re-export when you need a new file
Account needed	None on either side	Yes
Best when	One interaction has to go into somebody else’s course	The course is the deliverable and the file is a by-product

The packaged route

An Agent Skill produces the interaction and the SCORM wrapper in one pass. The live one is AI Role-play, installed with a single command:

npx skills add minicoursegenerator/edu-role-play

You then describe the activity in plain English: the scenario, the persona the learner is talking to, the rubric it’s graded against, the debrief they see at the end. The Skill writes the interaction and the packaging together, and exports a self-contained bundle that reports the rubric score through cmi.core.score.raw and completion through cmi.core.lesson_status.

What its documentation actually commits to is worth reading before you promise anything to a client:

• SCORM 1.2 is the supported export version. No other version is claimed.
• The platforms it has been tested with are Moodle, Canvas, Cornerstone, SAP SuccessFactors, Mini Course Generator and SCORM Cloud.
• It’s open source, and it needs no account on either side.
• The same bundle runs standalone in a browser when there’s no platform to upload it to.

Treat the role-play Skill as one interaction type done well rather than a library of them. If role-play is what the module needs, the Skill’s own page has the detail.

The platform route

Where the deliverable is a whole course rather than one interaction, build it in a platform connected to your assistant through an MCP server, then export the finished course. You keep authoring, preview and editing, and the packaging happens at the end instead of being the thing you’re generating.

The SCORM Upload Block runs the other way too. It takes a package you already hold from another tool and places it inside a course as a tracked activity, which helps when half of what you’re assembling came from somebody else’s authoring seat.

Mini Course Generator is our product, so read that paragraph as disclosed: it exports a course as a SCORM package, dynamic SCORM export is a higher-tier feature you can check on the plan comparison, and the Skills are open source and free to install and run wherever you like.

Which route fits is a question about where the course should live, not about which is more capable. Skills against MCP lays that decision out properly.

And if the module really is a full course with a house design standard behind it, an authoring seat may still be the right purchase. The tools that publish SCORM is the shortlist to price up.

What Agents Get Wrong

Four failures recur when a model writes SCORM plumbing from scratch instead of using a tested exporter. Three of the four produce no error message at all.

The failure	What you see	Why it happens
The session is never closed	The learner finishes, closes the window, and nothing is recorded	LMSFinish is never called, or it’s called after the window has already gone
Status is never set	A score sits in the gradebook while the attempt stays unfinished	The package writes score.raw and assumes a score implies completion
The manifest names a file that isn’t there	The import fails, or it warns that a resource in the manifest couldn’t be found	The href and the real filename differ by a capital letter or a hyphen — case counts
The zip has a wrapper folder	The import is refused, often with a message telling you to re-package	The folder was compressed instead of the folder’s contents, burying the manifest one level below the root

The first one is the expensive one, because it survives every review that consists of opening the file and clicking through it. Locally there’s no platform to notice that the session was never committed.

The second is the one that argues against its own diagnosis. The score is right there, so the package is obviously reporting, so the problem must be the platform. It isn’t.

There’s a fifth that isn’t really the agent’s fault but lands the same way: a resource declared in the manifest as an asset rather than as a trackable object. A package like that imports cleanly, plays perfectly and never completes. Nothing anywhere looks wrong, which is why it’s the one that costs the most time to find, and it’s one more reason to prefer a tested exporter to a model improvising manifest XML.

Reviewing a Generated Package

Two technical stages, and they catch different classes of problem. Skipping the second is where the client-facing version of this goes badly.

Stage	What it catches	What it can’t see
A validator outside the platform	Manifest errors, missing files, wrapper folders, packaging faults	Anything about how the target platform behaves
The target platform, with a test learner	Frame nesting, cross-domain hosting, status interpretation, where the score lands, how the player sizes on a phone	Whether the activity teaches anything

Stage one. SCORM Cloud imports a package and plays it the way a platform would, then reports what it saw. Its Trial plan costs $0 and covers three courses and ten resettable registrations (Rustici’s published pricing, September 2026), which is more than enough to clear a single activity. There’s no budget argument for skipping it.

Stage two. Run the activity end to end as a test learner in the platform it’s actually going to live in. Then look at the record the platform kept, not at the screen the learner saw. That last instruction is the whole point of the stage.

Then there’s the review a validator has no opinion about, which is the one you’re actually being paid for:

• The scenario. Does it match how the job is really done, or is it a plausible-sounding version of it? An agent will happily write a sales objection nobody in that industry has ever raised.
• The rubric. Check it against the learning objectives, not against the transcript the agent produced.
• The debrief. A closing screen that only reports a number teaches nothing.
• Accessibility. Confirm it meets whatever standard the client works to, because nothing in SCORM enforces one.

An agent removes the packaging work and a chunk of the drafting. It doesn’t remove the design review, and a package that clears both technical stages and fails this one is still a bad deliverable.

When a Package Is the Wrong Deliverable

Worth saying, because SCORM gets chosen out of habit as often as out of need.

Where you control delivery, you don’t need it. A link, an embed or a course in a platform you run gives better analytics and no packaging step at all. Share links and embeds do the same job for the same learner when nobody is demanding a file.

Where the content changes often, packaging is friction. Every revision means re-export, re-upload and re-publish in the target platform, plus whatever approval sits around that. Connected delivery updates in place, which is most of the argument for keeping an agent in the loop after publish.

Where you need to know what happened inside the activity, SCORM 1.2 won’t tell you. It reports a status and a score and very little else, by design.

Use SCORM when the training has to run somewhere you don’t control. That’s the job it was built for, and it still does it better than anything else.

The Short Version

An AI SCORM generator solves a narrow, common problem: one interactive activity has to live inside a platform you can’t administer, and buying an authoring seat to produce it is out of proportion to the job.

A SCORM 1.2 package is a zip with your content, a manifest and a modest amount of JavaScript. The rules that keep one out of trouble are short:

1. Have the package set cmi.core.lesson_status explicitly, and never infer completion from a score.
2. Convert the rubric total to the 0-to-100 range before reporting it through cmi.core.score.raw.
3. Generate 1.2 unless an auditor or a long branching course gives you a reason not to.
4. Use a tested exporter instead of asking a model to improvise the plumbing.
5. Review it three times over — a validator for the packaging, the target platform for the behaviour, your own eye for whether the activity is any good.

Where you do need to cross a boundary, Agent Skills will produce the package without an authoring seat. Where you don’t, skip the file entirely.

Frequently Asked Questions

Can AI generate SCORM content?

Yes. An agent can produce the interaction and the SCORM wrapper together and export a package a learning platform imports like any other. Use a tested exporter rather than asking a model to write the run-time calls from scratch, because the common failures produce no error message and only appear once the package is live.

What is in a SCORM package?

A zip holding your content files, an imsmanifest.xml at the root of the archive describing the package and naming the launch file, and JavaScript that reports completion and score back to the platform running it. No server component and no run-time licence.

Should an agent generate SCORM 1.2 or 2004?

SCORM 1.2, unless an auditor needs completion and pass recorded as two separate facts for the same person, or the course is long or branching enough to outgrow the resume-state ceiling. For a single graded activity dropped into somebody else’s course, neither usually applies.

Why does the platform show a score but no completion?

Almost certainly because the package writes cmi.core.score.raw and never sets cmi.core.lesson_status, so the attempt is recorded as unfinished. Some platforms paper over this by completing a silent package themselves, which is why it often surfaces only after the content moves to a stricter one.

How do I check an AI-generated SCORM package?

Import it into a validator such as SCORM Cloud to catch manifest and packaging errors, then run it in the actual target platform with a test learner and inspect the record afterwards. Then review the scenario, the rubric and the debrief yourself, because neither stage has an opinion about whether the activity teaches anything.

Does an agent-generated package work in any LMS?

It works where SCORM 1.2 imports work, which is most places, but “most” is not “yours”. The AI Role-play Skill’s documentation names the platforms it has been tested with, and anything outside that list is a two-hour test rather than an assumption.

When should I not use SCORM at all?

When you control delivery, because a link or an embed gives better analytics with no packaging step. When you need detailed interaction data, since SCORM 1.2 reports little beyond status and score. And when the content changes often, because every revision means a re-export and a re-upload.

Sources

• Mini Course Generator Agent Skills and the AI Role-play Skill pages
• The open-source edu-role-play Agent Skill repository and its SCORM documentation, on GitHub
• Moodle documentation on SCORM settings and externally hosted packages
• Rustici Software’s published SCORM Cloud plans and pricing, read in September 2026