Mental model

functionalAI treats an AI capability as a function — f in Y = f(X). You define the mapping you want, prove it works, deploy it, and then call it behind one stable contract. Everything in the platform hangs off that idea.

The function

A function is the stable product identity: a slug (like doc_summarizer) plus metadata. It owns everything below it — versions, plans, experiments, deployments, and traces. The slug never changes; it’s what your callers invoke.

Versions and the contract

A version is an immutable snapshot of how the function works: the prompt (or agent) sections, the model binding, the tools, and the input/output JSON schemas. Those schemas are the function’s contract.

• Schemas live on the version, so the contract can evolve from one version to the next within the same slug — you don’t need a new function to change a field.
• At approval the version is frozen and compiled into an artifact, so what you evaluated is exactly what you deploy.

A new slug is reserved for a genuinely different capability, not for a routine change to prompt or schema.

Two gates

A version passes through two independent checks before it can serve traffic:

1. Design gate — contract must-haves, a hard accept/reject that runs at submit. A version that fails its own contract can’t be versioned. This is not an evaluation; it’s a sanity boundary.
2. Evaluation — quality. You author (or generate) a plan of checks and run it as an experiment. This is where you decide whether the version is good enough to ship. See the evaluation guide.

The core objects

Object	What it is
Function	Stable slug + metadata; owns everything below
Version	Immutable snapshot (prompt/agent + schemas) → compiled artifact
Dataset	Sample inputs X (± expected Y), scoped to a space
Check	One atomic measurement (a catalogue entry + config)
Plan	A named, editable collection of checks, scoped to a function
Experiment	Plan × Version × Dataset × models × repeats
Result / Comparison	An experiment’s output, and the cross-experiment view
Deployment	An approved version live behind /v1/run
Trace	A recorded execution — from the playground, an experiment, or production

Where things run

You build and evaluate against the management API (/api/*) using a personal access token, then deployed functions are invoked on the public runtime (/v1/run/{slug}) with a per-function invoke key. Which credential opens which door is covered in authentication.

Next

• Quickstart — the golden path, end to end, in ~5 minutes.
• Evaluation — how you prove a version is good enough.
• Deployment — taking an approved version live and watching it.