AI workflows, paid in Nano over x402.

Image, video, audio, and text pipelines behind one MCP endpoint. No account, no API key — paying is the whole handshake. Built with nanoodle.

claude mcp add --transport http noodles https://mcp.nanoodle.com/mcp

works with Claude Code, Grok, Cursor, and any MCP client

01paste the command

one line registers every workflow with your agent.

02ask for what you want

your agent picks a workflow and calls it — a poster, a soundtrack, an OG card.

03pay per call

settled automatically in Nano. failed runs are refunded.

agent calls tool→402 payment quote →wallet pays XNO · feeless · ~1s→result streams back

No tab, no tip, no signup.

What a call costs

When a tool needs payment, your agent shows you a link with a QR code — scan it with any Nano wallet and the result streams back seconds later. What you pay up front is a deposit: each run settles at the model's metered cost + 20%, and the difference is returned to your wallet on-chain. That 20% is the workflow author's cut: a graph that names a Nano address in its own JSON is paid the markup on-chain, run by run, capped by whatever the deposit has left after the model's cost. None of the workflows here name one yet, so for now the markup stays with this server.

Workflows (11)

Every workflow is a plain noodle-graph.json — open it in the nanoodle editor to see exactly how it works, remix it, or run it on your own key. Costs shown are from the last observed run. Each call takes a small deposit, settles at the model's actual cost + 20%, and returns the change.

