io.github.RunOnFluxPublished by GitHub account RunOnFluxv0.2.8Updated Oct 24, 2026
Deploy, pay for and manage apps on Flux Cloud, the decentralized cloud. Prices in USD.
Deploy, pay for and manage apps on Flux Cloud, a decentralized cloud, letting an assistant quote, launch, monitor, update and cancel deployments.
Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.
Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.
Read https://sourceweft.com/mcp/io.github.RunOnFlux%2Fflux-cloud-mcp/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.Add this to your client's mcpServers config.
{
"mcpServers": {
"flux-cloud": {
"type": "http",
"url": "https://mcp.runonflux.com/mcp"
}
}
}An MCP server that lets any AI agent use Flux Cloud, the decentralized cloud: quote an app in US dollars, deploy it, pay for it, watch it come up, read its logs, update it, and cancel it. Works with Claude Code, Claude Desktop, Cursor, Windsurf, OpenCode and every other MCP host.
There is no account. Two keys are the whole identity:
The server generates a pair for you (flux_generate_keys); fund the payment
address with FLUX and deploy.
Every price this server shows is the Flux Cloud USD price, the same one
home.runonflux.io charges, converted to FLUX at the
live market rate with the 5 percent pay-in-FLUX discount. Quotes come from the
network itself (/apps/calculatefiatandfluxprice), so they include the $0.99
minimum, hardware and term discounts, and update credits.
The blockchain's own acceptance threshold is several times lower. It is never shown as a price; it is only checked as a guard before a payment is broadcast.
Or run it without installing: npx @runonflux/flux-cloud-mcp.
Keys are optional. Without them every read-only tool works, and
flux_generate_keys will create a pair to put into the config.
Resources flux://guide/overview, flux://guide/spec-format,
flux://guide/pricing and flux://guide/gotchas give the agent the domain
knowledge; the deploy_on_flux prompt walks it through a deployment.
api.runonflux.io exactly as it will be at
registration (image reachable, architecture, ports, name free). If the
balancer refuses, a few healthy nodes are probed and tried in turn.confirm=true the Flux ID signs the spec, the same endpoint
broadcasts it to the network and returns a 64-character message hash.Private (enterprise) apps publish an empty component list, so flux_get_app,
flux_get_app_logs and flux_get_app_stats fetch the decrypted specification
from an ArcaneOS node with the owner key when it is configured or passed. Only
component names, images, ports and sizes are returned; environment variables,
commands and registry credentials never leave the server.
Updates use the same tool: an existing app of the same owner gets a
fluxappupdate message and the network credits the unused part of the old
term. Private (enterprise) apps are supported through the enterprise
argument: components are encrypted for the network and only ArcaneOS nodes
can run them.
The same server also runs on Flux Cloud itself, over Streamable HTTP, for hosts that cannot start a local process (claude.ai connectors, ChatGPT, browser and mobile agents). Add it as a remote MCP server:
The hosted server holds no keys. Read-only tools need none. Tools that sign
or pay take fluxIdPrivateKey and paymentPrivateKey as call arguments,
used in memory for that call and never logged or stored. The server's
instructions tell agents to create a dedicated pair with flux_generate_keys
and to have the user fund only what a deployment needs, rather than asking
for the keys of a wallet used elsewhere. Anything typed into a chat passes
through the AI vendor and the host's history, so treat such a pair as
disposable and keep its balance small. For larger budgets, run the local
server, where keys never leave your machine.
Run your own copy with Docker:
It is stateless, so any number of instances can sit behind one load balancer.
GET /healthz reports liveness. The Flux app specification that runs the
public instance is in deploy/cloudmcp.json.
flux_generate_keys returns only the keys it just created.confirm=true. Hosts that
ask before tool calls will show the USD amount in the arguments' context.The USD estimator, the specification formatter and the consensus guard mirror
the FluxOS code (appSpecHelpers.js, appUtilities.js, messageVerifier.js)
and the live test checks the estimator against the network on every run.
MIT
Source: README.md at commit e10d2ad
Show the configured Flux identity and balance
Returns the Flux ID (app owner address), the payment address and its spendable FLUX balance with its USD value. Explains what to configure if keys are missing. Never returns private keys.
fluxIdPrivateKeypaymentPrivateKeyGenerate a new Flux ID and payment key pair
Creates two fresh private keys (WIF): one for the Flux ID that will own apps, one for the address that pays. The response contains the secrets; store them in the MCP server environment as FLUX_ID_PRIVATE_KEY and FLUX_PAYMENT_PRIVATE_KEY, then restart the server. Nothing is stored or sent anywhere by this tool.
fluxIdPrivateKeypaymentPrivateKeyGet the Flux Cloud rate card
Returns the current USD rate card, the live FLUX/USD rate, the pay-in-FLUX discount and instant USD estimates for a few reference sizes. Use flux_quote_app for the exact price of a specific app.
fluxIdPrivateKeypaymentPrivateKeyBuild a Flux app specification from a simple description
Turns images, ports, resources and a term into a complete, correctly formatted v8 specification, with public ports auto-picked and data replication enabled. Returns the spec plus local validation errors and warnings.
namerequirednodesownermonthscontactsstaticipinstancescomponentsrequireddescriptiongeolocationexpireBlocksfluxIdPrivateKey+1 moreValidate a specification locally and on the network
Runs the local rule checks, then asks a FluxOS node to verify the specification exactly as it would at registration (image reachable, architecture, ports, name availability). Returns the node-formatted spec on success.
specrequirednetworkfluxIdPrivateKeypaymentPrivateKeyQuote the price of an app in USD and FLUX
Returns the Flux Cloud price for registering the given specification, or for updating it if an app of that name already exists (the unused part of the current term is credited). Price is in USD with the FLUX amount at market rate.
specrequiredfluxIdPrivateKeypaymentPrivateKeyDeploy (register or update) an app and pay for it
Validates the specification on a node, quotes it, and with confirm=true signs it with the Flux ID, broadcasts it and pays the quoted FLUX from the payment address. Without confirm it only returns the plan (price, balance, warnings) and spends nothing. Registers a new name or updates an existing app of the same owner. Then call flux_wait_for_app with the returned txid.
specrequiredconfirmenterprisefluxIdPrivateKeypaymentPrivateKeyWait for a deployment to be accepted and its instances to run
Polls the network for up to timeoutSeconds (default 45 to fit hosts with a 60 s tool timeout, max 600). Returns payment confirmations, whether the spec was accepted, and the running instances with URLs. Safe to call repeatedly until done=true.
namerequiredtxidpreviousHashtimeoutSecondsfluxIdPrivateKeypaymentPrivateKeyGet a deployed app: spec, status, instances, URLs
Looks up any app on the network by name and returns its published specification, expiry, running instances, URLs and a reachability check: probes the shared domain (HTTP) and each instance port (TCP and HTTP) and explains what a 503 means, including when it is expected for non-web apps.
namerequiredportsfluxIdPrivateKeypaymentPrivateKeyList apps owned by the configured Flux ID
Lists every app registered by the owner (or a given Flux ID) with expiry and instance counts.
ownernameContainsfluxIdPrivateKeypaymentPrivateKeyRead container logs from a running instance
Fetches the last N log lines of an app from one of the nodes running it. Requires the owner key. The component is picked automatically when the app has one (private apps are decrypted with the owner key); otherwise the available names are listed.
namerequiredlinesnodeIpcomponentfluxIdPrivateKeypaymentPrivateKeyGet live resource usage of a running instance
CPU, memory and network stats of the containers of an app on one node. Requires the owner key.
namerequirednodeIpcomponentfluxIdPrivateKeypaymentPrivateKeyRestart, redeploy or remove app instances
restart: restarts containers. redeploy: pulls the image again and recreates containers (hard=true also wipes data). remove: uninstalls from nodes; the registration stays and the network re-spawns it elsewhere, so use flux_cancel_app to stop paying. Scope is one node (nodeIp) or every node running the app (global). Requires the owner key.
hardnamerequiredscopeactionrequirednodeIpfluxIdPrivateKeypaymentPrivateKeyCancel an app (stop it and stop paying)
Ends an app early by updating its term so it expires within about an hour. The network then uninstalls it everywhere. With confirm=true this signs and pays the (usually minimal) update; without it, returns the plan.
namerequiredconfirmfluxIdPrivateKeypaymentPrivateKeyNetwork overview
Node counts by tier, current block height, FLUX/USD rate and the deployment payment address.
fluxIdPrivateKeypaymentPrivateKey100% of the applicable checks met
How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.
npm install -g @runonflux/flux-cloud-mcp # or: yarn global add @runonflux/flux-cloud-mcpclaude mcp add flux-cloud -s user \ -e FLUX_ID_PRIVATE_KEY=<wif> -e FLUX_PAYMENT_PRIVATE_KEY=<wif> \ -- npx -y @runonflux/flux-cloud-mcp{ "mcpServers": { "flux-cloud": { "command": "npx", "args": ["-y", "@runonflux/flux-cloud-mcp"], "env": { "FLUX_ID_PRIVATE_KEY": "<wif of the Flux ID>", "FLUX_PAYMENT_PRIVATE_KEY": "<wif of the payment address>" } } }}{ "mcp": { "flux-cloud": { "type": "local", "command": ["npx", "-y", "@runonflux/flux-cloud-mcp"], "environment": { "FLUX_ID_PRIVATE_KEY": "<wif>", "FLUX_PAYMENT_PRIVATE_KEY": "<wif>" } } }}> deploy nginx on flux, 3 instances, one month
flux_get_identity -> Flux ID 1Ab..., payer t1Cd..., 996.98 FLUX ($48.74)flux_build_spec -> v8 spec, port 39978 -> 80, r:/data, validflux_quote_app -> $0.99 for 1 month, pay 19.24 FLUX (5% FLUX discount) user agreesflux_deploy_app confirm=true -> message hash 8d2f..., paid 19.24 FLUX, txid 0c41...flux_wait_for_app -> accepted at height 2941560, 3/3 instances running https://myapp.app.runonflux.iohttps://mcp.runonflux.com/mcp (also https://mcp.runonflux.io/mcp)docker run -p 3000:3000 runonflux/flux-cloud-mcpyarn installyarn type-check && yarn lint && yarn format:check && yarn build && yarn testyarn test:live # differential test of the USD estimator against the network