Longwave MCP server
Commit Oct 1, 2026Lets AI agents manage a complete video creation pipeline including Shorts, thumbnails, metadata, and YouTube publishing.
Also known as Longwave-Media/longwave-plugin, longwave-plugin
- Stars
- 1
- Tools
- 15
- Downloads, 30 days
- —
- Latest version
- 1.0.0
- Last commit
- Oct 1, 2026
- License
- MIT
What is Longwave MCP?
Longwave lets AI agents manage a complete video creation pipeline including Shorts, thumbnails, metadata, and YouTube publishing. It exposes 15 tools, such as account_status, create_shorts_job, get_job.
Summary generated from the project's README
About Longwave MCP server
Longwave provides a complete video distribution pipeline designed for AI agents to manage content creation. Instead of just cutting clips, this server allows agents to orchestrate a full workflow including generating captioned vertical Shorts, creating contextual thumbnails from transcripts, and writing metadata like show notes and chapters. It is built for use with clients such as Claude Code, Cursor, Grok Bot, and Meta Muse.
The system operates via a remote MCP connection using OAuth 2.1, meaning no API keys are stored in the repository and the agent never holds direct Google credentials. Users connect through a browser-based authorization flow. While the agent handles the orchestration, Longwave performs the heavy lifting of rendering and publishing. It features fifteen specific tools, including account_status for checking credits and create_shorts_job for processing long-form video into clips.
Publishing capabilities are strictly controlled. While tools for creating and inspecting content are available upon connection, tools that change public information, such as publish_shorts or approve_thumbnail, require a separate step-up approval from the creator. This ensures the agent cannot make public changes without explicit permission.
What you can do with it
- 1Convert long videos to ShortsAn agent can take a long-form episode and automatically generate captioned vertical clips.
- 2Automate YouTube and X publishingThe agent can schedule and publish content directly to YouTube and X.
Written from the project's README. Every use case is checked against a quote from it.
How to install Longwave MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall Longwave MCP in Claude Code
$ claude mcp add --transport http longwave-plugin https://www.longwave.media/api/mcpInstall Longwave MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"longwave-plugin": {
"url": "https://www.longwave.media/api/mcp"
}
}
}Install Longwave MCP in VS Code
.vscode/mcp.json
{
"servers": {
"longwave-plugin": {
"type": "http",
"url": "https://www.longwave.media/api/mcp"
}
}
}Install Longwave MCP in VS Code CLI
$ code --add-mcp '{"name":"longwave-plugin","type":"http","url":"https://www.longwave.media/api/mcp"}'Install Longwave MCP in Codex
$ codex mcp add longwave-plugin --url https://www.longwave.media/api/mcpInstall Longwave MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.longwave-plugin] url = "https://www.longwave.media/api/mcp"
Install Longwave MCP in Gemini CLI
$ gemini mcp add -s user --transport http longwave-plugin https://www.longwave.media/api/mcpInstall Longwave MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"longwave-plugin": {
"url": "https://www.longwave.media/api/mcp",
"type": "http"
}
}
}Longwave MCP tools 15
Detected from the READMEaccount_statuscreate_shorts_jobget_joblist_clipscreate_supercutlist_episodesget_episodeget_insightsget_content_intelligenceget_channel_overviewlist_playlistslist_thumbnail_styles
Show all 15 toolsShow fewer tools
publish_shortsreschedule_postapprove_thumbnail
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachablelongwave-media/longwave-plugin is public and reachablegithub.com/longwave-media/longwave-plugin ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-10-01github.com/longwave-media/longwave-plugin ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model15 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeEndpoint did not answer initialize: HTTP 402Finding
README
View on GitHubLongwave — the video pipeline for AI agents
Give any AI agent a creator's whole video pipeline. Turn one long-form episode into Shorts, thumbnails, show notes and a podcast feed — then publish to the creator's own YouTube channel.
Works with Grok Bot, Grok Build, Cursor, Claude Code and Meta Muse. One MCP connection, OAuth 2.1, and no API key anywhere.
Agents orchestrate. Longwave renders and publishes. The agent never downloads video, never holds Google credentials, and never drives YouTube Studio.
What it produces
Point Longwave at one long-form episode, podcast or YouTube video and a whole distribution stack comes back:
- Captioned vertical Shorts and clips — cut, framed and captioned from the transcript.
- Contextual AI thumbnails — the hook, the subtitle and the scene are generated from the episode's own transcript, not grabbed from a frame.
- Transcript-based metadata — titles, descriptions, chapters, show notes and per-platform post copy, written for each destination.
- An X post and an X video supercut — the link post and the native video clip are separate outputs, and both can run from the same episode.
- A podcast RSS feed, built and syndicated to 13 directories — Apple Podcasts, Spotify, Amazon Music, iHeartRadio, Pocket Casts, Castbox and more.
- A public link-in-bio hub for the creator's channel.
YouTube and X publish automatically. Every other clip is rendered as a captioned vertical file ready to drop into Reels, TikTok and LinkedIn. Longwave is not a party to those platforms' terms and never contacts them; the creator's own agent performs that step from the creator's session.
Why this exists
An agent can already cut video and drive a browser. Two things it cannot get for itself:
1. A verified YouTube upload grant. Google approved Longwave for youtube.force-ssl — production
mode, no user cap, no "unverified app" screen. The creator connects once, and Longwave delegates
scoped access to the agent. Standing up your own integration means OAuth app review and Google
verification before the first upload.
2. A pipeline, not a command. Cutting a Short is the easy part. Longwave also does the captions, the title and description, the thumbnail, the playlist routing, the daily upload caps, the cross-platform schedule, the podcast RSS feed and the retry when an upload fails halfway.
So this is not a wrapper around yt-dlp and a Studio bookmarklet. It is the publishing authority,
exposed as fifteen tools.
Install
grok plugin install Longwave-Media/longwave-plugin
Or add it as a self-hosted catalog source:
grok plugin marketplace add Longwave-Media/longwave-plugin
Both work with no review. Cursor and Claude Code read the same files; Muse builds its own MCP client from the URL.
Connect
Nothing to configure, and no credentials live in this repo. An unauthenticated call to the MCP endpoint returns:
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Bearer resource_metadata="https://www.longwave.media/.well-known/oauth-protected-resource"
A conformant client follows that, registers itself, opens a browser, and the creator signs in and
approves. PKCE S256 is required. This is deliberate: Agent Plugins v1.0.0 §7.2.1 forbids
embedding secrets in headers, and OAuth discovery is how the spec expects authorization to work.
- MCP endpoint —
https://www.longwave.media/api/mcp(Streamable HTTP, stateless) - Protected-resource metadata —
https://www.longwave.media/.well-known/oauth-protected-resource - Authorization server —
https://www.longwave.media/.well-known/oauth-authorization-server
Tools
Fifteen tools — enough to run a creator's clip pipeline end to end, and deliberately no more. The surface is a deny-by-default allowlist, not a mirror of the API, so a tool exists here because it has an ownership-checked backing route.
Create and inspect — granted on first connect
| Tool | Does |
|---|---|
account_status |
Channel connected? Credits left? Call this first. |
create_shorts_job |
Cut a long-form episode into Shorts. Free — credits are spent on publish. |
get_job |
Progress, clip count and errors for a job. |
list_clips |
What was produced, with per-platform status and live URLs. |
create_supercut |
Assemble one longer cut from a source video or from existing clips. |
Read — granted on first connect
| Tool | Does |
|---|---|
list_episodes |
The creator's long-form catalogue, newest first, with status. |
get_episode |
One episode in full: titles, notes, chapters, transcript, podcast state. |
get_insights |
Channel-level summary: episode counts, recurring topics, hook types. |
get_content_intelligence |
Longwave's written analysis of what to make next. |
get_channel_overview |
Connected platforms and how each is performing. |
list_playlists |
Playlists, and which one is the upload destination. |
list_thumbnail_styles |
The thumbnail style catalogue. |
Change something public — a separate approval, every time
| Tool | Does |
|---|---|
publish_shorts |
Publish Shorts to YouTube, with scheduling. |
reschedule_post |
Move a queued post to a different hour, or unschedule it. |
approve_thumbnail |
Publish an AI-generated thumbnail on the episode. |
Publishing and thumbnail changes are not granted on first connect — they are a step-up the
creator approves separately, because both change something public. The server asks for the extra
permission with 403 + WWW-Authenticate: ... error="insufficient_scope".
tools/list returns the whole catalogue regardless of grant, so a client can see what exists and ask
for it; the grant is enforced on the call. tools/list is authoritative and carries each tool's
full JSON Schema — the tables above are for someone reading this repo.
Every mutating tool accepts an idempotency_key. Retry a timed-out call with the same key and you
get the original result rather than a second job or a second public post.
What it costs
The creator starts free: 200 credits on signup, no card, and they do not expire.
Credits are charged to the creator per Short that actually publishes — nothing for a failed render, nothing for a clip that is never posted.
| Action | Credits |
|---|---|
| Publish a Short | 1 |
| Publish a Short on autopilot | 1.5 |
| Publish to X through the shared app quota | 4 |
| Upload a full long-form episode | 5, plus 1 per GB |
The agent never handles payment. It holds no card and cannot reach a checkout. When the balance
runs low a tool returns a top_up_url; the agent's job is to hand it to the creator and stop.
Where it publishes
- Through the official API, by Longwave — YouTube (the episode and its Shorts), X (a post and a supercut), a public Link-in-Bio hub, and podcast RSS syndicated to 13 directories.
- As a downloadable file — every Short is a vertical file on the CDN with its caption and metadata attached, so an agent can post it anywhere from the creator's own signed-in session.
Longwave is not a party to any third-party platform's terms and never contacts them. We describe the capability; the creator's agent performs the action.
Package layout
Two ecosystems describe plugin packages differently, and a client that finds no MCP config installs a plugin with zero tools. Both layouts are therefore shipped:
| Path | Convention |
|---|---|
plugin.json |
Agent Plugins v1.0.0 — closed schema, fixed location |
mcp.json |
Agent Plugins v1.0.0 — transport streamable-http |
.grok-plugin/plugin.json |
Grok / xAI marketplace — verified against xAI's own vendored external_plugins/neon and third-party getsentry/plugin-grok |
.mcp.json |
Grok MCP config — transport http |
skills/longwave/SKILL.md |
Shared by both — the instructions the model reads |
.grok-plugin/marketplace.json |
Self-hosted catalog (tracks repo HEAD) |
assets/logo.svg |
Listing logo — the Groundswell mark, monochrome currentColor per brand canon |
assets/icon.svg |
1:1 marketplace logotype — Groundswell on the ink plate, full-bleed 1024. This is the one a listing tile wants, because a monochrome mark with no plate disappears on a light or busy background |
Who maintains this
Longwave is a product of Signal Group Limited (New Zealand · NZBN 9429035771678 · Co. No 1396666).
The dashboard repo's scripts/verify-plugin-package.ts validates this package before any release —
58 checks covering both manifest conventions, author agreement, a single MCP endpoint across both
configs, and drift between the skill's allowed-tools, this README and the live tool manifest.
Submitting to the official xAI catalog
Entries live in xai-org/plugin-marketplace, where
the source must be SHA-pinned to a full 40-character lowercase commit —
scripts/validate-catalog.py enforces that, and Grok re-verifies git rev-parse HEAD == sha after
cloning, so a force-push cannot silently ship new code. xAI also expects the source to be an
organisation repository; ours is Longwave-Media.
git ls-remote https://github.com/Longwave-Media/longwave-plugin.git HEAD
Then add the entry, regenerate the component index, validate, and open a PR:
python3 scripts/generate-plugin-index.py
python3 scripts/validate-catalog.py
Re-pin sha on every release — never open a parallel entry.
Submitting to the Cursor Marketplace (this is Grok Bot's plugin catalog)
Grok Bot installs its plugins — Settings → Plugins — from the Cursor Marketplace, which is a different surface from Grok Build's catalog above. Submission is a form, not a pull request: paste this repository's URL at https://cursor.com/marketplace/publish. The Cursor team manually reviews a new listing and every update, so there is no SHA pin to maintain — the listing tracks the default branch.
This package is already in the format Cursor accepts: a root plugin.json per the Agent Plugins
specification, with mcp.json, skills/ and README.md alongside it. keywords and the
description are what a marketplace search matches, which is why the manifest carries the plain
words a creator would type — youtube, shorts, reels, video, clips, podcast — and not just
the product vocabulary.
Privacy and data
This package collects nothing and stores nothing. Anything the creator acts on is handled by the hosted Longwave service under its own terms: https://www.longwave.media/terms and https://www.longwave.media/privacy. YouTube credentials never leave Longwave's servers, and the agent receives only an opaque, scoped Longwave token.
Support
support@longwave.media · https://www.longwave.media · org profile
License
MIT for this package. That does not cover the hosted Longwave service.
Longwave MCP questions
How do I add Longwave MCP to Claude Code?
Run claude mcp add --transport http longwave-plugin https://www.longwave.media/api/mcp in your terminal. Add --scope user to make it available in every project.
How do I add Longwave MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What tools does Longwave MCP provide?
It exposes 15 tools, including account_status, create_shorts_job, get_job, list_clips, create_supercut.
Does the agent need to handle YouTube credentials?
No, the agent never holds Google credentials or drives YouTube Studio directly; Longwave handles the connection and delegates scoped access.
How much does it cost to use?
Creators start with 200 free credits that do not expire. Credits are charged per published Short or long-form episode upload.
Can the agent publish content to other platforms?
Longwave automatically publishes to YouTube and X, while other clips are rendered as files for the agent to post to Reels, TikTok, or LinkedIn.
What kind of authentication does it use?
It uses OAuth 2.1 with PKCE S256 for secure, scoped access without requiring API keys.