Fabric Orchestrator

The intelligent coordinator that routes tasks, manages workflows, and learns from experience.

The Fabric Orchestrator is the brain of Fabric AI. It intelligently routes your requests to the right agents and tools, manages complex multi-step workflows, and learns from every interaction to get better over time.

What Makes the Orchestrator Special?

Before the Orchestrator

User: "Create a PRD and add stories to Jira"
        │
        ▼
┌─────────────────────────────────────────┐
│           Manual Process                 │
│  1. Open Document Generator              │
│  2. Generate PRD                         │
│  3. Copy PRD content                     │
│  4. Open Jira                            │
│  5. Manually create stories              │
│  6. Hope nothing fails                   │
└─────────────────────────────────────────┘

With the Orchestrator

User: "Create a PRD and add stories to Jira"
        │
        ▼
┌─────────────────────────────────────────┐
│           Orchestrator                   │
│  1. Detect user intent                   │
│  2. Retrieve workspace context           │
│  3. Create execution plan                │
│  4. Generate PRD (document agent)        │
│  5. Create Jira tickets (integration)    │
│  6. Handle errors automatically          │
│  7. Learn for next time                  │
└─────────────────────────────────────────┘
        │
        ▼
    PRD + Jira stories created

Core Capabilities

1. User Intent Detection

The Orchestrator understands what you're asking for, including explicit requests:

Request: "Use the Jira tool to get my open tickets"
            │
            ▼
┌─────────────────────────────────────────┐
│        Intent Detection                  │
│  • Explicit tool request: Jira          │
│  • Operation: read/list                  │
│  • Skip semantic search for alternatives │
└─────────────────────────────────────────┘
            │
            ▼
      Use Jira MCP directly

Recognized intents:

Explicit tool requests — "use the Jira tool", "search with GitHub"
YouTube URLs — Automatically routes to transcript extraction
Workspace references — "my docs", "attached files" → use RAG
Integration triggers — "post to Slack", "send an email"
Fabric patterns — "summarize", "extract wisdom", "analyze claims"

2. Semantic Routing

The Orchestrator uses AI embeddings to find the best executor for your task:

Request: "Post this update to our team Slack"
            │
            ▼
┌─────────────────────────────────────────┐
│        Semantic Search                   │
│  Query: "post update slack"              │
│                                          │
│  Results:                                │
│  • slack integration: send_message (0.96)│
│  • slack-mcp: post_message (0.91)       │
│  • notification-agent (0.71)             │
└─────────────────────────────────────────┘
            │
            ▼
      Use Slack integration (fastest)

Why this matters:

No need to remember which tool does what
Works with 100+ tools without confusion
Natural language understanding
Respects explicit user preferences

3. Task Planning

Complex requests are automatically decomposed:

Request: "Create a PRD for auth, generate stories, post to Slack"
            │
            ▼
┌─────────────────────────────────────────────────────────────┐
│                        Task Plan                             │
├─────────────────────────────────────────────────────────────┤
│ Step 1: Generate PRD                                         │
│   Executor: document-generator (agent)                       │
│   Outputs: prd_document                                      │
│                                                              │
│ Step 2: Extract Stories                                      │
│   Executor: task-planner (agent)                             │
│   Inputs: prd_document                                       │
│   Outputs: story_list                                        │
│                                                              │
│ Step 3: Create Jira Tickets                                  │
│   Executor: jira-mcp (tool)                                  │
│   Inputs: story_list                                         │
│   Outputs: ticket_ids                                        │
│                                                              │
│ Step 4: Post Summary to Slack                                │
│   Executor: slack (integration)                              │
│   Inputs: prd_document, ticket_ids                           │
│   Outputs: message_sent                                      │
└─────────────────────────────────────────────────────────────┘

4. Priority-Based Executor Assignment

Each step is assigned the optimal executor based on capability and speed:

Priority	Executor Type	Use Case
1	Workflow Integrations	Slack, GitHub, Email—fastest path
2	MCP Tools	Connected services via MCP protocol
3	Fabric AI Tools	YouTube, web scraping, audio
4	Specialized Agents	Tasks requiring AI reasoning
5	Pre-defined Workflows	Complex automations
6	LLM	Simple text generation
7	Web/Browser	Browser automation (last resort)

5. Context Flow

Each step can use outputs from previous steps:

Step 1 Output: { prd_document: "## Authentication PRD..." }
                    │
                    ▼
Step 2 Input:  Uses prd_document
Step 2 Output: { stories: [{ title: "Login flow" }, ...] }
                    │
                    ▼
