Agent development

Agent development in Studio covers creating agents, configuring their behavior through the visual editor or ABL code, managing versions, testing agents in an interactive chat environment, and using th

Agent development

Agent development in Studio covers creating agents, configuring their behavior through the visual editor or ABL code, managing versions, testing agents in an interactive chat environment, and using the AI Architect to accelerate your workflow.

The agent editor

Creating agents

To create a new agent:

1. Navigate to your project and select Agents from the sidebar.
2. Click the Create Agent button.
3. Fill in the creation form:
   • Name — must start with a letter and contain only letters, numbers, and underscores. Maximum 100 characters.
   • Execution mode — choose whether to start with a blank agent (LLM-driven by default) or add a FLOW section for structured step execution.
   • Description (optional) — a brief summary of what this agent does.

Pattern-aware agent creation

If your project uses an orchestration pattern (Concierge, Router, or Tiered), Studio automatically assigns a role to the new agent based on the pattern and the number of existing agents:

• Concierge pattern: First agent gets the Concierge role; subsequent agents are Specialists.
• Router pattern: First agent gets the Triage role; subsequent agents are Specialists.
• Tiered pattern: First agent gets the Triage role; subsequent agents choose between L1 and L2 tiers.
• Custom pattern: No roles are enforced.

A context panel in the creation dialog explains how the new agent fits into the orchestration pattern, including which coordination blocks (such as ESCALATE rules) will be pre-configured.

Agent with or without a flow

Every agent reasons by default. You can optionally add a FLOW section with structured steps for deterministic execution.

Feature	Agent (default)	Agent with FLOW section
Decision making	LLM decides next action	Steps define explicit transitions
Best for	Open-ended conversations, complex reasoning	Structured workflows, deterministic processes
Editor UI	Full-page configuration panel	Visual flow canvas with step nodes
Step control	LLM determines when to use tools	Each step explicitly defines actions and transitions

Agent list

The Agents page displays all agents in your project as a list. Each agent entry shows:

• Agent name
• Flow indicator (whether the agent has a FLOW section)
• Deployment status
• Last modified timestamp

Click an agent to open it in the agent editor.

Editor layout

The editor contains:

• Header — agent name, save status, and action buttons.
• Navigation sidebar — organized into groups with clickable sections.
• Section content area — the active section’s configuration form.
• AI Architect button — opens the AI Architect panel with context about the current section.

Editor sections

The agent editor organizes configuration into 17 sections grouped by function:

Identity & Core

Section	Description
Identity	Agent name, persona, goal, and description
Execution	LLM model selection, temperature, token limits, timeout settings, thinking/reasoning configuration, fallback model
Tools	Tools available to this agent with parameter mapping

Data & Logic

Section	Description
Gather	Data collection fields the agent should capture from users
Memory	Session variables, persistent state, remember/recall triggers
Flow	Flow definition with structured steps, transitions, and entry point (optional)

Safety & Behavior

Section	Description
Constraints	Rules and restrictions the agent must follow
Guardrails	Content safety policies applied to agent inputs/outputs
Behavior	Conditional behavior profiles that activate based on context

Coordination

Section	Description
Handoffs	Rules for transferring to other agents
Delegates	Sub-agent delegation configuration
Escalation	Triggers and routing for human escalation

Lifecycle

Section	Description
On Start	Actions when the agent session begins (greeting, tool calls, variable initialization)
Error Handling	Error recovery strategies and fallback behaviors
Completion	Conditions that determine when the agent’s task is done

Advanced

Section	Description
Templates	Output templates with format variants (default, markdown, HTML, voice)
Definition	Raw ABL code editor with syntax highlighting

Tip: Each section editor includes an AI Architect button that opens the assistant panel with context about the current section. Use it to get help writing personas, designing flows, or troubleshooting configurations.

Visual flow editor

For agents with a FLOW section, the visual flow editor provides a canvas-based interface for designing conversation flows.

Canvas

The flow canvas displays steps as connected nodes. You can:

• Drag nodes to rearrange the flow layout.
• Connect steps by drawing edges between nodes to define transitions.
• Select nodes to view and edit step properties in the sidebar panel.
• Zoom and pan to navigate complex flows.

Flow steps

Each step in a flow is a node on the canvas. Steps define:

• Step name — unique identifier for the step.
• Reasoning flag — whether the LLM can reason at this step.
• Response — what the agent says at this step.
• Transition (THEN) — which step to go to next, or COMPLETE to end.

Step palette

The step palette provides a library of step types you can drag onto the canvas:

• Standard response steps
• Data collection steps
• Conditional branching steps
• Completion steps

Property panel

When you select a step on the canvas, the Flow Step Property Panel opens on the right side showing editable properties for that step, including its name, response content, reasoning settings, and transition targets.

Configuration sidebar (agents with flow)

Agents with a FLOW section also have access to a configuration sidebar that mirrors the section structure of agents without a flow, allowing you to configure identity, tools, constraints, and other sections alongside the flow.

Toolbar

The flow toolbar provides actions for:

• Adding new steps
• Saving the flow
• Toggling between visual and code views
• Viewing validation errors

View modes

The agent editor supports switching between:

• Visual mode — the section-based configuration UI (agents without a flow) or flow canvas (agents with a FLOW section).
• Code mode — a full ABL code editor with syntax highlighting, powered by Monaco editor, where you can edit the raw agent definition directly.

Changes made in one mode are synchronized to the other.

Agent versioning

Studio tracks agent versions to provide history and rollback capabilities.

Version history

Navigate to an agent’s Versions tab to see a table of all saved versions. Each version shows:

