> ## Documentation Index
> Fetch the complete documentation index at: https://koreai.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# ABL how-to guides

These task-based guides help you build ABL agents. Each guide starts with the decision or pattern you need, then gives you working ABL to copy into a project.

Use the guides alongside the [ABL reference](/agent-platform/abl/reference/language-overview). The reference explains what each section and keyword does. The guides show which sections to combine for a scenario, and why.

## Prerequisites

Before you use these guides:

* Read the [ABL overview](/agent-platform/abl/reference/language-overview) to understand sections, indentation, and the goal-driven execution model.
* Get access to a project where you can create or edit agents.
* Identify the tools, workflows, and knowledge bases your agent uses. The examples reference these by name, so you must replace the placeholder names with your own.

## Guide categories

<CardGroup cols={2}>
  <Card title="Agent architecture and design" href="#agent-architecture-and-design">
    Choose an agent pattern, split work across agents, and set execution behavior.
  </Card>

  <Card title="Conversation entry and welcome experience" href="#conversation-entry-and-welcome-experience">
    Control greetings, startup logic, session setup, and channel differences.
  </Card>

  <Card title="Routing and multi-agent orchestration" href="#routing-and-multi-agent-orchestration">
    Route each conversation to the owning agent and debug the routing decision.
  </Card>
</CardGroup>

***

## Agent architecture and design

Decide how many agents to build, how to split their work, and how to configure their execution.

| Guide                                                                                                                                             | Use it when                                                                                                            |
| ------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| [How to choose between a reasoning agent and a FLOW-based agent](/agent-platform/abl/how-to/choose-reasoning-agent-or-flow)                       | You need to decide whether an agent should be goal-driven and flexible, step-driven and predictable, or a mix of both. |
| [How to decide whether to build one agent or multiple specialist agents](/agent-platform/abl/how-to/choose-single-agent-or-specialists)           | One customer-facing experience could be one broad agent or a supervisor with specialists.                              |
| [How to design a supervisor that routes users to specialist agents](/agent-platform/abl/how-to/design-supervisor-routing-agent)                   | One entry point must identify what the user needs, choose a specialist, and pass enough context.                       |
| [How to define clear responsibilities for each enterprise agent](/agent-platform/abl/how-to/define-agent-responsibilities)                        | An agent is becoming too broad or too vague for builders and support teams to reason about.                            |
| [How to combine reasoning steps with deterministic FLOW steps](/agent-platform/abl/how-to/combine-reasoning-and-flow-steps)                       | A conversation needs both flexible judgment and predictable execution.                                                 |
| [How to write effective agent goals, personas, instructions, and limitations](/agent-platform/abl/how-to/write-agent-goals-personas-instructions) | An agent needs a clear job boundary, a consistent voice, and explicit limits.                                          |
| [How to use behavior profiles to change agent behavior by context](/agent-platform/abl/how-to/use-behavior-profiles-by-context)                   | The same agent keeps its core responsibility but must change style, constraints, or tools by context.                  |
| [How to configure model, timeout, and execution settings for an agent](/agent-platform/abl/how-to/configure-agent-execution-settings)             | An agent needs explicit model choice, response limits, timeout boundaries, or history windowing.                       |
| [How to design reusable agents and modules for large projects](/agent-platform/abl/how-to/design-reusable-agent-modules)                          | Many agents, tools, and workflows must compose without duplicated responsibilities or routing ambiguity.               |
| [How to use EXECUTION.pipeline for agent routing, classification, and short-circuiting](/agent-platform/abl/how-to/use-agent-execution-pipeline)  | A supervisor needs classifier-assisted routing before the normal reasoning path decides what to do.                    |
| [How to configure EXECUTION.pipeline models, modes, thresholds, and fallbacks](/agent-platform/abl/how-to/configure-agent-execution-pipeline)     | The execution pipeline exists but needs tuning for model, mode, confidence thresholds, or fallback behavior.           |

## Conversation entry and welcome experience

Control what happens before and during the first user turn: greetings, startup logic, session setup, and channel differences.

| Guide                                                                                                                             | Use it when                                                                                             |
| --------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
| [How to create a welcome message for a new conversation](/agent-platform/abl/how-to/create-welcome-message)                       | A conversation should open with a clear first message before the user asks for help.                    |
| [How to use ON\_START to greet users before the first message](/agent-platform/abl/how-to/use-on-start-welcome)                   | The agent must run startup logic before the user sends the first turn.                                  |
| [How to personalize a welcome message for returning users](/agent-platform/abl/how-to/personalize-returning-user-welcome)         | The agent should recognize a known user and make the first turn specific to that user.                  |
| [How to run an authentication or profile lookup during welcome](/agent-platform/abl/how-to/run-auth-profile-lookup-on-start)      | The first turn should use authenticated context, such as account status or display name.                |
| [How to route users from the welcome experience to the right agent](/agent-platform/abl/how-to/route-users-from-welcome)          | The first assistant turn should guide the user into the right specialist path.                          |
| [How to initialize session variables before the first user turn](/agent-platform/abl/how-to/initialize-session-before-first-turn) | Flow steps, routing, templates, or tools need known session values before the user says anything.       |
| [How to design channel-specific welcome experiences](/agent-platform/abl/how-to/design-channel-specific-welcome)                  | Web chat, voice, messaging, or async channels need different startup behavior.                          |
| [How to handle empty-state and fallback greetings](/agent-platform/abl/how-to/handle-fallback-greetings)                          | Startup context may be missing, a branch may not match, or a channel may not deliver proactive content. |

## Routing and multi-agent orchestration

Send each conversation to the agent that owns the work, handle unclear or bundled requests, and debug the routing decision.

| Guide                                                                                                                         | Use it when                                                                                                        |
| ----------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
| [How to route users by detected intent](/agent-platform/abl/how-to/route-by-user-intent)                                      | A supervisor classifies what the user is trying to do, then hands the conversation to the specialist that owns it. |
| [How to design supervisor routing with priority gates](/agent-platform/abl/how-to/route-with-supervisor-priority)             | Mandatory checks such as authentication, fraud screening, or consent must run before a business route.             |
| [How to route by role, channel, language, and session state](/agent-platform/abl/how-to/route-by-role-channel-language-state) | The same user intent must branch by channel, language, role, or current session state.                             |
| [How to route by tool result, profile lookup, or remembered state](/agent-platform/abl/how-to/route-by-tool-result-or-memory) | Routing depends on profile, case status, risk, entitlement, or a remembered preference, not just the utterance.    |
| [How to route unclear or unsupported requests to a fallback agent](/agent-platform/abl/how-to/route-to-fallback-agent)        | The supervisor cannot confidently choose a specialist, or the request is outside the supported intent catalog.     |
| [How to handle messages that contain multiple user intents](/agent-platform/abl/how-to/handle-multiple-intents)               | Customers bundle several tasks into a single message and secondary requests must not be dropped.                   |
| [How to clarify before routing to a specialist agent](/agent-platform/abl/how-to/clarify-before-routing)                      | A request is short, ambiguous, overloaded, or missing the one field that determines ownership.                     |
| [How to switch the active agent during a conversation](/agent-platform/abl/how-to/switch-active-agent)                        | A supervisor should stop answering directly and let a specialist own the next turn.                                |
| [How to debug routing decisions in traces](/agent-platform/abl/how-to/debug-routing-traces)                                   | You need to explain why a user reached one specialist, or why a route fell through to fallback.                    |