Step 3 Input:  Uses stories
Step 3 Output: { ticket_ids: ["AUTH-1", "AUTH-2", ...] }
                    │
                    ▼
Step 4 Input:  Uses prd_document AND ticket_ids
Step 4 Output: { message: "Posted to #engineering" }

Variable interpolation allows referencing previous step outputs:

// Step 4 can reference previous outputs
{
  message: "PRD: {{step-1.output.title}}. Tickets: {{step-3.output.ticket_ids}}"
}

6. Trust-Based Approvals

The Orchestrator learns what you approve:

Week 1:
┌────────────────────────────────────────────────────────────┐
│ "Post to Slack?"  [Approve] [Reject]                       │
│ "Create Jira ticket?"  [Approve] [Reject]                  │
│ "Post to Slack?"  [Approve] [Reject]                       │
│ "Create Jira ticket?"  [Approve] [Reject]                  │
└────────────────────────────────────────────────────────────┘

Week 4:
┌────────────────────────────────────────────────────────────┐
│ Post to Slack: ✅ Auto-approved (100% approval history)    │
│ Create Jira: ✅ Auto-approved (100% approval history)      │
│ Delete 50 records: ⚠️ [Approve] [Reject] (always ask)     │
└────────────────────────────────────────────────────────────┘

7. Memory System

The Orchestrator remembers what works and what doesn't:

Positive Memory (Letta + Qdrant):

Successful routing patterns
Effective tool combinations
Working prompts and parameters

Negative Memory:

Failed approaches
Rate-limited operations
Error-prone patterns

New request similar to past failure:
"⚠️ Similar task failed 3 days ago due to rate limiting.
 Automatically batching operations with delays."

8. Graceful Recovery

When things go wrong, the Orchestrator handles it:

Error Type	Response
Timeout	Retry with longer timeout
Rate limit	Exponential backoff
Network error	Retry with backoff
Validation error	Fix and retry once
Not found	Skip step, continue
Auth error	Fail gracefully, alert user

Workflow Integrations

The Orchestrator includes built-in integrations for common services—faster than MCP:

Available Integrations

Integration	Operations	Speed
Slack	send_message, post_notification, send_dm	~200ms
GitHub	create_issue, create_pr, list_issues	~300ms
Linear	create_issue, list_issues, update_issue	~250ms
Email	send_email (via Resend)	~400ms
Webhooks	Custom HTTP calls	~200ms

Integration vs. MCP Tools

┌─────────────────────────────────────────────────────────────┐
│ "Post to Slack"                                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Integration Path:              MCP Path:                   │
│  ┌──────────────┐              ┌──────────────┐            │
│  │ Direct API   │              │ MCP Protocol │            │
│  │ Call (~200ms)│              │ (~800ms)     │            │
│  └──────────────┘              └──────────────┘            │
│                                                             │
│  The Orchestrator automatically chooses the faster path.    │
└─────────────────────────────────────────────────────────────┘

Fabric AI Tools

Built-in tools for content processing without external dependencies:

YouTube Tools

fabric_youtube_transcript — Extract raw transcripts with optional timestamps
fabric_analyze_youtube — Apply patterns: summarize, extract_wisdom, analyze_claims, create_keynote

Request: "Summarize this YouTube video: https://youtube.com/watch?v=..."
            │
            ▼
┌─────────────────────────────────────────┐
│  Fabric AI YouTube Tool                  │
│  1. Extract transcript                   │
│  2. Apply summarize pattern              │
│  3. Return structured summary            │
└─────────────────────────────────────────┘

Web Tools

fabric_scrape_url — Scrape and readability-enhance web content
fabric_analyze_webpage — Apply Fabric patterns to web content

Audio Tools

fabric_transcribe_audio — Convert audio files to text

MCP Tool Integration

The Orchestrator can execute MCP tools directly:

Available Tools

GitHub — Issues, PRs, repositories
Jira — Tickets, sprints, projects
Slack — Messages, channels
Notion — Pages, databases
Linear — Issues, projects
And many more...

Tool Selection

The Orchestrator automatically selects tools:

Request: "Create a Jira ticket for the login bug"
            │
            ▼
┌─────────────────────────────────────────┐
│  Tool Selection                          │
│  • Search: "create jira ticket"          │
│  • Match: jira-mcp → create_issue (0.96) │
│  • Decision: Use MCP tool directly       │
└─────────────────────────────────────────┘

Tool vs. Agent Delegation

Scenario	Use Tool	Use Agent
Direct API call	✓
Simple CRUD	✓
Needs reasoning		✓
Complex generation		✓
Multi-step logic		✓

Starred Preferences

Prioritize your favorite tools, servers, and agents:

