Agent Studio

Studio is where agents are built. It's a visual canvas — drop nodes, write prompts, attach tools, run a test, deploy. The canvas is the source of truth: there's nothing about an agent that lives outside it.

Production and Dev views

Studio has two view modes for each agent:

The backend calls the Dev bucket TEST because it shares the same execution-origin axis used by traces, budgets, and cost reports. The UI labels it Dev so it reads as the builder's iteration view rather than a test dataset or test case.

Viewers stay in Production. Editors can switch modes from the segmented toggle in the Studio header.

The canvas

The big area in the middle is your workflow.

• Pan — drag the background.
• Zoom — scroll, or use the zoom controls bottom-right.
• Select — click a node to open its configuration panel.
• Multi-select — drag a marquee or shift-click.
• Auto-layout — clean up node positions with the layout button (or ask Copilot to do it).

Connections between nodes are derived, not drawn — Fruxon reads the placeholders in your prompts and tool configs and wires the dataflow accordingly. You don't have to drag wires.

Nodes

Every workflow has the same spine: an Entry Point, one or more Agent Steps, and an Exit Point.

Entry Point

The starting node. Defines the typed inputs the agent accepts.

• Name — how you reference it in placeholders ({{param.<name>}})
• Type — STRING, INTEGER, FLOAT, BOOLEAN, OPTION, JSON, STRING_ARRAY, DICTIONARY, and others
• Required — whether the agent fails fast if missing
• Default — fallback value when not provided
• Description — surfaces in the API schema and to sub-agent callers

Keep the entry point lean. A focused agent has 1–4 well-named parameters.

Agent Step

Where the LLM work happens.

Exit Point

Shapes the response sent back to the caller. Map fields from any step output, input, or asset:

result   ← {{step.briefing}}
summary  ← {{step.research}}

The exit's shape is what API callers and sub-agent parents see.

Tool steps and sub-agents

Tools and sub-agents aren't separate node shapes on the canvas — they're attached to Agent Steps:

• Sub-agents — invoke another agent from a step (Sub-agents).
• Tools — APIs, predefined tools, code tools, MCP, code execution, and more, attached to a step (Tools & Skills).
• Human approval — configure on any tool to pause execution until a human approves the call.

Connecting a tool to credentials

Every tool that calls an external service needs an integration connection (a tenant-level config carrying the credential, sandbox routing, and OAuth scopes). You wire credentials with a connection picker, not by pasting auth into the step:

1. Configure once at the tenant level. In Integrations, set up one or more configs for each integration. Each is a card with its own name, credentials, granted OAuth scopes, and sandboxMode strategy. The same integration can have multiple configs (e.g., "Salesforce — Prod", "Salesforce — Sandbox").
2. Pick the connection per agent. In the agent's Integrations panel, pick which config the agent uses for each integration. This is the per-agent binding.
3. Override per-tool when needed. A specific tool on a specific step can override the agent-wide binding — useful when one read-only step should use a sandbox config while the rest of the agent uses prod.
4. Pin the connection on a step to lock in its chosen config — credentials and granted scopes — so the step isn't silently rebound when the agent-wide default credentials change.

The picker shows each config as a card with its sandbox status and OAuth scope summary, so it's clear which environment a step is actually talking to before you save.

Placeholders

Placeholders are how data moves between nodes. Anywhere a string is accepted, you can reference:

{{param.<name>}}    # entry-point parameters
{{step.<name>}}     # the output of a previous step
{{secret.<NAME>}}   # organization secrets
<file:…>            # an attached asset (inserted from the asset picker)

You insert these from the prompt editor's placeholder menu rather than hand-typing them, so names always resolve to a real node. Placeholders that don't resolve render as empty strings — a common silent bug — so always check the trace if a step is producing weird output.

Configuration panel

The right-side panel shows whatever's selected. Different node types expose different sections:

• Agent Network — triggers, participants, and channels delivering this agent (Slack, Teams, Telegram, etc.)
• Integrations — connection picker. Pick which tenant-level config each integration uses for this agent. Per-tool overrides are configured on the step. See the picker pattern above.
• AI Providers — the tenant LLM configs (LLM Providers) wired into this agent. Per-step picking happens on the step itself.
• Knowledge Base — assets and data sources attached for retrieval (Assets). Per-step picking happens on the step.
• Access Requests — approval queue for unknown or unbound senders

Saving & revisions

Every save creates a revision — an immutable snapshot. Production traffic continues to hit the deployed revision; saving doesn't change what's live.

Testing from Studio

The Test panel runs the current canvas state (saved or unsaved) with sample inputs and shows the full trace. See Testing for the full guide.

Copilot

The Copilot drawer at the bottom of the canvas is an AI assistant that can build and modify your workflow from natural-language prompts — add steps, attach tools, change prompts, import flows from other platforms. See Copilot.

Multiple workflows per agent

An agent can have multiple workflows — for example, one for normal handling and one for error fallback or human-handoff. Switch between them from the workflow selector at the top of the canvas.

Next steps

• Creating Agents — full walkthrough of a new agent
• Tools & Skills — what agents can do
• AI Providers — wiring up the LLM
• Copilot — build with natural language
• Testing — interactive validation