# A Tour of Orchestrations

Walk the Orchestrations list, open one in the Builder, and see how nodes, ports and Roles fit together.

- Page: https://perceivo.ai/university/orch-02-tour-of-orchestrations
- JSON: https://perceivo.ai/registry/film/orch-02-tour-of-orchestrations.json
- Kind: film
- Revision: 2 (published 2026-10-18, produced 2026-10-15)
- Previous revision 1 (published 2026-10-07): https://perceivo.ai/registry/film/orch-02-tour-of-orchestrations/r1.json
- SDK version: none

## Validation

- SDK: not applicable (UI walkthrough; no component or orchestration is offered for download)
- Platform: not applicable (UI walkthrough; no component or orchestration is offered for download)

## Transcript

[0:00] Introduction to Orchestrations, Episode 2: A Tour of Orchestrations
[0:06] Welcome to our Introduction to Orchestrations series.
[0:10] This video introduces the web-based interface for building, running and evaluating orchestrations: automated pipelines designed to achieve complex, multi-step goals.
[0:22] Orchestrations are part of the Studio: a collection of tools you use to build AI solutions.
[0:29] Orchestrations let you combine components into intelligent workflows.
[0:35] Orchestrations you import or build are listed here.
[0:39] In the next episode we show you how to import one.
[0:42] For now, let's open one we have already built.
[0:47] Each orchestration has five tabs.
[0:49] The Builder, which you are looking at now, is where you develop and validate your orchestration.
[0:55] We'll come back here in a minute.
[0:58] You use the Runner to start runs and watch them live.
[1:02] Observe is where you explore execution history and results, including outcomes, metrics, logs and costs.
[1:11] Roles gives you fine-grained control over who can see, edit and run this orchestration.
[1:18] And Settings: connection details for the Perceivo API.
[1:22] Expand any call to see its address, the response it returns, and a ready-made cURL command.
[1:29] Under Configuration, Actor Resources sets the compute and memory allocated to this orchestration.
[1:36] And Versions is your version history, where you can reopen any earlier version.
[1:42] Back to the Builder.
[1:44] There are three main areas here: the palette on the left, the canvas in the middle, and the inspector on the right.
[1:52] The palette is your parts bin.
[1:54] At the top are the primitives, the building blocks: start and end, agents, tools, state machines, policies, review steps and adapters.
[2:05] Below them is the quick select.
[2:07] It lists the parts you use, most frequent first.
[2:11] Favorite one, and it is pinned to the top, so it is always within reach.
[2:17] The Gallery shows everything you can use.
[2:20] View all your components, or filter on just templates, orchestrations, or components.
[2:27] We cover nested orchestrations and templates in episode six.
[2:32] The canvas is where you construct orchestrations by linking nodes with edges.
[2:37] You drag parts onto the canvas, connect their ports, and configure them in the inspector.
[2:43] In this simple orchestration, execution flows one way, from start to finish.
[2:49] We call this path from start to end the main flow.
[2:52] All ports on the main flow are one-way.
[2:55] Other connections are two-way: they send a request and receive a response.
[3:02] In Perceivo, both the request and the response are typed, so a component can only connect to compatible components.
[3:09] Episode four is all about those connection rules.
[3:14] Now let's run it.
[3:15] The Start component has a special external input port.
[3:19] When you click Start Run, it reads that configuration and opens a dialog that prompts for inputs, based on the contract defined on the orchestration's Start component.
[3:29] That is how inputs reach your orchestration: artifacts, metadata, or both.
[3:35] Here we are not passing an artifact.
[3:38] We are providing a request data object that has a prompt, which is a string, and a maximum length, which is an integer.
[3:46] Start Run queues a job, sized to the compute and memory you set in Settings.
[3:51] The job ends as soon as the run completes.
[3:55] Run one-shot like this, you pay for compute only while the run's pod is allocated.
[4:01] It is a true on-demand pricing model.
[4:05] Your agent can also start the run with a post to the API, or with the Perceivo client SDK.
[4:11] Same result.
[4:13] Executing components light up while they are active.
[4:16] When each one completes, its latency and cost appear above the node on the canvas, and are tallied in the inspector on the right.
[4:26] Done in seconds.
[4:28] Latency and cost, logged for every component.
[4:37] Everything in this series is open source.
[4:40] You'll find this orchestration, and every example that follows, in the Perceivo SDK repository under examples.
[4:48] The best way to learn this platform is to build with it.
[4:53] Next time, we show you how to import and export orchestrations, so you can bring every example in this series into your own workspace.
[5:01] See you there.
