Agent Orchestration Overview

🎯 What is Agent Orchestration?

Agent Orchestration is the process of coordinating multiple AI agents to work together, forming complex workflows where each agent handles a specific task. In Junis, orchestration is entirely prompt-based - you configure agent behavior through system prompts in the Admin UI, without writing any code.

🏗️ Architecture

┌─────────────────────────────────────────────┐
│           User Request                       │
└──────────────┬──────────────────────────────┘
               │
               ▼
┌─────────────────────────────────────────────┐
│         Orchestrator Agent                   │
│  (Analyzes & routes to appropriate agent)   │
└──┬──────────┬──────────┬────────────────────┘
   │          │          │
   ▼          ▼          ▼
┌─────┐   ┌─────┐   ┌─────────┐
│Agent│   │Agent│   │Workflow │
│  A  │   │  B  │   │ (Multi) │
└─────┘   └─────┘   └────┬────┘
                          │
                   ┌──────┴──────┐
                   ▼             ▼
                ┌─────┐       ┌─────┐
                │Agent│       │Agent│
                │  C  │       │  D  │
                └─────┘       └─────┘

🧩 Key Components

1. Orchestrator

Role: Top-level router that receives user requests and delegates to appropriate agents. Configuration: System prompt with routing rules. Example:

User: “Send an email to John”
Orchestrator: Routes to EmailAgent

2. Sub-Agents

Role: Specialized agents that handle specific tasks. Types:

LLM Agent: Single AI task execution
Sequential Agent: Multi-step workflow (A → B → C)
Parallel Agent: Concurrent execution (A + B + C simultaneously)
Loop Agent: Iterative refinement

Example:

EmailAgent: Handles email composition and sending
DataAgent: Handles data retrieval and analysis

3. Tools & MCP

Role: External capabilities agents can use. Tools: Python functions (e.g., search_database, generate_pdf) MCP: External platform integrations (e.g., GitHub, Firecrawl) Example:

Agent calls search_github_repo tool → Code retrieved via GitHub MCP

4. RAG Knowledge Base

Role: Domain-specific knowledge agents can query. Configuration: Upload documents → Create DataStore → Link to agent Example:

Agent queries company policies → RAG returns relevant documents

🔄 Workflow Types

Sequential Workflow

Pattern: A → B → C (one after another) Use Case: Multi-step processes where each step depends on the previous. Example: Brand Factbook Generation

User Request
  → DataCollector (gather data)
  → Analyzer (process data)
  → ReportGenerator (create PDF)

Parallel Workflow

Pattern: A + B + C (simultaneously) Use Case: Independent tasks that can run concurrently. Example: Multi-Source Data Collection

User Request
  ├── DataCollector (get DataCollector data)
  ├── CRCollector (get CR data)
  └── SalesforceCollector (get CRM data)
  → Aggregator (combine results)

Loop Workflow

Pattern: Repeat until condition met Use Case: Iterative refinement or retry logic. Example: Content Improvement

User Request
  → DraftWriter (create v1)
  → Reviewer (check quality)
  → IF quality < threshold: DraftWriter (improve) → Reviewer
  → ELSE: Return final draft

Hybrid Workflow

Pattern: Combination of above Example: Complex Business Process

Orchestrator
  → VerificationAgent (check inputs)
  → DataWorkflow (Sequential)
      ├── Collector1 (Parallel)
      ├── Collector2 (Parallel)
      └── Collector3 (Parallel)
      → Aggregator (combine)
  → AnalysisAgent (process)
  → ReportAgent (generate output)

✨ Core Capabilities

A. Agent Routing

What: Direct requests to specific agents based on keywords. How: Mention agent names in Orchestrator’s system prompt. Example:

이메일 요청 → EmailAgent 전송
데이터 분석 요청 → DataAgent 전송

B. Tool & MCP Calls

What: Agents call external functions and APIs. How: List tools/MCP in agent config, mention in prompt. Example:

사용 가능한 도구:
- send_email: 이메일 발송
- search_crm: CRM 검색

C. RAG Queries

What: Agents retrieve information from uploaded documents. How: Upload docs → Link DataStore → Mention knowledge domains in prompt. Example:

회사 정책 문서에서 휴가 규정 검색

D. Data Passing

What: Pass structured data between agents in workflows. How: Set output_key in parent, include_contents in child. Example:

DataCollector (outputs: collected_data)
  → Analyzer (receives: collected_data)

E. Flexible Patterns

What: Conditional logic and dynamic behavior. How: Write if/else logic in system prompts. Example:

IF 긴급 요청:
  → UrgentAgent
ELSE:
  → NormalAgent

