| Layer | What it stores | What you can change | What it affects |
|---|---|---|---|
| Template version | The linear step recipe: launch inputs, prompts, gates, scenario calls, and runtime requirements | Create a new private version by authoring or editing a copy. Existing versions are immutable. | What future installations of that version will do |
| Installation | A saved copy of one template version in an organization or workspace scope | Display name, runtime setup, default launch inputs, enabled state, toolbar visibility, and uninstall | Whether the scenario can run and how future runs resolve inputs and resources |
| Run | A frozen execution snapshot created when the scenario starts | Continue, retry, resume, or cancel from the workspace timeline | Only that active or historical run |
Running scenarios keep snapshots of the template version, compiled workflow,
runtime mappings, runtime presets, and launch inputs that were used at start.
Later edits to templates or installations affect future runs, not runs that
already exist.
Who Can Manage Scenarios
Scenario management uses the same organization-admin boundary as workspace runtime presets.| Role | Can view scenario settings | Can install, configure, or author |
|---|---|---|
| Admin | Yes | Yes |
| Member | Yes, read-only where the UI allows it | No |
| Read-only | Yes, read-only where the UI allows it | No |
| Subtab | Purpose | What belongs here |
|---|---|---|
| My scenarios | Configure scenarios that are already installed | Scenario detail, read-only flow preview, runtime setup, launch defaults, publish checklist, toolbar visibility, readiness check, and uninstall |
| Templates & Builder | Browse, install, and author template versions | Template library, version preview, install, edit copy, visual linear flow builder, and advanced JSON import |
The Most Important Boundary
Flow builder v1 is intentionally linear. Every scenario is a single ordered chain:| Supported in v1 | Not supported in v1 |
|---|---|
| Linear sequence of steps | DAG/canvas graphs |
| Agent prompt steps | Branches and routers |
| Human gate steps | Conditions |
| Scenario call steps | Loops |
| Runtime preset mappings | Code steps |
| Private organization versions | Marketplace publishing |
Quick Start: Install and Configure a Scenario
Open Templates & Builder
Open Settings → Scenarios → Templates & Builder. Select the organization
and host that should provide scenario templates.
Choose a template
Pick a template from Template library. The Versions and flow preview
panel shows the template version, checksum, and a visual preview of the linear
flow.
Install the version
Click Install. Jaidu creates an installation that is disabled and hidden
from the chat toolbar by default.
Configure the installed copy
Switch to My scenarios, open the installed scenario, then use
Configure launch to rename the installed copy, map runtime requirements to
organization runtime presets, and add launch defaults.
What You Can Influence
The table below is the shortest way to understand what each control changes.| Surface | Control | You influence | You do not directly influence |
|---|---|---|---|
| Templates & Builder | Template selection | Which template version can be installed or edited as a copy | Runtime preset availability on the host |
| Templates & Builder | Edit copy | The draft for a new private version | The source template/version; it remains unchanged |
| Templates & Builder | Launch inputs | Which fields a run can receive before prompts render | The actual values used by an already-started run |
| Templates & Builder | Step order | The linear order in which steps execute | Branching, fan-out, fan-in, or custom edges |
| Templates & Builder | Agent prompt | Prompt text and optional isolated runtime requirement | Whether the mapped runtime preset actually contains required resources |
| Templates & Builder | Human gate | The review message shown before continuing | Automatic approval; the run waits for a user action |
| Templates & Builder | Scenario call | Which nested scenario version is called and which launch inputs are passed | Arbitrary dataflow between previous step outputs |
| My scenarios | Name in toolbar | The display name for this installed copy | The source template name |
| My scenarios | Runtime setup | Which organization runtime preset satisfies each requirement | The contents of a runtime preset; edit those in Runtime presets |
| My scenarios | Launch defaults | Fallback input values for future runs | Values already frozen into a run snapshot |
| My scenarios | Allow new runs | Whether this installation may run | Whether it appears in the toolbar; that also needs toolbar + readiness |
| My scenarios | Show in chat toolbar | Whether a runnable enabled scenario appears in workspace chat | Launch while backend preflight is blocked |
| Workspace chat | Start scenario | Creates a run snapshot from the current installation and chat context | The saved installation configuration |
| Workspace chat | Continue/retry/resume | Progresses or repairs the active run | The template version used by that run |
Templates & Builder
Use Templates & Builder for template work. Template work is about what a scenario does. It is separate from installation work, which is about whether a saved scenario can run in your organization or workspace.Template Library
The library shows templates returned by the selected host and organization. First-party templates are seeded by the host. A template can have multiple versions.| Field or action | Meaning |
|---|---|
| Template card | Selects a template so you can inspect its versions |
| Version status | Only active versions are installable or editable as a copy |
| Checksum | Identifies the immutable manifest content for that version |
| Visual preview | Shows launch inputs, the linear step chain, runtime requirements, and step details |
| Install | Creates a disabled installation for that version |
| Edit copy | Forks that version into the private visual editor |
Edit Installed Scenarios Safely
Use My scenarios → Edit flow when you want to change a downloaded or installed scenario. The action opens an editable copy in Templates & Builder. Saving the result creates a new private immutable version. It does not mutate the source installation, source version, or active runs. When the source is an installed scenario, the editor can offer these save options:| Save option | Result |
|---|---|
| Save private version | Saves only a new private template version |
| Save & install as new disabled scenario | Saves the private version and creates a new disabled, toolbar-hidden installation |
| Copy runtime setup and launch defaults from source installation | Copies configuration onto the new installed copy, then relies on backend readiness to verify it |
| Replace source installed scenario after save | Saves and installs the new private version, copies the source configuration, then removes the old installed copy from future use |
Replacing an installed scenario still preserves existing run snapshots. The
replacement starts disabled and hidden from chat until readiness passes.
Flow Board Builder
The builder is the main no-JSON path for building organization-private linear templates. It looks like a Zapier/Activepieces-style board, but it still writes a strict v1 linear manifest. Start and Done are fixed boundary nodes; only the step cards between them can be inserted, reordered, or removed.| Editor area | What you set | Behaviour |
|---|---|---|
| Top builder bar | Scenario name, description, source-copy status, and save action | Edits template-draft metadata only; installation configuration stays in My scenarios |
| Flow board | Start → step cards → Done | Shows the whole linear sequence on a canvas-like surface |
| Plus connectors | Insert Agent prompt, Human gate, or Scenario call at an exact position | The new card is inserted into the sequence; no manual edges are created |
| Step cards | Select, drag, move up/down, or remove steps | The saved manifest regenerates strict previous-step dependencies from card order |
| Start inspector | Launch input key, label, and required marker | Prompts and scenario calls can read these fields |
| Selected step inspector | Edits the selected step only | Changes update the board card and generated manifest |
| Variable picker | Inserts {{ input.<key> }} into agent prompts | Only launch inputs are exposed; previous-step output mapping is not exposed in v1 |
| Done inspector | Read-only summary | Confirms step/input/runtime counts and that v1 has no branches or custom edges |
| Runtime mode | Workspace default or isolated preset requirement | Controls whether an agent prompt needs a runtime mapping after installation |
| Input bindings | Parent launch input to nested scenario input | Passes launch inputs into scenario-call steps without JSON |
| Save behaviour | Save private version, install after save, copy source configuration, or replace source installation | Controls what happens after the immutable version is created |
| Advanced template identity, schema, and runtime resources | Template id, version, input schema JSON, required skills, and MCP servers | Developer/admin escape hatch for technical details |
| Generated manifest preview | Collapsed technical view | For inspection only; not the main authoring path |
Launch Inputs
Launch inputs define the fields a scenario can receive at start time. The visual editor supports the common case: string fields with a key, label, and required flag. Prompts can reference launch inputs with template placeholders, for example:| Input setting | What it changes |
|---|---|
| Field key | The name used by prompt placeholders and scenario-call bindings |
| Label | The human-readable name in the editor |
| Required | Indicates that the input should be provided before a reliable run |
| Input schema JSON | Optional advanced escape hatch for custom cases |
Step Types
A v1 scenario can contain only these step types.| Step type | What it does | User-controlled fields | Runtime effect |
|---|---|---|---|
| Agent prompt | Sends a prompt to Codex as part of the scenario | Name, prompt template, runtime mode, and advanced step id/runtime requirement key | Uses workspace default runtime unless an isolated preset requirement is set |
| Human gate | Pauses the workflow for human review before continuing | Name, review message, and advanced step id | The run waits in the workspace timeline until a user continues or retries |
| Scenario call | Calls another scenario version as a nested workflow | Name, target scenario id/version, input bindings, and advanced step id | The called scenario expands into the run preview/timeline using the selected version |
Agent Prompt Runtime Requirements
An agent prompt step can either use the workspace default runtime or require an isolated runtime preset.| Runtime mode | Result |
|---|---|
| Workspace default | The step uses the workspace default runtime path and does not need an installation runtime mapping |
| Requires isolated preset | The step stores a runtime requirement key. Installed configuration must map this key to an organization runtime preset |
| Advanced field | Meaning |
|---|---|
| Required skill canonical names | Skills the mapped preset must contain |
| Required MCP canonical names | MCP servers the mapped preset must contain |
Scenario Call Input Bindings
A scenario call passes launch inputs from the current scenario into the nested scenario.| Binding field | Meaning |
|---|---|
| Nested scenario input | The input key expected by the called scenario |
| Use launch input | The current scenario input to pass into that nested input |
| Advanced scenario call inputs | JSON escape hatch for literal or imported custom bindings |
| Nested scenario input | Use launch input | Effect |
|---|---|---|
objective | objective | The child scenario receives the parent objective |
implementation_prompt | implementation_prompt | The child scenario receives the parent implementation prompt |
My Scenarios
Use My scenarios for configuration of scenarios that already exist in your organization or workspace. Installed configuration answers: Can this scenario run here, and with which resources/defaults?Installed Scenario Detail
Each installed scenario opens into a detail panel with five views.| View | Purpose |
|---|---|
| Overview | Shows the scenario layer summary, runtime/default counts, publish state, and readiness checklist |
| Flow | Shows a read-only backend preview of the installed copy, including nested calls and runtime nodes |
| Configure launch | Edits the installed copy name, runtime setup, launch defaults, and backend preview |
| Publish | Controls Allow new runs, Show in chat toolbar, readiness refresh, and uninstall |
| Versions | Shows the immutable template version, catalog item, installation id, scope, and safe edit path |
Scenario Detail Controls
| Control | What it does | When it is available |
|---|---|---|
| Allow new runs | Allows the installation to be considered runnable | Only after backend preflight is OK, or when disabling an already-enabled installation |
| Show in chat toolbar | Requests chat-toolbar visibility for the scenario | Requires allowed runs, backend preflight OK, and runnable state |
| Open details | Opens the scenario detail panel | Any visible installation |
| Configure launch | Opens runtime setup, launch defaults, and backend preview | Admin only |
| Edit flow | Opens a safe editable copy in Templates & Builder | Admin only |
| Refresh readiness check | Re-runs backend compatibility checks | Any visible installation |
| Uninstall | Removes this installation from future use | Admin only |
Runtime Setup
Runtime setup connects template requirements to organization runtime presets. A mapping does not create skills or MCP servers. It selects a preset that should already contain the resources required by the template.| Requirement state | What happens |
|---|---|
| No preset mapped | Preflight reports missing_runtime_mapping and the scenario cannot be enabled for launch |
| Preset was deleted or is unavailable | Preflight reports unknown_preset |
| Preset belongs to another organization | Preflight reports wrong_preset_organization |
| Required skill missing | Preflight reports missing_required_skill |
| Required MCP server missing | Preflight reports missing_required_mcp |
| Exactly-one skill policy is not satisfied | Preflight reports exactly_one_policy_violation |
| Isolated preset has extra resources | Preflight reports extra_resource_for_isolated_preset |
| Nested scenario cannot expand | Preflight reports scenario_call_expansion_failure |
Default Launch Inputs
Launch defaults are saved on the installation. They provide fallback values for future runs.| Behaviour | Result |
|---|---|
| A default input key exists and launch provides no value | The default value is used |
| Launch provides a value for the same key | The launch value overrides the default |
| You edit defaults after a run starts | Only future runs see the new default |
| You need complex values | Use Advanced default inputs JSON |
Backend Preview and Readiness
The configuration panel shows a backend preview because the server is the source of truth for runtime compatibility.| Preview area | What to look for |
|---|---|
| Runtime flow | Expanded step order, nested scenario calls, mapped/unmapped runtime nodes |
| Preflight errors | Blockers that prevent enabling or launching |
| Preflight warnings | Issues to inspect before launch |
| Runtime requirements | Which keys must be mapped to presets |
| Mapped preset ids | Which preset will be snapshotted for runtime-isolated steps |
Saving runtime setup may temporarily disable the installation and hide it from
the toolbar until backend preflight validates the new configuration.
Toolbar Visibility Rules
An installed scenario appears in the workspace chat toolbar only when all required conditions are satisfied.| Condition | If false |
|---|---|
| Installation belongs to the current organization/workspace scope | Hidden from that workspace |
| Installation allows new runs | Hidden with reason: disabled in scenario settings |
| Toolbar visibility is enabled | Hidden with reason: hidden from chat toolbar |
| Backend preflight is OK | Hidden or disabled with the first preflight blocker |
| Backend preflight is runnable | Hidden or launch-blocked until runnable |
| Current Codex attempt is idle | The toolbar action is disabled with a wait message while an agent run is active |
What Changes Affect Future Runs
| Change | Affects existing active runs | Affects future runs | Notes |
|---|---|---|---|
| Install a template | No | Yes, after configuration and enablement | Installation starts disabled and toolbar-hidden |
| Edit runtime setup | No | Yes | Backend preflight decides whether enable/toolbar can remain on |
| Edit default launch inputs | No | Yes | Launch-time values override defaults |
| Allow or block new runs | No | Yes | Disabled installations cannot start new runs |
| Toggle toolbar | No | Yes | Controls visibility, not installation existence |
| Edit copy and save private version | No | Only if installed and configured | Source version is unchanged |
| Replace source installed scenario after save | No | Yes, through the new installed copy | The old installed copy is removed from future use |
| Uninstall | No direct mutation of run snapshots | Prevents future use of that installation | Existing run history keeps its snapshots |
| Edit runtime preset contents | No | Yes, after preflight sees the new preset resources | Can make mappings valid or invalid |
Troubleshooting
The scenario does not appear in workspace chat
The scenario does not appear in workspace chat
Check Settings → Scenarios → My scenarios. The installation must allow new
runs, toolbar visibility must be on, and backend preflight must be OK and
runnable. Also confirm that the installation is not scoped to a different
workspace.
The Toolbar checkbox is disabled
The Toolbar checkbox is disabled
Toolbar visibility requires allowed runs and runnable backend preflight. Open
Configure launch, fix runtime setup or default inputs if needed, refresh
readiness, then try again from Publish.
Preflight says a runtime mapping is missing
Preflight says a runtime mapping is missing
The template has an agent prompt with an isolated runtime requirement key. Map
that key to an organization runtime preset in My scenarios → Configure
launch.
Preflight says a required skill or MCP server is missing
Preflight says a required skill or MCP server is missing
The mapped runtime preset does not contain the canonical resource required by
the template. Edit the runtime preset or choose a different preset.
My edited flow did not change the installed scenario
My edited flow did not change the installed scenario
Flow editing creates a new private version. Install or replace the installed
copy from the save options, then configure and publish the resulting
installation. The source version remains immutable.
A prompt placeholder renders empty or wrong
A prompt placeholder renders empty or wrong
Confirm that the launch input key exists, the default launch input has a value,
and the prompt uses the same key, such as
{{ input.objective }}.Advanced JSON import is rejected
Advanced JSON import is rejected
The import path is still constrained to v1 linear manifests. JSON with DAG,
fan-out, fan-in, unsupported step types, invalid dependencies, or invalid
runtime requirements is rejected.