Getting started

Welcome to Triform. Pick the path that fits how you want to build:

Build visually (no code)

For builders who want to assemble an application on the canvas — add elements, configure them in panels, wire them together, and ship.

1. Sign up and land in a circle. A circle is your unit of tenancy: an identity, an isolated database schema, a git repository, and a wallet, all at once. Everything you build lives inside exactly one circle, and data never leaks between circles.
2. Add your first element. Open the canvas and place an element — a python function, a document store, a view, an app. Elements sit flat inside the circle; you don’t need a folder or wrapper to group related ones, just create them side by side.
3. Configure it in its panel. Selecting an element opens its properties, where you fill in its spec — the code for an action, the schema for a data element, the layout for a view. Each element validates against its own schema as you go.
4. Wire two elements together. Composition is how elements stop standing alone: a wire connects one element’s output to another’s input, an app references the elements it deploys, an automation routes data between steps. Connect a source to a consumer and data flows.
5. Preview, then ship. Invoke an operation to see it run — every run is tracked with its inputs, status, output, and logs (see runs) — and publish the app when it behaves.

The element’s own docs page tells you what each one is for and when to reach for something else, so you can keep the loop tight: add, configure, wire, run, repeat.

Build with the API, CLI, or agents

For developers calling Triform over HTTP, the triton CLI, or MCP, and for agent integrators. The platform exposes one consistent API shape for every element type, so a single set of moves covers everything.

1. Get credentials. Triform accepts bearer tokens for programmatic clients and agents, and cookie sessions for the browser UI (see auth). From the CLI, triton auth login does an interactive browser login, or triton auth set-api-key uses a bearer token directly; triton auth status shows who you’re authenticated as. The MCP server reuses the same resolved credentials.

2. Discover an element and its operations. Every element lives at a flat URL, /api/{circle}/{slug}, with operations under /api/{circle}/{slug}/ops/{operation}. You don’t need an external endpoint map: responses are self-documenting. GET an element and read _actions for the callable operations (each with method, URL, and input schema) and _lifecycle for the valid-vs-blocked operations in its current state. To browse, use triton tools (or list over MCP), or POST /api/search to find elements and POST /api/search/docs for help.

3. Invoke it — HTTP, CLI, or MCP, your choice. The same operation is callable three ways:

   # HTTP
   curl -s -X POST https://triform.dev/api/acme/my-function/ops/invoke \
     -H "Authorization: Bearer $TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"input": {"name": "Ada"}}'
   

   # CLI — uniform across every element
   triton <tool> <action> --field value
   triton <tool> --input '{"field":"value"}'
   

   Over MCP, the same tools are exposed to MCP-capable agents (Claude Code and any MCP client). The tool catalog the CLI scripts, the MCP agent sees, and the HTTP API serves are the same surface — a workflow you script one way is callable verbatim the others. Bootstrapping a working set of elements at once? Batch create them in a single request.

4. Handle errors and lifecycle. Before submitting, check _lifecycle for blockers — an operation can be invalid in the element’s current state, with the reason given. Read the operation’s declared input schema from _actions rather than hard-coding a request shape, and continue from the next response.

5. Stream results. Operations don’t just return — the platform pushes live events as a run progresses (started, progressed, completed, failed). Subscribe to the event stream to watch a run in real time instead of polling, then react to terminal states as they arrive.

Go deeper in the reference clusters: the HTTP API, the CLI, and the MCP server.

First, the core ideas

New to the platform? Two minutes on the core concepts pays off:

• Tenancy: the airtight circle — where everything lives
• Elements — what you build with
• Composition — how elements connect
• Runs — how operations execute