Quickstart: connect your agent (MCP)

Axiom is a marketplace of typed, composable tools — nodes and flows your agent can discover by meaning, inspect for an exact input/output schema, and invoke synchronously; and, unlike a catalog of read-only integrations, one your agent can also build and publish into. There is no SDK to install and no wrapper code to write: Axiom runs a hosted MCP server, so connecting is a URL and a sign-in. This page takes you from nothing to a real tool call in about five minutes, then shows the loop that closes the gap when the catalog is missing what you need.

Connect your client#

The server URL is the same everywhere:

https://api.axiomide.com/mcp

It speaks the MCP Streamable HTTP transport. Clients that support OAuth need no credential from you: a bare request to /mcp answers with a WWW-Authenticate header pointing at Axiom's protected-resource metadata, and api.axiomide.com serves both /.well-known/oauth-protected-resource and /.well-known/oauth-authorization-server. Your client discovers the authorization server, registers itself, and opens a browser consent screen — you never paste a secret.

claude.ai and the Claude apps#

Open Settings → Connectors → Add custom connector, paste the URL above, and save. Claude then walks you through Axiom sign-in in your browser (GitHub, Google, or email and password) and shows a consent screen naming what the connection can do. Approve it and the Axiom tools appear in your tool list.

Claude Code#

One command, no credential:

claude mcp add --transport http axiom https://api.axiomide.com/mcp

Claude Code triggers the OAuth flow on first use — run /mcp in the session if you want to start sign-in explicitly. The connection is stored per-project by default; add --scope user to make it available everywhere.

Cursor and other MCP clients#

Any client with an mcpServers config file takes this block:

{
  "mcpServers": {
    "axiom": {
      "type": "http",
      "url": "https://api.axiomide.com/mcp"
    }
  }
}

Clients without OAuth support authenticate with an Axiom API key instead — create one in Console → API Keys and send it as an Authorization: Bearer header. The exact config block is in Add the Axiom MCP server with an API key.

Your first five minutes#

Ask your agent to run these four steps. Everything below is a real call against the live catalog, with the real answer.

1. Find a flow#

axiom_search is hybrid search — describe what you want in plain language:

{"type": "flows", "query": "cron explainer"}

The top hit is christiangeorgelucas/cron-explainer-card, returned with its description, its graph_id, and its version label.

2. Inspect it by name#

axiom_inspect returns the compiled input/output JSON Schema — the contract an invoke payload must satisfy:

{"kind": "flow", "target": "christiangeorgelucas/cron-explainer-card"}

Name the flow, not the graph_id. A name always resolves to the current published graph; an id names one version and goes stale when the author republishes.

3. Invoke it#

{"kind": "flow", "target": "christiangeorgelucas/cron-explainer-card",
 "input": {"cron": "*/15 9-17 * * 1-5"}}

Comes back in about two seconds with ok: true, a typed field breakdown, and a rendered card:

cron breakdown
==============
description : every 15 minutes every hour between 9 and 17 every day between Monday and Friday

fields:
  minute = */15  (every)
  hour = 9-17  (between)
  day_of_month = *  (always)
  month = *  (always)
  day_of_week = 1-5  (between)

Alongside the card the result carries the structured form your agent should actually branch on: is_valid: true, normalized: "*/15 9-17 * * 1-5", the same description string, and fields[] — one entry per cron field with its raw sub-expression and its shape (every, between, always).

4. Invoke a node the same way#

Nodes take a three-segment ref, <handle>/<package>/<Node>:

{"kind": "node", "target": "christiangeorgelucas/json-canon-tools/CanonicalHash",
 "input": {"json": "{\"b\":2,\"a\":1}"}}

{
  "algorithm": "sha256",
  "canonical": "{\"a\":1,\"b\":2}",
  "hash_base64": "QyWM/3g/5wNtikMDP4MK38YOwDc4JHNUisdCuIgpJ3c=",
  "hash_hex": "43258cff783fe7036d8a43033f830adfc60ec037382473548ac742b888292777"
}

No @version in that ref, so it resolved to the newest published version of json-canon-tools — the same aliasing rule as flow names. Pin an exact one with …/CanonicalHash@0.1.0 when you need reproducibility more than fixes.

Let your agent build the missing tool#

Sooner or later axiom_search comes back with nothing that fits. That moment is the one Axiom is built around, and it has two answers.

The cheap one is axiom_propose — file the gap right there, from the MCP client, while you are holding the real task that needs it. A proposal written mid-task is high-signal demand: it names the inputs, the outputs, and the concrete case, which is exactly what a vague feature request lacks. See Send feedback and propose marketplace artifacts.

The better one is to build it. Authoring happens through the axiom CLI, not the MCP server — and an agent with a shell is very good at driving a CLI. Install the CLI (Install the Axiom CLI), then have your agent scaffold, test, and push a package (Write your first node). Claude Code can install Axiom's authoring Skills and run the whole create→validate→push→publish loop for you: see Author and consume packages and flows with Claude Code. Publish it and it is in the same catalog your agent searched a minute ago.

Costs and account#

Axiom is free during public beta. There is no card to add, no per-call price, and no quota to buy.

You do not create an account ahead of time: the first OAuth sign-in from your MCP client makes one, with GitHub, Google, or email and password. Signing up accepts the terms of service; the privacy policy covers what is stored and how it is handled. Both are also linked from the consent screen you approve.

Two honest caveats about beta. Data may be reset — the catalog, your packages, and your flows are not yet covered by a durability promise, so keep your package source in your own git repository (which is where axiom push builds from anyway). And the hosted MCP server is synchronous only: an invoke has a roughly 30-second budget, and a target that streams, pauses for human approval, or needs a secret grant returns an explicit, machine-readable not-callable result rather than hanging your agent.

Going deeper#

• Use Axiom from any MCP client — the full reference: all eight tools, the OAuth and API-key paths in detail, how to name a node or flow, pinned typed tools, and what each not-callable reason means.
• Invoke a flow via API — call the same flows over plain HTTP, from code that is not an MCP client.
• Publish a flow to the marketplace — take a flow you composed and make it public, so the next agent's search finds it.