Skip to main content
Motion Model Context Protocol — v1.0-rc1

One protocol.
Any motion model.

A vendor-neutral HTTP contract for text- and constraint-driven motion generation. Send a skeleton and a prompt; get back a standard glTF 2.0 animation. Build motion-capable plugins for any DCC without locking yourself to a single AI vendor.

Read the protocol →Quickstart
Wire formatJSON request, glTF 2.0 responsePython SDKpip install motionmcp-sdkStatusRelease candidate
The contract, in three verbs

Discover. Generate. Decode.

MMCP is two HTTP calls and a glTF document. No SDK to install. No vendor lock-in. The same wire format works for every backbone — diffusion, transformer, or hybrid.

01 — Discover

What can the model do?

Ask the server which models it hosts, which constraints they support, what fps they run at, and what canonical skeleton they expect.

GET /capabilities
02 — Generate

Hand it your skeleton.

Send the user's actual skeleton — joint names, parent links, rest pose. Add a prompt or a few constraints. The server returns a glTF document with one animation per sample.

POST /generate
03 — Decode

Apply the animation.

The response is standard glTF 2.0 — load it with any glTF parser. Optional extensions.MMCP_motion carries fps, foot-contact masks, and chunk boundaries.

model/gltf+json
Hand-writable

A minimal request fits in five lines.

No upload step. No buffers in the request. Just JSON — the character's skeleton plus a description of the motion you want.

Read the request schema for the full surface, or jump to the client quickstart to send your first request in under five minutes.

POST · /generateapplication/json
{
  "protocol_version": "1.0",
  "model": "kimodo-soma-rp",
  "skeleton": { "joints": [ /* canonical or your own */ ] },
  "segments": [
    {
      "type": "text",
      "prompt": "a person walks forward, then waves",
      "duration_frames": 120
    }
  ]
}
Design principles

Built for studios, not demos.

The protocol surface is intentionally small. Implementation details — backbones, retargeters, post-processors — sit behind the contract where they belong.

⊕

Vendor-neutral

Any motion-generation backbone implements the same wire format. Swap models without rewriting your plugin.

{ }

Plain JSON in, glTF out

No proprietary formats. Inputs are a single JSON document; outputs load into any tool that reads glTF 2.0.

⌗

Skeleton-respectful

Send the user's skeleton verbatim. Servers retarget under the hood. No imposed canonical naming.

◐

Discoverable

One GET tells you which models, which constraints, which fps, and what limits. No surprises at runtime.

↻

Versioned for the long haul

Major versions for breaking changes. Minor versions add capabilities. Servers run both concurrently when needed.

✦

Hand-writable

A minimal request is five lines. The contract is small enough to reason about end-to-end in one sitting.

Building a server in Python?

There's an SDK so you don't have to start from scratch.

motionmcp is a thin Python package that handles the wire format, validation, error envelope, and glTF encoding. You write a Backbone subclass; it serves the protocol. The SDK is a convenience — the protocol stands alone, in any language.

SDK reference →Server quickstart
pip install motionmcp-sdk
python · server.pymotionmcp 0.1
from motionmcp import (
    Backbone, ModelSpec, GenerateRequest,
    MotionResult, serve,
)

class MyBackbone(Backbone):
    def capabilities(self) -> ModelSpec:
        return ModelSpec(
            id="my-model",
            fps=30.0,
            canonical_skeleton=load_skeleton(),
            supported_constraints=["pose_keyframe"],
        )

    async def generate(self, req: GenerateRequest):
        return MotionResult(
            rotations=self.model.run(req),
            root_translations=self.model.run_root(req),
        )

if __name__ == "__main__":
    serve(MyBackbone())

Read the protocol. Send a request. Ship.

The protocol surface is small enough to read end-to-end in one sitting. The quickstart sends a real request in under five minutes.

Read the protocol →Learn the concepts