Documentation

Connect any MCP client — the Claude apps, Claude Code, Cursor — to Axiom's hosted MCP server at https://api.axiomide.com/mcp, then have your agent discover, run, and publish typed tools and flows without writing any wrapper code.

Install the axiom CLI with Homebrew or the curl install script, authenticate with axiom login, and confirm your identity and tenant with axiom whoami.

Scaffold a package with axiom init, create a Python node, and iterate locally with axiom validate, axiom test, and the axiom dev hot-reload server.

Push your package with axiom push, import its nodes into the canvas editor, connect them into a flow, and run it from the editor.

Create an API key, copy the ready-made curl command from the Use via API dialog, and call your compiled flow over HTTP — one-shot or as an SSE stream.

Axiom's core object model — how messages, nodes, packages, flows, executions, and the entry and terminal nodes relate to each other.

How Protocol Buffers define every contract in Axiom: messages as node inputs and outputs, importing types from other packages with axiom import, and how the canvas keeps edges type-safe.

How Axiom runs a flow: immutable compiled artifacts, unary vs pipeline (SSE) invocation, the Executions list and detail pages, and durable resume after worker failure.

What node code can and cannot do at runtime: the sidecar is a node's only channel to the platform, and tenant isolation is enforced by the platform — never by your code.

Scaffold a Python package, define protobuf messages, implement a typed node function with AxiomContext, test it with pytest, and push it to Axiom.

Scaffold a Go node with the Axiom CLI, implement the handler against generated protobuf types, test it, and run it locally with hot reload.

Scaffold, implement, test, and push a TypeScript node with the Axiom CLI, using google-protobuf message classes and AxiomContext.

Scaffold a Rust node package, implement the handler against the AxiomContext trait, run cargo-based tests with axiom test, and push it to the platform.

Scaffold a Java package and node with the Axiom CLI, implement the handler against AxiomContext, test it with Maven, and push it to the platform.

Scaffold a C# package, implement a unary or pipeline node against IAxiomContext, and run xUnit tests with axiom test — codegen happens at dotnet build via Grpc.Tools.

Author a type: pipeline node that emits many output frames for one input, compose pipeline nodes into a pipeline_mode flow, and stream the frames from the CLI and over HTTP as they are produced.

Attach `axiom dev --tunnel` so platform flows execute your local, hot-reloading code for a draft node — edit, save, invoke, no push or deploy — after a human arms the tunnel in the console.

Find a published package with axiom search and axiom info, pull its message types into your package with axiom import, and use them as node inputs and outputs.

Bind a Generic node's port to a real type in the console wizard or with axiom instance create — author nested message-typed fields, toggle repeated/optional, and preview a mapping's exact output before you save.

Store an API key on the console's Secrets page, read it from node code with ax.secrets.get, and know exactly what is and is not encrypted.

Create flow config profiles in the console, pick one in the Run dialog or via config_id, and see how resolved parameters reach nodes.

Declare a flow's own request and response messages in the canvas editor — add Flow input / Flow output boundary cards, document their fields, grow them from a wire, or import a published message.

Declare per-node fixtures in a flow.yaml mocks: section so a flow whose nodes cost money, need a key, or have side effects still runs end to end — and so failure paths can be exercised on demand.

Write tests/*.test.yaml cases that assert on a flow's real, mocked run — status, typed output, which nodes ran, and typed failures — with axiom flow test.

Add a human-in-the-loop pause to a node, resume it with a typed decision that becomes the node's input, and choose what happens when nobody answers in time.

Compile a flow.yaml with axiom flow compile, then promote the artifact to the public marketplace with axiom flow publish so other tenants can fork it or import it as a subflow.

Declare a read-only flow cacheable so browsers reuse the response instead of re-invoking it, declare a node cacheable for direct owner-credentialed callers, and understand exactly what that promise does and does not cover.

Start a debug session with breakpoints and pause/step controls, inspect each node's input and output — and the flow's own typed input and output — on the canvas, and replay any past execution on its detail page.

Open generated, interactive OpenAPI docs for any flow from the inspector's API section, send test requests from the browser, and fetch the raw openapi.json for codegen.

Bundle marketplace nodes and flows into a client — in Console → Client Builder or headlessly with `axiom client` — build it into a typed SDK in up to seven language targets, and call it with an API key from the environment (or, for the browser target, a constructor-injected token).

Mint, use, and revoke API keys in Console → API Keys, understand what a key can access, and read the Usage page's execution stats.

Install Axiom's Skills into Claude Code with axiom skills install so your agent knows the create→validate→push→publish authoring loop AND the search→inspect→source→invoke loop for using published nodes, then drives the axiom CLI through the shell.

Add Axiom's hosted MCP server in any MCP client — sign in with OAuth or paste an API key — and search the catalog, inspect schemas, read a node's source, invoke nodes and flows, and pin favorites as typed tools, without installing the CLI.

Tell Axiom what to build or fix, and request a package, node, or flow that doesn't exist yet — from the editor's feedback dialog, the axiom CLI (axiom feedback / axiom propose), or an MCP client. Every submission feeds the roadmap review.

The complete schema of the axiom.yaml package manifest: every field, its type, default, validation rule, and which CLI commands read or write it.

Complete reference for the ax parameter in Python nodes: structured logging with ax.log, secrets with ax.secrets, and flow reflection with ax.reflection.flow.

Every capability on axiom.Context — the Go form of AxiomContext: structured logging, secrets, execution identity, flow reflection, and flow mutation, with full signatures.

Complete reference for AxiomContext in TypeScript — logging, secrets, flow reflection, flow mutation, execution identifiers, and handler signatures.

Every invocation endpoint — flow invoke, SSE streaming, single-node calls, pre-warm — plus the Client Builder management API, Instance creation, adapter-mapping preview, with authentication, request and response fields, rate limits and daily quotas, and the structured error envelope.

Every place a CEL expression appears in Axiom — the compose-mapping formula bar, the edge-adapter cel() transform, a gate condition's CEL op, and a HITL node's interrupt_payload_template — the value/srcField bindings, the inputs.<edge>.<path> multi-source syntax, the built-in string functions, and Axiom's two custom functions toUpper/toLower.

Every user-facing Axiom error — flow run failures in the editor, edge transform errors, and HTTP API error responses — with what causes each one and how to fix it.

Canonical definitions for every Axiom term — the single authority for terminology used across the docs, the CLI, the canvas, and the API.

What's new in the v0.2.0 Axiom CLI: the new axiom client command group, breaking changes, and other changes since v0.1.1.