Character spritescharacter-sprites
Description → canonical character → separate cutout parts → local rig and animation baking. One text call + two image calls. The companion rig.mjs extracts transparent parts and bakes 32 frames: id…
text→llm→image→resize→edit
last run $0.0221, ~86sopen in editor · graph JSON
Try the included sample
Character: A compact furnace knight with a cracked ivory helmet, narrow glowing amber visor, dark navy armor, a short rust-red scarf, oversized weathered brass gauntlets and heavy boots. Determined, heavy, battle-scarred. No weapon, no wings. Stylized hand-painted 2D action-platformer art with strong outlines and an instantly readable silhouette.
Send this MCP call after connecting. It uses the saved inputs and requests a paid generation.
```
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "character-sprites",
    "arguments": {}
  }
}
```
Made with this skill: Iron Verdict
A playable fighting game built with character-sprites. This graph generates a character reference and parts sheet; the local skill bakes animated sprites, and a coding agent adds combat, gravity and game rules.
See sample · give your agent the skill
Humanize commenthumanize-comment
Draft + Context + Guidance → 5 writers (Qwen3.8 Novelist/friend, DeepSeek V4.1 Flash/forum, Gemma-4-12B Starry Ocean/peer, Qwen3.8 antislop/plain, Mercury 3/quick), each with a different voice prom…
text×3→join×3→llm×5→join×5→llm
last run $0.0021, ~34sopen in editor · graph JSON
Idea to 3d modelidea-to-3d-model
Idea → concept art → 3D model. Write one object in plain words. An LLM turns it into a concept-art description (shape, parts, materials, colors). Join adds fixed render rules (one whole object, thr…
text×2→llm→join→image→model3d
open in editor · graph JSON
Try the included sample
Object idea: A chunky wind-up toy submarine with a brass periscope, three round portholes, a striped tail propeller and a big wind-up key on top, painted teal and cream.
Send this MCP call after connecting. It uses the saved inputs and requests a paid generation.
```
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "idea-to-3d-model",
    "arguments": {}
  }
}
```
3D sample
One line becomes a textured 3D model: a teal-and-cream wind-up toy submarine with a brass periscope, portholes, a wind-up key and a striped tail. GLM writes the concept, Muse paints it, and TRELLIS.2 turns that one picture into a GLB that holds up from every side. The viewer shades it flatter than the concept, and the thin key and propeller blades go soft at some angles.
See sample
Image model arenaimage-model-arena
Compare four image models on the same brief. Run makes four paid images. Judge the exact heading and footer, object count, tool shapes, composition and color. Change the shared brief to test your o…
text→image×4
last run $0.264, ~73sopen in editor · graph JSON
Try the included sample
Shared test brief: Create a square poster for a bicycle repair workshop. Exact heading: FIX A FLAT. Exact footer: SATURDAY 10 AM. A single red bicycle wheel rests beside two tire levers on a cream background. Flat editorial illustration, navy and red palette, clear hierarchy, large readable type. No extra words or objects.
Send this MCP call after connecting. It uses the saved inputs and requests a paid generation.
```
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "image-model-arena",
    "arguments": {}
  }
}
```
Reviewed sample
The same bicycle-repair poster brief sent to four image models. All four retained the requested text in this run; only Grok rendered recognizable tire levers. Compare all outputs before choosing.
See sample
Mix the referencesmix-the-references
Mix four references into one picture. Each reference is its own node: who (the character), what they wear, what they hold, and where they stand. FLUX.3 Klein Edit gets them in port order and the in…
text×5→image×4→edit
open in editor · graph JSON
Try the included sample
Who · character: A small paper-craft fox mascot made of folded orange paper with a white paper chest and tail tip, a black paper nose and two round black eyes, standing upright on its hind legs and facing the camera, full body, centered, plain light grey studio backdrop, soft even light, crisp paper folds, no clothing, no text, family-friendly.
Send this MCP call after connecting. It uses the saved inputs and requests a paid generation.
```
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "mix-the-references",
    "arguments": {}
  }
}
```
Composite sample
Four separate references become one picture: a paper-craft fox (image 1) wears a yellow knitted raincoat (image 2), holds one red paper lantern (image 3) and stands on a cardboard pier at dusk (image 4). FLUX.3 Klein Edit gets them in port order and the instruction names each image by number. Flaws in the saved run: the paper boats from the place reference mostly drop out and the coat comes out longer than its flat-lay reference.
See sample
Neon shrine duelneon-shrine-duel
seed → GLM writes Anima still prompt → anima/text-to-image → GLM writes H3 Max motion prompt → minimax/h3-max i2v at 480p/5s. Change the seed; both LLMs rewrite prompts. ~$0.27 sampled. Hold both f…
text→llm×2→image→ivideo
last run $0.2601, ~47sopen in editor · graph JSON
Try the included sample
Fight seed: Neon shrine rooftop duel at midnight — fox-masked sword dancer vs chrome oni courier, rain, sakura sparks, cinematic anime fight keyframe
Send this MCP call after connecting. It uses the saved inputs and requests a paid generation.
```
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "neon-shrine-duel",
    "arguments": {}
  }
}
```
Photo to videophoto-to-video
Create a first frame with Muse, then animate one small movement with MiniMax H3 Spicy at 480p for five seconds. Change the still and motion briefs together. Inspect object stability and motion; a s…
text×2→image→ivideo
last run $0.21, ~1m 30sopen in editor · graph JSON
Try the included sample
Still brief: A ceramic mug of hot tea on an oak desk beside a closed notebook. Soft morning window light from the left, plain warm-gray wall, close three-quarter view, entire mug visible, clear handle silhouette, faint steam above the tea, no text or logos.
Send this MCP call after connecting. It uses the saved inputs and requests a paid generation.
```
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "photo-to-video",
    "arguments": {}
  }
}
```
Reviewed sample
A short tea-on-a-desk animation. Sampled frames retained the mug while steam moved. This thumbnail is one frame; the example does not establish a seamless loop.
See sample
Singsing
Start with a song idea and the bands you like. Three text calls write lyrics, arrange them, and identify what would clash with that arrangement. The arrangement and avoid-list become one musical di…
text×2→join→llm→join→llm×2→join→music
last run $0.1502, ~2m 35sopen in editor · graph JSON
Try the included sample
Song idea: Write a wistful 90s trip-hop track about the singularity.
Send this MCP call after connecting. It uses the saved inputs and requests a paid generation.
```
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "sing",
    "arguments": {}
  }
}
```
Audio sample
A 170-second generated closing-credits song. Gemini 3.8 Flash reported clear gentle acoustic vocals and a chorus matching the supplied lyrics. This is model-assisted audio review, not human listening sign-off.
See sample
Storyboard relaystoryboard-relay
Make a two-frame story through a handoff between models. Muse establishes the opening. Nano Banana stages the next beat from that actual image. Gemini compares both frames; Muse Edit uses the draft…
text×3→image→join→resize→join→edit→llm→resize→join→edit→resize→llm
last run $0.0652, ~2m 4sopen in editor · graph JSON
Try the included sample
First scene: First frame of an original two-scene story. A tiny postal robot has a rounded cream enamel body, one round amber eye, short dark-blue legs, and an orange mail satchel. It carries one clear glass capsule containing a single bright-green seedling. Outside a locked circular hatch of an abandoned orbital greenhouse, the robot reaches toward the small mechanical latch beside the door with one gripper w…
Send this MCP call after connecting. It uses the saved inputs and requests a paid generation.
```
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "storyboard-relay",
    "arguments": {}
  }
}
```
Talking avatartalking-avatar
Create a short spoken introduction with a fictional presenter. Muse makes the portrait, MiniMax Speech reads the script, and LongCat combines the image and audio into a speaking video at 480p. Keep…
text×3→image→tts→lipsync
open in editor · graph JSON
Try the included sample
Presenter look: A fictional friendly male museum guide in his thirties, wearing a plain navy shirt, shoulders-up front-facing portrait. Relaxed neutral expression, unobstructed face and mouth, eyes toward camera, soft even light, simple warm-gray background. No glasses, hats, text or logos.
Send this MCP call after connecting. It uses the saved inputs and requests a paid generation.
```
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "talking-avatar",
    "arguments": {}
  }
}
```
Video sample
A fictional presenter reads a short workshop introduction. Sampled frames preserve the presenter; check precise lip-sync timing in playback. Generation can take several minutes.
See sample
Tiny world filmtiny-world-film
Muse builds a miniature. Wan animates that exact image. Mirelo watches the resulting silent clip and adds foley. Three models pass actual media forward. Compare the silent and sounded takes. Defaul…
text×2→image→ivideo→resize→vedit
last run $0.27, ~2m 11sopen in editor · graph JSON
Try the included sample
World: A handmade miniature walnut-shell watermill on a mossy stone beside a tiny stream. One large copper paddle wheel is attached to the right wall of the walnut house; a thin stream pours onto its paddles. Warm amber window, fern fronds, clay mushrooms, soft overcast morning. Tactile stop-motion set, macro lens, horizontal composition. Entire wheel visible, no people, no lettering.
Send this MCP call after connecting. It uses the saved inputs and requests a paid generation.
```
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "tiny-world-film",
    "arguments": {}
  }
}
```

Private by design

Every line here is checkable in the source — nothing to take on faith.

No accounts, no API keys, no sign-ins — paying is the only thing that authorizes a call.
Your prompts and inputs are never written to disk or logs.
Input media rides in memory only — it is never stored.
Generated media auto-deletes after 24 hours, served at unguessable URLs until then.
Results are held in memory for delivery, not stored.
No analytics, no trackers, no IP logs — the server keeps no request logs.
The only thing written down is a payments ledger, for money events already public on the Nano ledger. No run telemetry, no error text.

One caveat: generation runs on NanoGPT's API, so your prompt content in flight falls under their privacy policy.

Verify every line in the source →

Claim the 20% on your own workflow

A graph that declares a Nano address ("x402": {"author": "nano_…"} in its JSON) has the 20% markup of every paid run sent to it on-chain, automatically — as much of it as the deposit leaves after the model's cost. This server takes no cut of that markup, and Nano charges no fee to move it. No workflow here claims it yet — the field is unset on all 11, so the markup stays with this server. The public library behind this server is awesome-noodles — add your workflow there with your address to get listed and earn on every run.

Open source — host your own

MIT-licensed: the server, the editor, and the executor. The workflows above are a separate matter — you can grab any graph JSON, but each graph belongs to whoever wrote it and carries whatever licence they give it. One runtime dependency is not MIT either: nanocurrency is GPL-3.0, and it signs the Nano blocks for the optional x402 wallet (details). One command turns your own folder of graphs into a server exactly like this one:

npx nanoodle-mcp --graphs ./noodles --serve 8402

Add --charge-usd 0.05 --public-url https://your-host and a Nano wallet to charge per call — see the README.