01 / Composer In development · Core engine built, MCP server next

Built for agents,
not for clicking buttons.

Composer is an open-source course engine delivered as an MCP server, and the author is an AI agent. From a lesson plan it structures the lesson, chooses how every block is presented, briefs the media, sets the theme, the backdrops and the transitions between them, and revises from your notes. You bring the expertise and the judgment.

Watch a lesson get built Why it exists

TOOL CALLS / MCP01 / 10

agent →create_lesson { title: "Handling a refund request", duration_minutes: 12 }← { lesson_id: "l_refund", revision: 3 }

The agent has read the lesson plan. The server never sees it.

Frontline Service Basics / Lesson 2 draft

LESSON 2 · 12 MIN

Handling a refund request

Ten calls from the design transcript, replayed. Eight by the agent, two by a reviewer in the preview. The preview is a client of the same tools.

WHAT THE AGENT AUTHORS

StructureSections, columns, and blocks, as a layout tree
PresentationHow each block reaches the learner, and at which stance
Media briefsImages, video, narration, and music, written as briefs
Narration & cuesScripts with cue markers, resolved from word timings
Theme & media stylePalette, type, and how every asset should feel
Backdrops & transitionsSection backgrounds and the seams between them
DynamicsVariables, triggers, states, animation, and motion

OPEN SOURCE / MITMCP SERVER15 SHAPESAGENT-DRIVEN

01 / Why this exists

Three problems with how courses get made.
What Composer does about each.

Course authoring is manual, and the tools are built to keep it that way.

Articulate Rise 360 is very good software for a human at a screen: pick a block from the menu and it is inserted where you are, type into it, preview, repeat. We spent the better part of a year making an agent operate Rise through that interface. It worked, barely, and broke every time the interface changed.

Composer is agent-driven all the way down. The agent does not only place blocks. It structures the lesson, chooses each presentation, briefs the images and narration, sets the theme, the section backdrops and the transitions between them, and revises from a reviewer’s notes. The person’s job moves from assembly to judgment.

Untitled lessonEditPreviewPublish

BlocksTextStatementQuoteListImageGalleryAccordionTabsProcessQuiz

+ Insert block here

A HAND ON A MOUSE · CHOOSE, INSERT, TYPE, PREVIEW, REPEAT

ONE TOOL CALL

agent → add_collection {
  presentation: "process", ordered: true,
  items: [ "Acknowledge", "Verify", "Decide", "Act", "Confirm" ]
}
← { id: "b_steps", revision: 10 }

rendered · collection · process

1Acknowledge
2Verify
3Decide
4Act
5Confirm

A TOOL CALL · ONE CALL, ONE BLOCK, RENDERED

Drag the divider. A course that takes a designer two weeks in a button-driven editor can be drafted by an agent from a lesson plan in minutes.

01 →

From a markdown lesson plan
to a layout tree.

A lesson plan is prose, and prose hides structure. The five steps of a procedure are five sentences in a paragraph. Three terms are a list inside a sentence. Instructional design is the work of recovering that structure and then making the learner do something with it.

The agent reads the plan, recovers the structure, and makes one tool call per piece. What the server holds is a layout tree: sections, columns, and blocks, each with a shape and a presentation. Click to see the plan become the tree.

THE LESSON PLAN / WHAT THE HUMAN WROTEPROSE

Open with a scene: an agent on a call. Say why refunds matter (retention, not cost). Define three terms: goodwill refund, policy refund, chargeback. Show the five-step refund process: acknowledge, verify, decide, act, confirm. Learners should be able to order the steps. Walk through the refund form (screenshot) and point out the four fields people get wrong. Sort: which requests are refundable under policy and which are not (eight examples). Two example emails, one good, one bad, side by side. Check: one multiple choice on the decide step, one true/false on chargebacks, one ordering of the five steps. Close with the one thing to remember: confirm in writing, always. Narrate the opening and the closing.