• Version number
• Status badge (draft, testing, staged, active, deprecated)
• Creation timestamp
• Author

Comparing versions

Click the diff icon on any version to open a side-by-side comparison showing what changed between that version and the current working copy or between any two versions. The diff viewer highlights additions, removals, and modifications to the ABL code. Tool snapshot changes are also shown.

Promoting versions

To promote a version to a new status:

1. Click the promote button next to the version.
2. In the promotion dialog, select the target status (e.g., draft to testing, testing to staged, staged to active).
3. Confirm the promotion.

Promoting a version updates its status and can trigger deployment pipeline actions depending on your project configuration.

Agent testing

Studio provides an integrated chat interface for testing agents in real time.

Chat interface

To test an agent:

1. Open the agent from the Agents list.
2. Switch to the Chat tab.
3. Type messages in the input field to interact with the agent.

The chat interface sends your messages to the runtime and displays the agent’s responses in real time.

Session management

Each test conversation creates a session. You can:

• Start a new session to begin a fresh conversation.
• View session history from the Sessions page.
• Copy session ID for reference or debugging.

Debug panel

The chat view includes a split-pane debug panel that provides real-time visibility into agent execution:

• Trace events — every action the agent takes (LLM calls, tool invocations, state changes) is logged as a trace event.
• Timing information — latency for each operation.
• Variable state — current values of session variables.

Tip: Use the debug panel to understand why an agent made a particular decision. Trace events show the full chain of reasoning, tool calls, and responses.

Testing from the overview

The project overview page provides a “Test Agents” quick action card that opens the chat interface for the project’s primary agent (supervisor agent if one exists, or the first agent in the project).

AI Architect

AI Architect is a context-aware AI assistant built into Studio that helps you design, build, and improve agents. It appears as a collapsible side panel accessible from any page within a project workspace.

Opening the Architect panel

There are several ways to access AI Architect:

• Click the Architect icon in the header bar (available when inside a project).
• Click the AI Architect button within any agent editor section.
• Click the floating Architect button in the bottom-right corner when the panel has been minimized.

The panel opens as a 480px overlay on the right side of the screen. It does not push the main content area; it overlays on top.

Panel controls

The panel header provides three controls:

• Maximize/Restore — expand the panel to 50% of the viewport width for more room, or restore to default width.
• Minimize — collapse the panel to a small floating button in the bottom-right corner. Click the button to restore.
• Close — dismiss the panel entirely.

Context awareness

AI Architect automatically adapts to your current context:

Page-level context — the panel detects which page you are on and adjusts its quick actions accordingly:

• Agents page — offers actions like “Explain the current agent ABL code,” “Add error handling,” “Suggest improvements,” and “Generate test scenarios.”
• Sessions page — offers “Analyze the current session” and “Suggest a fix for issues.”
• Overview page — offers “Summarize project health” and “Identify bottlenecks.”

Agent-level context — when you are editing a specific agent, the panel displays a context indicator showing the agent’s name. The Architect has access to the agent’s current ABL definition and can provide targeted advice.

Section-level context — when you are editing a specific section (e.g., Identity, Tools, Constraints) in the agent editor, the panel shows the section name and provides section-specific suggestions tailored to that configuration area.

Conversation interface

The Architect panel contains a chat-style conversation interface:

• Message input — type questions or instructions at the bottom of the panel.
• Message history — previous messages in the conversation are displayed in chronological order.
• Suggestion chips — quick-action buttons that send pre-configured prompts with a single click.

Suggestion chips appear above the input field based on context:

Context	Available suggestions
Agent editor	Explain code, Add error handling, Suggest improvements, Generate tests
Session viewer	Analyze session, Suggest fix
Project overview	Summarize health, Identify bottlenecks

Proposals and code changes

When the Architect proposes changes to agent ABL code, it presents them as a structured response:

• Diff view — changes are shown as a before/after comparison so you can review exactly what will be modified.
• Accept — apply the proposed changes to the agent’s working copy.
• Reject — discard the proposed changes and keep the current code.
• Refine — provide additional feedback to adjust the proposal before accepting.

Tip: Review diffs carefully before accepting. The Architect modifies the agent’s working copy, so you can always undo changes by reverting to a saved version.

Workflow states

When the Architect processes a request, it goes through a structured workflow:

1. Contextualizing — gathering relevant context from the current page, agent, and project.
2. Responding — generating a response based on the context and your request.
3. Executing — when the Architect modifies agent code, it applies changes and shows the results.

A status bar below the panel header shows the current workflow state with a spinner during processing.

AI-guided project creation wizard

AI Architect also powers the project creation wizard (described in Studio overview). The wizard provides a structured, multi-phase experience where the Architect asks questions about your use case, analyzes uploaded documents, and generates a complete project structure including agents, tools, and configurations. This replaces the need to manually create agents, write ABL code, and configure tools from scratch.

Conversation history and configuration

Conversations with AI Architect are scoped to each project. When you switch between projects, the conversation history switches as well. Conversation history is persisted to the server, so you can close the panel and return to the same conversation later.

AI Architect requires an LLM provider to be configured at the workspace level. If no provider is configured, a warning banner appears in the panel with a message explaining the setup requirement. To configure the LLM provider, navigate to Admin > Architect Settings, configure the required credentials, and return to the Architect panel.

Related pages

• Studio overview — navigation, project management, and workspace layout
• Tools, knowledge & connections — managing tools and resources used by agents
• Testing, deployment & operations — evaluations and deployment
• Insights & settings — guardrails and project configuration