How to Star

Go to Settings → MCP Servers or Agents
Click the ⭐ icon next to items you use frequently
Starred items get priority in routing decisions

What Starring Does

Starred Item	Effect
MCP Server	ALL tools from that server get elevated priority
Specific Tool	Individual tool boosted in semantic search
Agent	Preferred agent considered first for delegation
Integration	Favorite integration prioritized

Using the Orchestrator

Starting a Conversation

Go to Agents → Fabric AI (Orchestrator)
Type your request naturally
The Orchestrator handles the rest

Example Requests

Simple:

"Create a PRD for user authentication"

Multi-step:

"Create a PRD for the payment feature, then generate
user stories and create them in Jira"

With context:

"Based on our Q4 roadmap, create a technical spec
for the new API gateway and post a summary to #engineering"

YouTube processing:

"Summarize this video and extract the key insights:
https://youtube.com/watch?v=..."

Web research:

"Scrape this article and create a summary with key takeaways:
https://example.com/article"

Execution Modes

Choose the right mode for your task:

Mode	Max Steps	Use Case
Lite	10	Quick tasks, simple queries
Balanced	20	Standard workflows (default)
Deep	25	Complex multi-agent tasks

Attaching Context

Improve results by attaching:

Workspaces — Documents for RAG context
Projects — Previous project documents
Specific files — Upload directly

Workflow Visualization

Watch your workflow execute in real-time:

┌──────────────────────────────────────────────────────────┐
│                  Workflow Progress                        │
├──────────────────────────────────────────────────────────┤
│ Step 1: Generate PRD                    ✓ Complete       │
│   └── Using document-generator                           │
│   └── 3.2 seconds                                        │
│                                                          │
│ Step 2: Extract Stories                 ● In Progress    │
│   └── Using task-planner                                 │
│   └── Processing...                                      │
│                                                          │
│ Step 3: Create Jira Tickets             ○ Pending        │
│                                                          │
│ Step 4: Post to Slack                   ○ Pending        │
└──────────────────────────────────────────────────────────┘

Approval Workflows

When Approvals Are Needed

The Orchestrator requests approval for:

High-risk operations — Delete, bulk updates
External actions — First-time tool usage
Expensive operations — Large API calls
Unknown patterns — New types of requests

Risk Levels

Operation	Risk Level	Approval
Read/List/Search	Low	Auto-approved
Update/Modify	Medium	Check trust history
Create/Insert	High	Ask if untrusted
Delete/Bulk ops	Critical	Always ask
Code execution	Medium+	Check trust history
Browser automation	Medium+	Check trust history

Approval Interface

┌──────────────────────────────────────────────────────────┐
│                  Approval Required                        │
├──────────────────────────────────────────────────────────┤
│                                                          │
│  The workflow wants to:                                   │
│                                                          │
│  ✓ Create PRD document (auto-approved)                   │
│  ✓ Generate 5 user stories (auto-approved)               │
│  ⚠️ Create 5 Jira tickets                                │
│                                                          │
│  Affected resources:                                      │
│  • Jira project: AUTH                                    │
│  • 5 new tickets                                         │
│                                                          │
│  [Approve All]  [Approve Without Jira]  [Reject]         │
│                                                          │
└──────────────────────────────────────────────────────────┘

Consolidated Prompts

Multiple approvals are grouped into one:

Before: 5 separate approval prompts
After:  1 consolidated prompt with all actions listed

Advanced Features

Follow-up Handling

The Orchestrator understands context:

You: "Create a PRD for auth"
Orchestrator: [Generates PRD]

You: "Actually, also include OAuth support"
Orchestrator: "Updating PRD to include OAuth..."
[Modifies existing document, not starting over]

Journey Tracking

Full context is maintained:

Current phase of execution
Decisions made and why
Assumptions with confidence levels
All artifacts generated
Complete conversation history

Real-time Signals

Query workflow state anytime:

// Get current progress
const progress = await orchestrator.query('progress');
// { currentStep: 2, totalSteps: 5, status: 'executing' }

// Get generated artifacts
const artifacts = await orchestrator.query('artifacts');
// [{ type: 'prd', name: 'Auth PRD', status: 'complete' }]

Generalist Agent Delegation

For complex tasks requiring autonomous execution:

Delegation Mode	Behavior
`single-step`	Orchestrator decomposes, agent executes steps
`complete-task`	Agent handles entire task autonomously

Next Steps

Document Generator

Learn about the document generation agent

MCP Integration

Connect external tools

Workflows

Understand Temporal-powered execution

Fabric Orchestrator

Document Generator

MCP Integration

Workflows

On this page