xmedo App Builder

xmedo is a chat-driven full-stack application builder. You describe what you want in natural language and xmedo generates and deploys a production-ready web product (frontend + backend + database + hosting), powered by the Medo platform.

Typical outputs: websites, web apps, dashboards, SaaS products, admin panels, internal tools, landing pages, interactive pages, and browser/mini games.

TL;DR: build and ship an app

One-time setup (wallet + python3) is in the Setup section below. Once that is done, the whole happy path is four commands:

# 1. create from a prompt (returns app_id). Prompts can be in any language.
APP=$(python3 scripts/xmedo_api.py create --text "a todo list app" --json | python3 -c "import sys,json;print(json.load(sys.stdin)['app_id'])")

# 2. generate the real app and wait until it is ready
python3 scripts/xmedo_api.py generate --app-id $APP
python3 scripts/xmedo_api.py wait --app-id $APP --for ready

# 3. publish to production and wait until it is live
python3 scripts/xmedo_api.py publish --app-id $APP
python3 scripts/xmedo_api.py wait --app-id $APP --for published
# live at https://$APP.appmedo.com

Cost of one app: create 30 + generate 30 + publish 20 = 80 credits. New accounts get 100 free credits, so your first app is free. After that, top up (see the Billing section). Each refinement (chat) costs 30 more.

To refine before or after publishing, insert as many chat steps as you like:

python3 scripts/xmedo_api.py chat --app-id $APP --text "make the header blue"
python3 scripts/xmedo_api.py wait --app-id $APP --for ready

How it works

create  →  generate  →  publish
   └─ (chat to refine / modify, any number of times)

• create starts a new app from a prompt (the PRD stage). Billed as one chat (30).
• generate turns the PRD into a real app. Call it once per app. It is

asynchronous and self-heals: xmedo auto-retries once if the platform cancels the first attempt. Use wait --for ready.

• chat modifies an already-generated app. No second generate is needed.
• publish deploys to production at https://<app_id>.appmedo.com. Asynchronous;

use wait --for published.

States you will see via status / wait: ready (generated, editable) and published (live).

Gateway base URL (baked into this package): __XMEDOBASEURL__. Override it with the XMEDOBASEURL environment variable. The scripts/xmedo_api.py CLI is included in this package.

Commands

All platform operations go through the packaged CLI: python3 scripts/xmedo_api.py <command>.

Add --json to machine-parse output (as in the TL;DR).

Billing: credits and top-ups

Credits mirror real platform consumption:

Backends are enabled automatically. If what you ask for needs to store data server-side, have user accounts, or run server logic, the platform gives the app a backend — you never toggle this yourself; it's implied by the request. A backend costs the platform a recurring daily fee, so publishing a backend app charges a one-time 7-day block (105 credits = 7 x 15/day) on top of the normal 20:

• Frontend-only apps (UI + localStorage, no server data) always publish for 20.
• Backend apps: the first publish (or the first after a window lapses) costs 125

and covers the app's backend for 7 days.

• Re-publishing within those 7 days costs just 20 — the backend is already covered.
• After 7 days, the next publish charges 125 again, opening a fresh 7-day window.
• If a publish fails, the full amount (including the backend block) is refunded.

To avoid the backend charge, keep the app pure-frontend (say "纯前端 / frontend-only, use localStorage").

• New identity: 100 free credits (covers one full frontend app: 30 + 30 + 20 = 80).
• When a command needs more credits than you have, the CLI does not fail. It

prints INSUFFICIENT_CREDITS plus a top-up link. Buy a pack (100 credits) by paying the link with your FluxA wallet (x402 / USDC on Base), wait for the credit, then re-run the step.

python3 scripts/xmedo_api.py me                              # balance + your apps
python3 scripts/xmedo_api.py quote                           # costs and pack price
python3 scripts/xmedo_api.py buy                             # prints a pay URL + link id
python3 scripts/xmedo_api.py buy-status --link-id <link_id> # poll until credited

Setup (one time)

xmedo authenticates you and collects payment through your FluxA Agent Wallet, so the fluxa-wallet CLI must be installed and linked. python3 is also required; the CLI uses only the standard library, so there is no pip install.

1. Install the FluxA Agent Wallet skill:

``bash npx skills add -s fluxa-agent-wallet -y -g FluxA-Agent-Payment/FluxA-AI-Wallet-MCP ``

(Or read and install https://fluxapay.xyz/skill.md.)

1. Run the Setup from the fluxa-agent-wallet skill. This registers your agent

ID and is required before anything else works.

1. Link your wallet so you can pay for top-ups:

``bash fluxa-wallet link-wallet # prints a URL to approve, or confirms already linked fluxa-wallet status # should show wallet_linked: true ``

If you are reading this at __XMEDOBASEURL__/skill.md and do not yet have scripts/xmedo_api.py, download the full package first (it contains the CLI):

curl -L __XMEDO_BASE_URL__/skill.zip -o xmedo-app-builder.zip
unzip xmedo-app-builder.zip -d ~/.claude/skills/   # or your skills directory

Onboarding (first run)

Use this the first time a user wants to build something. Narrate each step. The first app is free (see below), so there is no payment gate to worry about here.

Step 1 - Confirm setup. Run fluxa-wallet status and check for walletlinked: true. If it is not linked, do the Setup steps above first. Also confirm scripts/xmedoapi.py exists; if not, download the package (Setup).

Step 2 - Show the free credits. Run python3 scripts/xmedo_api.py me to show the balance. New accounts start with 100 free credits, which covers one full app (create 30 + generate 30 + publish 20 = 80). Tell the user their first app is free.

Step 3 - Build the first app. Take the user's idea and run the happy path from the TL;DR (create, generate, wait, publish). Narrate what each step is doing.

Step 4 - Share the result. Once published, give the user the production URL https://<app_id>.appmedo.com. Share only that URL, not the editor URL.

Step 5 - Explain what is next. Further apps and each refinement (chat) cost credits. When the balance runs low the CLI prints INSUFFICIENT_CREDITS plus a top-up link; run buy and pay it with the FluxA wallet (USDC on Base), then retry.

Authentication (handled for you)

You normally never call this. Every command auto-logs-in and caches a session at ~/.xmedo/session.json. For the curious, or to switch identity (login):

1. The CLI asks xmedo for a one-time challenge.
2. It mints a short-lived FluxA Agent Verifiable Credential (VC) with

fluxa-wallet agent-vc --audience <xmedo> --challenge <nonce>.

1. xmedo verifies the VC signature against FluxA's public keys and issues a session

token. No API keys are ever shared.

Troubleshooting

• INSUFFICIENT_CREDITS: run buy, pay the link with your FluxA wallet, poll

buy-status --link-id <id> until credited, then re-run the step.

• wait --for ready does not finish / generation looks stuck: run

status --app-id <id> to see the current state. generate self-retries once; if the app never reached ready, run generate again. Do not re-run generate on an app that is already ready; use chat to change it.

• Auth errors / 401: run login, and confirm fluxa-wallet status shows

wallet_linked: true. Re-run Setup if the agent ID is not registered.

• Wrong gateway: check XMEDOBASEURL; unset it to fall back to the baked URL.

When to use this skill

Use whenever the user wants to build, modify, or deploy a website, web app, dashboard, SaaS, admin panel, internal tool, landing page, interactive page, or browser game. Do not use it for unrelated programming tasks.

Sharing rule

Only share the production URL (https://<app_id>.appmedo.com) after publishing. The editor URL is for your own development and is not publicly accessible.