MCP server

Agents that onboard themselves

Point any MCP client at murmurator.app/mcp with no credentials at all. It can create its own account, wire up models and connections, write and run workflows, invite your team and start a subscription — held to exactly the same roles and limits as a person.

Self-onboarding

The first call needs no key

Most MCP servers start with a human in a settings page, copying a token into a config file. Ours starts with the agent. Ask for the tool list with no Authorization header and you get two: sign_up and sign_in. Both hand back a token for the very same URL.

  • sign_up creates the user, the account and the token in one call
  • sign_in trades an existing login for a token scoped to one account
  • Accounts made this way get the same 14-day trial, no card required
  • Anonymous requests are rate limited per IP address
 1 · No Authorization header
POST /mcp

{ "method": "tools/call", "params": { "name": "sign_up",
    "arguments": {
      "name": "Ada Lovelace",
      "email_address": "ada@northwind.example",
      "account_name": "Northwind" } } }

# → { "api_token": "mur_…",
#     "account": { "slug": "northwind",
#                  "trial_days_left": 14 } }
 2 · With the token it just got
POST /mcp
Authorization: Bearer mur_…

{ "method": "tools/list" }

# → 45 tools: workflows, runs, connections,
#   models, the team and billing

Zero to running

Four calls from stranger to first run

Sign up

One call creates the user, the account and the API token. The trial starts the moment it returns, so there is nothing to wait for.

Set itself up

list_setup_options returns every connection kind, the credential fields of the ones it asks about, and every model on offer. add_ai_model and create_connection wire them up — and credentials are verified on the spot.

Build and check

get_reference is the whole workflow language. validate_definition and test_javascript catch mistakes before anything is saved, and every save lands as a new version.

Run and hand over

run_workflow starts a run; get_run reads each step's input, output, error and logs. Your team watches the same run live in the app.

The tool set

47 tools behind one endpoint

The same tools our own assistant uses to build workflows, plus everything it takes to run the account around them.

Without a token

sign_upsign_in

Workflows and runs

get_referencelist_workflowsget_workflowlist_connectionslist_modelscreate_workflowvalidate_definitionupdate_workflowset_workflow_enabledrun_workflowlist_runsget_runtest_javascript

Artifacts

artifact__createartifact__writeartifact__readartifact__appendartifact__edit_sectionartifact__listartifact__import

Screenshots

screenshot__capturescreenshot__readscreenshot__list

Accounts and tokens

get_accountlist_accountscreate_accountlist_api_tokenscreate_api_tokenrevoke_api_token

Billing

get_billingstart_subscriptionopen_billing_portalset_ai_spend_limit

Team

list_membersinvite_memberset_member_roleremove_member

Models and connections

list_setup_optionsadd_ai_modelset_default_ai_modelremove_ai_modelcreate_connectionupdate_connectionverify_connectiondelete_connection

Read the MCP guide →

Workspaces

Build the automation that writes the code

Your agent doesn't have to do the work itself, on your laptop, every time. It can write a workflow that clones the repository into a sandboxed workspace, hands the job to a coding agent there, runs the tests and opens a pull request — then a GitHub label, a schedule or a webhook fires it, with nobody watching.

  • The same workspace.* tools the assistant writes into definitions
  • Sandboxed per run, with no route to our servers or your credentials
  • Every run keeps the agent's account of what it did, the diff and the test output
See the workspaces guide → 
 update_workflow
{ "method": "tools/call", "params": { "name": "update_workflow",
    "arguments": {
      "workflow": "issue-to-pull-request",
      "definition": "trigger: …\n  - key: fix\n    tool: workspace.agent",
      "summary": "Fix labelled issues and open a PR" } } }

# → { "version": 3, "valid": true,
#     "steps": ["issue", "checkout", "fix",
#               "tests", "commit", "push",
#               "pull_request"] }

Guardrails

An agent gets no more than a teammate would

Scoped, revocable tokens

A token acts as one person in one account, with their role. Owners and admins manage connections and models; only owners touch billing. Tokens are shown once and can be revoked instantly.

Every change attributed

Each definition an agent saves becomes a new version marked mcp, with a one-line summary and a diff against the last. Nothing changes silently.

Sandboxed execution

JavaScript steps run in a fresh V8 isolate with time and memory limits and no host APIs. Workspaces run in a Docker sandbox that is deleted with the run. Connections can't reach private networks, and repositories and channels can be allow-listed.

Spend you cap

Built-in model usage is metered against a monthly limit an owner sets. Steps fail with a clear message rather than running up a bill.

Why workflows are the guardrail →

Billing

Subscribing is a link, not an action

An agent can't type in card details, and shouldn't. start_subscription returns a Stripe Checkout URL for a person to open, and open_billing_portal does the same for the card, invoices and cancellation. Everything either side of that, the agent can read for itself.

  • Trial state and days left, so it can ask before the trial runs out
  • Subscription status, renewal date and whether a cancellation is pending
  • Built-in AI spend this month against the limit, and what's left of the trial credit
  • The plan's limits and what the account has used of them
 get_billing
{
  "state": "trialing",
  "trial_days_left": 6,
  "subscribed": false,
  "plan": { "key": "team", "monthly_price": 99,
             "limits": { "run_concurrency": 5, "workspace_hours": 5 } },
  "murmurator_ai": {
    "spend_this_month_usd": 2.41,
    "trial_credit_remaining_usd": 2.59,
    "monthly_limit_usd": 100.0 }
}

# start_subscription → a checkout link
#   for a person to open

Connect a client

Already have an account? Paste a token.

Create one under MCP & API tokens, or let the agent call sign_in with your email and password and make its own.

 Claude Code
claude mcp add --transport http murmurator \
  https://murmurator.app/mcp \
  --header "Authorization: Bearer mur_…"
 Any MCP client
{ "mcpServers": { "murmurator": {
    "type": "http",
    "url": "https://murmurator.app/mcp",
    "headers": { "Authorization": "Bearer mur_…" } } } }

Let your agents build the automations.

14-day free trial with $5 of built-in AI included. Cancel anytime.

Start free trial Talk to us