Documentation
Everything you need to build on Axiom: install the CLI, write a node in any language, publish a package, compose a type-safe flow in the canvas, and invoke it via API.
Using an AI coding agent? Point it at /llms.txt (index) or /llms-full.txt (full corpus); every page is also raw markdown at the same URL with .md appended.
Getting started
Install the Axiom CLI
Install the axiom CLI with Homebrew or the curl install script, authenticate with axiom login, and confirm your identity and tenant with axiom whoami.
Write your first node
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.
Run your first flow
Push your package with axiom push, import its nodes into the canvas editor, connect them into a flow, and run it from the editor.
Invoke a flow via API
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.
Concepts
Nodes, packages, and flows
Axiom's core object model — how messages, nodes, packages, flows, executions, and the entry and terminal nodes relate to each other.
The type system
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.
Execution model
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.
Sandboxing and tenancy
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.
Agent memory
How flows remember things across executions: sessions, episodic conversation history, consolidated semantic memories, and the axiom memory CLI.
Guides
Create a node in Python
Scaffold a Python package, define protobuf messages, implement a typed node function with AxiomContext, test it with pytest, and push it to Axiom.
Create a node in Go
Scaffold a Go node with the Axiom CLI, implement the handler against generated protobuf types, test it, and run it locally with hot reload.
Create a node in TypeScript
Scaffold, implement, test, and push a TypeScript node with the Axiom CLI, using google-protobuf message classes and AxiomContext.
Create a node in Rust
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.
Create a node in Java
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.
Create a node in C#
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.
Import message types from another package
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.
Manage secrets in a flow
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.
Set per-flow config values
Create flow config profiles in the console — node timeout and secret overrides — pick one in the Run dialog or via config_id, and see how resolved values reach nodes.
Publish a flow to the marketplace
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.
Debug a flow
Start a debug session with breakpoints and pause/step controls, inspect each node's input and output on the canvas, and replay any past execution on its detail page.
Use the interactive API docs
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.
Build a client SDK
Bundle marketplace nodes and flows into a client in Console → Client Builder, build it into a typed SDK in up to six languages, and call it with an API key from the environment.
Create and manage API keys
Mint, use, and revoke API keys in Console → API Keys, understand what a key can access, and read the Usage page's execution stats.
Inspect agent memory
List, inspect, search, close, and delete agent memory sessions for your flows with the axiom memory CLI commands.
Author packages and flows with Claude Code
Install Axiom's authoring Skills into Claude Code with axiom skills install so your agent knows the create→validate→push→publish loop and drives the axiom CLI through the shell.
Reference
CLI commands
38 pages, generated from the CLI itself.
axiom.yaml manifest reference
The complete schema of the axiom.yaml package manifest: every field, its type, default, validation rule, and which CLI commands read or write it.
Python SDK reference
Complete reference for the ax parameter in Python nodes: structured logging with ax.log, secrets with ax.secrets, agent memory with ax.agent.memory, and flow reflection with ax.reflection.flow.
Go SDK reference
Every capability on axiom.Context — the Go form of AxiomContext: structured logging, secrets, agent memory, execution identity, flow reflection, and flow mutation, with full signatures.
TypeScript SDK reference
Complete reference for AxiomContext in TypeScript — logging, secrets, agent memory, flow reflection, flow mutation, execution identifiers, and handler signatures.
HTTP API reference
Every invocation endpoint — flow invoke, SSE streaming, single-node calls — with authentication, request and response fields, rate limits and daily quotas, and the structured error envelope.
Error catalog
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.
Glossary
Canonical definitions for every Axiom term — the single authority for terminology used across the docs, the CLI, the canvas, and the API.