Quickstart

Choose MCP, DEX CLI, or SDK by integration depth and how you operate Morpheum

What this guide does

Use this page to pick an integration surface—MCP, DEX CLI, or SDK—and to match your product (AI agents, wallets, exchange UIs, bots) to the level of integration and day-to-day activity you are willing to own.

You do not need every path. One team might live entirely in MCP tools; another ships a custom UI on TypeScript SDK only.

Integration surfaces at a glance

Surface	Best for	You implement	Typical operator
MCP	Model-driven workflows in IDEs and agents	MCP server or config that calls APIs/CLI/SDK	Developers and agent operators
DEX CLI	Scripts, ops, CI, and “human in the loop” chain actions	Shell/Make, automation around morpheum-cli	DevOps, traders, support
SDK	Products: wallets, web apps, bots, embedded agents	Rust or TypeScript against chain APIs; optional MWVM	Application engineers

Rule of thumb: MCP is for assistants and agents that discover tools; CLI is for repeatable commands without embedding a library; SDK is for software you ship (including agents built in code, not only via MCP).

Levels of integration

Use these three levels to decide how deep you couple to Morpheum—not how “good” your product is.

Level 1 — Tooling and operations

• What you do: Query state, submit occasional transactions, wrap existing behavior for an assistant, or run scripted flows.
• Surfaces: MCP (tools/resources), DEX CLI, thin SDK scripts.
• Ownership: Low ongoing app surface; you maintain configs, scripts, or a small MCP server.
• Fit when: You are exploring, automating personal workflows, or supporting a team with chat- or terminal-driven actions.

Level 2 — Product integration

• What you do: Embed signing, markets, and transport in an application with a clear UX (wallet connect, order forms, dashboards).
• Surfaces: Primarily SDK (Rust or TypeScript); MCP may still exist for internal agent tooling alongside the app.
• Ownership: You ship releases, handle keys and policy, and monitor usage.
• Fit when: You build a wallet, trading UI, third-party exchange front end, or a bot that is not just a script.

Level 3 — Agent runtime and chain-parity execution

• What you do: Run agent logic with WASM parity, host functions, gateways (MCP, A2A, x402), and strict policy boundaries.
• Surfaces: MWVM on top of the SDK; Agent wallet and Signing for keys and claims.
• Ownership: Highest—you own runtime policy, upgrades, and operational safety.
• Fit when: You need autonomous agents (including stacks like OpenClaw-class runtimes), hosted agent services, or execution that must mirror chain rules in a sandbox.

Smart contracts and WASM applications (MWVM development kit)

On Morpheum, agent applications that behave like smart contracts are developed as WASM with the same bytecode story locally and on-chain. If an AI agent or team is building that class of application—not only calling APIs from a chat tool—they should standardize on the MWVM development kit for the full development and production lifecycle:

• Develop: mwvm-sdk, cargo mwvm (project bootstrap and builds), templates, local wasmtime execution, simulation, and debugging—see the MWVM page and the upstream morpheum-labs/mwvm repo (README, QUICKSTART, QUICKSTART-AGENT).
• Ship: The same WASM and host boundaries you tested offline carry forward to chain-parity production paths; pair with Signing and Agent wallet where execution must be funded or signed.

MCP and the chain SDK alone are not a substitute for this lifecycle when the product is the WASM agent contract—you still anchor development, CI, and releases in MWVM.

Activity level: how you will work day to day

Match how often and how you touch Morpheum to the right surface.

Activity profile	Description	Start here
Explore and assist	Chat or IDE-driven help, docs, occasional test txs	MCP + docs; add CLI for one-off chain commands
Operate and script	Cron jobs, deploy scripts, support playbooks	DEX CLI; shell around SDK if you need logic
Build and ship	Production UX, custody patterns, streaming, risk	SDK + Signing; Agent wallet for automated traders
Build WASM / “smart contract” agents	Edit–build–test–deploy lifecycle for on-chain-parity WASM	MWVM development kit (SDK, CLI, cargo mwvm, local runtime); then gateways as needed
Run agents as a platform	Long-lived agents, tool discovery, paid APIs	SDK + MWVM; expose MCP or HTTP gateways as your product allows

If you are only adding Morpheum to an existing AI assistant (e.g. Cursor, Claude Desktop, or an OpenClaw-style agent host), Level 1 with MCP is usually enough until you need custom latency or custody—in which case you move to SDK or MWVM for the hot path.

Choose by product type

AI agents and assistant hosts (e.g. OpenClaw-class runtimes)

• Primary: MCP so the model lists and invokes tools with schemas and audit boundaries.
• When to add SDK/MWVM: You need sub-second custom flows, batch jobs without an LLM, chain-parity WASM, or hosted multi-tenant agents → SDK and MWVM (Level 3).
• When the agent is developing WASM / smart-contract-style apps: Use the MWVM development kit for the full lifecycle (see above); do not rely on MCP alone to replace build, test, and deploy discipline for that code.
• Signing: Agent wallet and Signing when agents hold or request keys.

Wallet applications

• Primary: SDK (TypeScript in browser/extension, Rust for native) with signers from the SDK docs (MetaMask, Phantom, native signers, etc.).
• Secondary: DEX CLI for support and recovery scripts, not for the main UX.
• MCP: Optional for developer tooling or support copilots, not for end-user wallet security boundaries.

Third-party exchange or trading UI

• Primary: SDK for markets, transport (gRPC/HTTP), and streaming; follow Engines and Listings for product rules.
• Secondary: DEX CLI for operations and integration tests.
• MCP: For internal automation (risk checks, runbooks), not as the sole execution path for live trading unless you have engineered latency and failure modes explicitly.

Validators and node operators

• Primary: Node tab (deploy guides, Node CLI); this path is separate from MCP/DEX CLI/SDK product integration unless you automate node ops via scripts.

A simple decision order

1. Do end users run your code in a browser or app? → SDK (Level 2 or 3).
2. Is the “user” an AI that should call tools? → MCP first; escalate to SDK/MWVM when you outgrow protocol boundaries.
3. Is the “user” a human or CI running commands? → DEX CLI.
4. Do you run sandboxed agent bytecode with host calls, or ship WASM like a smart contract? → MWVM development kit (full lifecycle); add SDK for chain and product APIs where needed.

Next steps

• Protocol and assistant tooling: MCP.
• Terminal and automation: DEX CLI (upstream morpheum-cli).
• Libraries and runtimes: SDK, MWVM (use the MWVM kit for WASM agent and smart-contract-style development lifecycle).
• Keys and automated trading: Agent wallet, Signing.
• Paid and metered APIs: x402.