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

# Core Concepts

Understand the building blocks of the Agent Platform.

## Agentic Apps

An **agentic app** is an autonomous system that uses AI agents to understand user intent, reason about tasks, and take actions to deliver outcomes.

Unlike traditional chatbots that follow predefined scripts, agentic apps:

* **Reason dynamically** about how to approach tasks
* **Select tools** based on context and user needs
* **Coordinate multiple agents** for complex workflows
* **Maintain state** across conversations

<div class="ascii-art">
  ```
  Traditional Bot                Agentic App
  ────────────            ───────────────
  User Input                      User Input
      ↓                               ↓
  Match Intent                    Understand Intent
      ↓                               ↓
  Execute Script                  Reason & Plan
      ↓                               ↓
  Return Response                 Select Agent(s)
                                      ↓
                                  Invoke Tools
                                      ↓
                                  Generate Response
  ```
</div>

## Agents

An **agent** is a specialized AI worker with a defined scope, instructions, and access to specific tools and knowledge.

### Agent Components

| Component        | Purpose                                               |
| ---------------- | ----------------------------------------------------- |
| **Profile**      | Name, description, and avatar that identify the agent |
| **AI Model**     | The LLM that powers reasoning and generation          |
| **Scope**        | Boundaries defining what tasks the agent handles      |
| **Instructions** | Behavioral guidelines and response patterns           |
| **Tools**        | Actions the agent can perform                         |
| **Knowledge**    | Information sources for RAG retrieval                 |

### Example Agent Definition

```yaml theme={null}
name: Billing Agent
description: Handles billing inquiries, payment processing, and invoice management

scope: |
  Responsible for:
  - Payment status inquiries
  - Invoice generation and retrieval
  - Payment method updates
  - Refund processing

instructions: |
  - Verify customer identity before discussing billing details
  - Always confirm transaction amounts before processing
  - Provide clear breakdowns of charges when asked
  - Escalate disputed charges over $500 to a human agent

tools:
  - get_payment_status
  - generate_invoice
  - process_refund
  - update_payment_method

knowledge:
  - billing_faqs
  - pricing_documentation
```

## Orchestrator

The **orchestrator** is the central coordinator that manages how agents work together. It:

1. **Interprets** user requests to understand intent
2. **Delegates** tasks to appropriate agents
3. **Coordinates** multi-agent workflows
4. **Resolves** conflicts between agent outputs
5. **Validates** responses before delivery

### Orchestration Patterns

| Pattern                                                            | Best For                                            |
| ------------------------------------------------------------------ | --------------------------------------------------- |
| [Single Agent](/agent-platform/orchestration/single-agent)         | Simple, focused use cases with one domain           |
| [Supervisor](/agent-platform/orchestration/supervisor)             | Complex tasks requiring parallel agent coordination |
| [Adaptive Network](/agent-platform/orchestration/adaptive-network) | Dynamic hand-offs between specialized agents        |

## Tools

**Tools** are capabilities that enable agents to interact with external systems, retrieve data, and perform actions.

### Tool Types

* **Workflow Tools**: Visual, no-code tools built with a drag-and-drop interface. Best for well-defined processes that benefit from visual traceability.

Example: A policy lookup flow that checks user eligibility, fetches the relevant policy details, and returns a formatted response.

```
Start → Check eligibility → Fetch Details → Format Response → End
```

* **Code Tools**: Custom JavaScript or Python functions for complex logic. Best for dynamic processing, calculations, or custom integrations.

```python theme={null}
def calculate_shipping(weight: float, destination: str) -> dict:
    rate = get_shipping_rate(destination)
    cost = weight * rate
    return {"cost": cost, "estimated_days": get_delivery_estimate(destination)}
```

* **MCP Tools**: Remote functions exposed via Model Context Protocol servers. Best for shared toolsets and enterprise integrations.

```json theme={null}
{
  "server": "https://tools.company.com/mcp",
  "tools": ["crm_lookup", "inventory_check", "order_create"]
}
```

## Tool Calling

**Tool calling** is how agents interact with tools during task execution.

### The Tool Calling Flow

```

1. User: "What's my account balance?"

2. Agent identifies need for external data
   └─ Selected tool: get_account_balance

3. Agent prepares parameters
   └─ { "user_id": "usr_123" }

4. Platform invokes the tool
   └─ API call to banking system

5. Tool returns result
   └─ { "balance": 1234.56, "currency": "USD" }

6. Agent generates response
   └─ "Your current account balance is $1,234.56"

```

### Parallel vs Sequential Calling

**Sequential**: Tools execute one after another when outputs are dependent.

```
get_user_profile → get_account_balance → format_statement
```

**Parallel**: Independent tools execute simultaneously for faster responses.

```
┌─ get_account_balance ─┐
├─ get_recent_transactions ─┼─→ combine_results
└─ get_rewards_points ──┘
```

## Knowledge

**Knowledge** connects agents to your data sources, enabling context-aware responses through Retrieval-Augmented Generation (RAG).

### How Knowledge Works

```
User Query: "What's your return policy for electronics?"

1. Query embedded into vector representation
2. Semantic search across knowledge base
3. Relevant chunks retrieved (return policy docs)
4. Context injected into agent prompt
5. Agent generates accurate, grounded response
```

### Knowledge Sources

* Document uploads (PDF, DOCX, TXT)
* Web crawlers
* Third-party applications such as Confluence, SharePoint, Google Drive
* Structured Data
* Custom connectors

## State Management

Agentic apps maintain **state** to enable natural, multi-turn conversations.

### State Types

**Short-term (Session)**
Temporary context within a conversation:

* Current order being discussed
* Selected product options
* Pending confirmations

**Long-term (Memory)**
Persistent preferences and history:

* User preferences
* Past interactions
* Account information

### Context Window

The context window limits how many messages agents retain. Configure it based on your use case.

| Setting  | Messages | Use Case                     |
| -------- | -------- | ---------------------------- |
| Minimal  | 25       | Simple Q\&A, transactional   |
| Default  | 50       | General conversations        |
| Extended | 100      | Complex multi-step workflows |
| Maximum  | 200      | Deep contextual discussions  |