Recipes

A recipe is the executable definition of what an agent does — the logic the harness walks at runtime. You shape it in the dashboard by talking through what you want, see the result as a visual graph, and try the draft in a sandbox before promoting it to production.

Author by conversation

Open an agent's Recipe tab. The left pane is a build conversation — describe what the agent should do and Levain produces the recipe in response. Push back when the result drifts, ask for changes when the spec needs sharpening, treat it the way you'd treat a working session with a teammate. Each round produces a new draft you can try.

The right-hand panel keeps the current draft visible while you talk:

• Spec — the product spec Levain is working from.
• Graph — the nodes and edges the agent will walk at runtime.
• State — the data shape that flows through the graph.
• Nodes — the generated source and prompt files behind each node.

Click any node in the graph to highlight its neighbours. The graph is a visualisation of the current draft — edits happen through the conversation on the left. If a node calls an integration the agent isn't attached to, the node's server chip flags it — attach the integration or ask the conversation to drop the call.

The same conversation can also change the agent's settings — ask it to add a schedule, wire up a trigger, or attach an integration — instead of setting those up from the agent's other tabs. Confirm the change and it applies immediately; an inline card in the conversation records what changed.

Try it in the sandbox

The Sandbox tab is the agent's playground. It runs the draft against real inputs, with the same execution model as production but cheaper lifecycle: reset whenever you want a clean slate, iterate without publishing. Any files the agent produces along the way appear in the sandbox conversation as it works.

The sandbox uses the sandbox primitive under the hood, so what you see here is what you'll get in production. The only difference is scope: sandbox sessions are scratch space, production runs are durable.

Promote to production

A status row above the conversation tracks whether the current draft is publishable: Draft — not published yet, Draft — N open review comments, Draft — checks not passing yet, Draft — review incomplete (checks pass and no open comments, but the conversation hasn't been approved yet), or Draft — ready to publish. Publishing runs a checks-plus-review pass over the draft and, if both pass, promotes it — creating a new version and marking it active. Runs going through your agent immediately start hitting the new logic, with no client changes. Click Publish to run the checks-plus-review pass — if the row already reads ready it promotes immediately, otherwise the pass updates the status (or surfaces review comments) so you know what's blocking it. The Agents guide covers the version lifecycle in detail.

Calling another agent

A call_agent node lets one agent invoke a second agent as a step in its graph. You map fields from the caller's state into the callee's input, the platform runs the callee as an independent child run, and then folds the callee's public output fields back into the caller's state before the graph continues.

# @node {"function": "call_agent", "agent": "summarizer",
#        "input": {"document": "draft"}, "output": {"summary": "summary"}}

• agent — the slug of the target agent (must be in the same workspace and have an active version).
• input — maps callee input fields to caller state fields ({ callee_field: caller_state_field }). Keys are callee destinations; values are caller sources.
• output — maps caller state fields to callee output fields ({ caller_state_field: callee_output_field }). Keys are caller destinations; values are callee sources.

The calling agent holds its sandbox open while the callee runs, so the callee's token spend and wall-clock time count against the caller's run budget. Set your budgets accordingly. The platform prevents cycles and caps the call chain at three levels deep.

Describe the call in the recipe conversation ("call the summarizer agent, pass it the draft, and put the summary back in state") — the builder generates the node annotation for you.

After a real run

Production runs land under Usage → Agents. The run detail page shows status, the LLM requests the agent issued, and the cost breakdown; the conversation and any artifacts it produced are in the agent's Chats tab — together, everything you need to understand what happened on a specific run.

Next

• Build from Claude covers editing the same recipes from your own Claude session instead.
• The Harness primitive covers how the recipe runs once it leaves draft.
• The Sandboxes primitive covers the isolation guarantees the sandbox tab inherits.