Eleven sentences. Structure in every one.

get_lesson { detail: "outline" }SHAPES

sec_open
sec_process
sec_judge
sec_check

The outline the server would return once the agent has done its work.

The block library is never enough, and adding to it is manual.

Rise ships about sixty block types, and an ecosystem has grown up to add more: Mighty’s custom blocks, Articulate’s Code Block and Custom Block, dozens of copy-paste components. Every one is built and placed by hand, keeps its content in a private format, and is harder to use than the blocks beside it. H5P’s fifty-four content types are fifty-four islands.

Composer’s answer is shapes and presentations. A shape is what the content is. A presentation is one way to show it. Write one new presentation and every existing block of that shape can be shown that way. Swap a block’s form without retyping it. Let an agent define a new shape mid-session and promote it to the shared library later. The library grows in use.

02 / The shape catalog

Fifteen shapes.
Four stances.

A shape is described independently of how it looks. A presentation reaches the learner with it, and its stance says what the learner does: read, explore, try, or prove. A flashcard is not a kind of content. It is one way of presenting pairs. So is a glossary, a table, a matching exercise.

Because shapes are shared across stances, a lesson can return to the same block at a harder stance without authoring a new one. That progression is what the research on retrieval practice and active learning asks for.

Download the project overview

SHAPE 03 / 15 · TIER 1

pairs

Items that go together two by two. Term and definition, symptom and cause, before and after.

expositoryRead it

glossarytwo_column_tabledialog_cards

exploratoryExplore it

—

practiceTry it

flashcards_gridflashcards_stackmemory_gamematching_dragconnect_linesscratch_reveal

assessmentProve it

matching

Absorbs Rise Flashcards, Matching; H5P Dialog Cards, Memory Game

Add a presentation and every existing block of this shape can be shown that way. Add a shape and you are making a claim about learning content, which is what an open repository is for.

Try the idea / Interactive demo

Same three pairs.
Read them, explore them, then try them.

Switch the presentation and the stance changes with it. Read the glossary, turn over a flashcard, then match them. Nothing is retyped between views.

PRESENTATIONREAD

Token: A unit of text (word, subword, or character) that the model processes
Context window: The maximum amount of text a model can consider in a single interaction
Temperature: A parameter that controls the randomness of the model's output

A working illustration of Composer’s design principle, built for this page. This is not a connection to the unreleased Composer engine.

Storyline is the industry standard for a reason. Its timeline is not that reason.

Designers leave Rise for Articulate Storyline when they need what Rise cannot do: variables, triggers, object states, animation and motion paths, layers, narration synced to what is on screen. Those features make a course feel authored rather than assembled.

Composer’s position is that nearly all of this is data, and Storyline’s demanding timeline and trigger panels exist only because humans cannot comfortably write that data by hand. An agent can. Variables, triggers, states, animation, motion and narration cues are a declarative layer any block can carry, validated like everything else, and responsive by construction because nothing is pinned to a pixel.

THE CLASSIC STORYLINE SLIDE

Three clickable objects. Each opens a layer that slides in. The learner cannot continue until all three are visited. Rise has no way to build this. Try it, and watch the spec light up.

Lesson 2 · section “Three kinds of refund” 0 / 3 visited

collection · cards_grid · states: normal, visited

Three kinds of refund. Open each one.

THE SAME SLIDE, AS DATATWO CALLS

agent → add_collection {
  presentation: "cards_grid", heading: "Three kinds of refund",
  items: [ goodwill, policy, chargeback ],
  states: [ "normal", "visited" ],
  triggers: [
    { on: "click(item)", do: "overlay(item)" },
    { on: "close(item)", do: "set_state(item, visited)" }
  ],
  completion: "all_items(state == visited)"
}
← { id: "b_types", revision: 21 }

agent → add_separator { presentation: "continue", label: "Continue", require_completion: true }
← { id: "b_gate", revision: 22 }

