Core Concepts - Kore.ai Docs

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

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

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

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:

Interprets user requests to understand intent
Delegates tasks to appropriate agents
Coordinates multi-agent workflows
Resolves conflicts between agent outputs
Validates responses before delivery

Orchestration Patterns

Pattern	Best For
Single Agent	Simple, focused use cases with one domain
Supervisor	Complex tasks requiring parallel agent coordination
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.

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.

{
  "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?"

Query embedded into vector representation
Semantic search across knowledge base
Relevant chunks retrieved (return policy docs)
Context injected into agent prompt
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

​Agentic Apps

​Agents

​Agent Components

​Example Agent Definition

​Orchestrator

​Orchestration Patterns

​Tools

​Tool Types

​Tool Calling

​The Tool Calling Flow

​Parallel vs Sequential Calling

​Knowledge

​How Knowledge Works

​Knowledge Sources

​State Management

​State Types

​Context Window