🛠️ Configuration Methods

1. Admin UI (Recommended)

Easiest way to configure agents - no code required. Steps:

Agent Management → Create agents
Edit Agent → Set system prompt, tools, MCP, RAG
Relationships → Link agents together
Test → Send requests and monitor

2. API (Programmatic)

Use Junis API for automation or bulk operations. Endpoints:

POST /api/admin/agents - Create agent
PUT /api/admin/agents/{id} - Update agent
POST /api/admin/agents/{id}/relationships - Link agents

Documentation: See API Reference

📊 Monitoring & Optimization

Usage Tracking

View in Admin UI:

Usage → Agent usage statistics
Session logs and conversation history
Agent routing flow visualization

Performance Optimization

Best Practices:

Cache frequently-used agents (automatic in Junis)
Use Parallel workflows for independent tasks
Optimize prompts for clarity and conciseness
Monitor token usage and adjust as needed

🚀 Quick Start

1. Simple Routing Example

Goal: Create Orchestrator that routes to 2 agents. Steps:

Create 3 agents:
- Orchestrator (LLM_AGENT)
- EmailAgent (LLM_AGENT)
- DataAgent (LLM_AGENT)

Set Orchestrator prompt:

이메일 요청 → EmailAgent 전송
데이터 요청 → DataAgent 전송

Link agents: Orchestrator → EmailAgent, DataAgent
Test: “Send email” → Routes to EmailAgent

2. Multi-Step Workflow

Goal: Create Sequential workflow (A → B). Steps:

Create 3 agents:
- Orchestrator (LLM_AGENT)
- DataWorkflow (SEQUENTIAL_AGENT)
- CollectorAgent (LLM_AGENT)
- AnalyzerAgent (LLM_AGENT)
Link: DataWorkflow → CollectorAgent (order 1), AnalyzerAgent (order 2)
Link: Orchestrator → DataWorkflow
Test: “Analyze data” → CollectorAgent → AnalyzerAgent

3. Tool Integration

Goal: Agent that calls a tool. Steps:

Create SearchAgent (LLM_AGENT)
Add tool in config: ["search_database"]

Set prompt:

도구: search_database
사용자 검색 요청 시 search_database 호출

Test: “Search for X” → Calls tool

📖 Next Steps

Prompt Engineering Guide

Start Here: Learn to configure agents with prompts

Agent System Deep Dive

Understand agent types and architecture

Tools Development

Create custom tools for agents

MCP Integration

Connect external platforms (GitHub, Firecrawl, etc.)

❓ FAQ

Do I need to write code?

No! Junis orchestration is entirely prompt-based. Configure agents through the Admin UI with system prompts. Code is only needed for custom tools or advanced integrations.

How many agents can I create?

No hard limit. However, we recommend:

Orchestrator: 1 per organization
Sub-agents: 5-20 for most use cases
Nested workflows: Max 3-4 levels deep

Can agents share data?

What if an agent fails?

Automatic retry: Junis retries failed tool/MCP calls once
Error handling: Agents receive error messages and can handle gracefully
Monitoring: View errors in Usage logs
Recovery: Update agent prompts to handle edge cases

How do I test changes?

Edit agent → Save (cache auto-refreshes)
Send test message in Chat UI
Check Usage logs for routing and tool calls
Iterate on prompts based on results

🎓 Learning Path

Beginner:

Read this overview
Follow Quick Start examples
Try Prompt Engineering Guide

Intermediate:

Build Sequential and Parallel workflows
Integrate tools and MCP
Use RAG for knowledge retrieval

Advanced:

Create complex hybrid workflows
Optimize performance with caching
Build custom tools and MCP integrations

Ready to build? Start with the Prompt Engineering Guide → 🚀

User Guides

Documentation Index

​Agent Orchestration Overview

​🎯 What is Agent Orchestration?

​🏗️ Architecture

​🧩 Key Components

​1. Orchestrator

​2. Sub-Agents

​3. Tools & MCP

​4. RAG Knowledge Base

​🔄 Workflow Types

​Sequential Workflow

​Parallel Workflow

​Loop Workflow

​Hybrid Workflow

​✨ Core Capabilities

​A. Agent Routing

​B. Tool & MCP Calls

​C. RAG Queries

​D. Data Passing

​E. Flexible Patterns

​🛠️ Configuration Methods

​1. Admin UI (Recommended)

​2. API (Programmatic)

​📊 Monitoring & Optimization

​Usage Tracking

​Performance Optimization

​🚀 Quick Start

​1. Simple Routing Example

​2. Multi-Step Workflow

​3. Tool Integration

​📖 Next Steps