agent → add_passage { presentation: "statement_a", body: "Now that you can tell them apart…" }

States, a trigger per event, and a gate that hides everything after it until the collection reports complete. The reveal_gate, events, and state behaviors ship in the runtime, so the layer is keyboard-reachable and the gate is announced, with no per-slide scripting.

NARRATION SYNCED TO THE SCREEN

Storyline’s other signature: things happen when the narrator says them. Here the cue points come from the script itself.

NARRATION · GENERATED FROM THE SCRIPTCUES

[cue:acknowledge] First, acknowledge. Say back what you heard. [cue:verify] Then verify: find the order and the charge before you decide anything. [cue:decide] Now decide. Policy refund, goodwill refund, or decline, and say why. [cue:act] Act. Submit the form, one per charge. [cue:confirm] And confirm, in writing, before the call ends.

The agent marks cues in the script. The speech provider returns word timings. The server resolves each cue to a time, and cue(verify) becomes an event any trigger can listen for.

collection · process · states driven by cues

1Acknowledge
2Verify
3Decide
4Act
5Confirm

triggers: [{ on: "cue(verify)", do: "set_state(steps.1, active)" }]

“Highlight step two when the narrator reaches it” is a trigger, not something dragged on a timeline. No pixel is pinned, so it holds on every screen.

STORYLINE CAPABILITY → WHERE IT LANDSFROM THE PARITY MAP

Variables and references in text: course and lesson variables, {{name}} interpolation
Triggers with conditions: declarative triggers: { on, when, do }
Object states: named states on items and annotations, set_state
Entrance, exit, emphasis animation: animation per block or item, theme defaults
Motion paths: motion: an SVG path or keyframes, on a trigger, on scroll, on a cue
Timeline and cue points: narration cues resolved from word timings; a timeline inside scene
Layers, lightboxes: overlay and show/hide triggers, sections, the scene shape
Freely positioned slide objects: scene: layers on a stage that scales to any screen
Fixed pixel layouts, hand-edited timelines: not offered, by design

What falls out of the design

Cheap where it used to be
expensive.

Swapping, two ways.

Re-presentation keeps the structure and changes the form. An accordion becomes tabs or a timeline, nothing retyped. It is deterministic, so the reviewer gets it as a button. Re-shaping turns one structure into another. The engine does the mechanical ones itself and publishes exactly what each one loses. The ones that need something written go to the agent, and the result replaces the original with its lineage preserved.

The human stays in the loop, at the point of judgment.

The most common reaction to a draft is not “the content is wrong” but “not like that.” So the preview lets a reviewer change how any block is presented with one click and compare alternatives side by side. For anything that is a matter of substance, the reviewer selects the exact thing and talks to the agent about it. Approved lessons are protected from quiet changes. The reviewer cannot edit content directly, so there is one author of record and the agent’s understanding never drifts from the truth.

Media is generated, not sourced.

Wherever a block needs an image, video, narration, or soundtrack, the agent writes a brief instead of supplying a file. The course renders immediately with placeholders that show the briefs, so structure can be validated before anything is generated. Style is decided once per course. Every result carries its brief, prompt, provider, and rights back into the course.

Backdrops and transitions come from the theme.

Rise stacks every block on one white page. In Composer a section can carry a backdrop, and the seam between two colored surfaces is drawn automatically by the theme: wave, layered, curve, slant, arrow, or zigzag. The agent decides which and why, per course, per section, or per edge. What Mighty added to Rise as a manual transition block is a default here.

Explore the other project

Built for agents,not for clicking buttons.

Handling a refund request

Three problems with how courses get made.What Composer does about each.

Course authoring is manual, and the tools are built to keep it that way.

From a markdown lesson planto a layout tree.

The block library is never enough, and adding to it is manual.

Fifteen shapes.Four stances.

pairs

Same three pairs.Read them, explore them, then try them.