Knowledge Orchestrator

Overview

The Knowledge Orchestrator is a meta-cognitive skill that automatically analyzes user requests and intelligently routes them to the most appropriate specialized skill(s): obsidian-markdown, hierarchical-reasoning, or knowledge-graph. It operates as a transparent cognitive layer that enhances task execution through:

Automatic skill selection based on semantic task analysis
Context-aware routing using confidence-weighted decision logic
Workflow composition for complex multi-skill tasks
Hybrid MCP integration that enriches context before delegation
Quality validation ensuring outputs meet standards

The orchestrator eliminates the need for manual skill selection while enabling sophisticated multi-skill workflows that produce higher-quality outputs than individual skills alone.

Core Philosophy

The orchestrator operates at a meta-tactical level—above individual skill tactics but below user-facing strategy—serving as an intelligent dispatcher rather than a monolithic controller. It preserves skill autonomy (skills can still be invoked directly) while adding adaptive coordination that emerges from task analysis rather than rigid rules.

Core Capabilities

1. Semantic Task Analysis

Extracts multi-dimensional features from user requests to enable intelligent routing:

Feature Dimensions:

Content Type: code, structured_data, prose, mixed
Artifact Type: file, knowledge, analysis, visualization
Complexity Score: 0.0-1.0 based on decomposition needs, domain breadth, abstraction level
Creation Signals: creates_md_file, requires_extraction, requires_decomposition
Domain Signals: obsidian_keywords, reasoning_keywords, graph_keywords

Example Analysis:

User: "Create a comprehensive note about neural networks with entity relationships"

Analysis:
  content_type: prose
  artifact_type: file + knowledge
  complexity_score: 0.75 (multi-step, requires structure)
  creates_md_file: true (keyword "note")
  requires_extraction: true (keyword "entity relationships")
  obsidian_signals: 1 ("note")
  graph_signals: 2 ("entity", "relationships")

Selection: Multi-skill workflow (research→structure→document pattern)

Keyword Catalogs:

Obsidian: vault, wikilink, dataview, frontmatter, callout, note, .md, mermaid, templater
Reasoning: analyze, strategic, tactical, decompose, converge, multi-level, planning
Graph: entities, relationships, extract, ontology, schema, knowledge graph, mapping

2. Skill Selection

Maps task features to skill(s) using confidence-weighted decision logic with priority tiers:

Confidence Thresholds:

0.90-1.0: Execute immediately (high confidence)
0.70-0.89: Execute with notification about selection reasoning
0.50-0.69: Present options to user for confirmation
<0.50: Ask user to specify skill or provide more context

Decision Priority Order:

Explicit Triggers (0.90-1.0 confidence)
- Creates .md file → obsidian-markdown (0.95)
- Contains 3+ Obsidian keywords → obsidian-markdown (0.92)
- Requires extraction + non-code content → knowledge-graph (0.90)
- Contains 2+ graph keywords → knowledge-graph (0.88)
- Complexity > 0.7 + requires decomposition → hierarchical-reasoning (0.90)
- Contains 3+ reasoning keywords → hierarchical-reasoning (0.88)
Implicit Triggers (0.70-0.89 confidence)
- Artifact type = knowledge (no explicit extraction) → knowledge-graph (0.75)
- Complexity > 0.5 + artifact = analysis → hierarchical-reasoning (0.72)
- Artifact = file + content = prose → obsidian-markdown (0.70)
Workflow Detection
- Multiple candidates → check workflow pattern library
- Match found → route to workflow coordinator
Tiebreaker Logic
- Single candidate → execute that skill
- Multiple candidates without workflow → select highest confidence
- Zero candidates → ask user for clarification

Decision Tree Reference: See references/decision_logic.md for complete rules and examples

3. Workflow Coordination

Composes multi-skill workflows for complex tasks using canonical patterns:

Pattern 1: Research → Structure → Document

description: "Complex topic research → structured documentation"
trigger_conditions:
  - complexity_score > 0.7
  - artifact_type == file
  - requires_decomposition == true

sequence:
  1. hierarchical-reasoning:
     purpose: "Strategic decomposition of topic"
     input: user_request
     output: strategic_insights

  2. knowledge-graph:
     purpose: "Extract entities/relationships from insights"
     input: strategic_insights.operational_output
     output: knowledge_structure

  3. obsidian-markdown:
     purpose: "Format as Obsidian note"
     input:
       content: knowledge_structure
       template: moc-template
       frontmatter:
         tags: knowledge_structure.entity_types
         related: knowledge_structure.entity_names
     output: final_note

Pattern 2: Extract → Validate → Format

description: "Process unstructured text → validated knowledge → Obsidian note"
trigger_conditions:
  - artifact_type == file
  - requires_extraction == true
  - content_type == prose

sequence:
  1. knowledge-graph:
     purpose: "Extract entities and relationships"
     input: user_request.source_text
     output: raw_graph

  2. hierarchical-reasoning:
     purpose: "Validate graph coherence and completeness"
     input:
       problem: "Assess quality of extracted knowledge graph"
       context: raw_graph
     output: validation_assessment

  3. obsidian-markdown:
     purpose: "Create structured note with wikilinks"
     input:
       entities: raw_graph.entities
       relationships: raw_graph.relationships
       template: note-template
     output: final_note

Pattern 3: Analyze → Graph → Visualize

description: "Complex system analysis → knowledge graph → visualization"
trigger_conditions:
  - complexity_score > 0.6
  - requires_decomposition == true
  - requires_extraction == true

sequence:
  1. hierarchical-reasoning:
     purpose: "Decompose system into components"
     input: user_request
     output: system_decomposition

  2. knowledge-graph:
     purpose: "Map components as graph"
     input: system_decomposition
     output: system_graph

  3. obsidian-markdown:
     purpose: "Visualize with Mermaid diagram"
     input:
       graph: system_graph
       diagram_type: mermaid_graph
       template: note-template
     output: visual_doc

Workflow Pattern Reference: See references/workflow_patterns.md for additional patterns and customization

4. Context Enrichment

Gathers relevant context via MCP tools before skill delegation using a hybrid approach:

Obsidian-Markdown Enrichment:

Analyze vault conventions (if accessible)
Select appropriate template based on note type
Load relevant reference documentation
Gather example notes of similar type

Hierarchical-Reasoning Enrichment:

Identify constraints from task features
Define success criteria based on complexity/domain
Set convergence parameters (thresholds, cycle counts)
Gather domain-specific examples

Knowledge-Graph Enrichment:

Load domain ontology (core_ontology.md or coding_domain.md)
Search for similar extraction examples
Set confidence thresholds based on complexity
Retrieve relevant schemas

MCP Integration Reference: See references/mcp_integration.md for tool usage patterns

5. Output Validation

Ensures skill outputs meet quality standards before returning to user:

Obsidian-Markdown Validation:

Valid YAML frontmatter present
Wikilinks used for internal notes (not markdown links)
Callout syntax correct
Tables properly formatted
Code blocks have language tags

Hierarchical-Reasoning Validation:

Convergence score ≥ 0.85
All three levels present (strategic, tactical, operational)
Average confidence ≥ 0.7
Reasoning trace available if requested

Knowledge-Graph Validation:

Minimum entity count (≥3 for meaningful graphs)
Minimum relationship count (≥2 for connectivity)
Provenance coverage (all entities have source attribution)
Confidence scores present
No broken references

Quality Thresholds:

Overall quality score ≥ 0.6 to pass validation
If validation fails, trigger refinement or notify user
Issues reported with actionable remediation steps

Validation Reference: See references/validation_criteria.md for complete checklists

Integration Points

The orchestrator bridges outputs between skills through automatic transformations:

Knowledge Graph → Obsidian

Entities → [[wikilinks]] with proper formatting
Relationships → Mermaid diagram syntax
Confidence scores → Frontmatter metadata
Provenance → Source attribution in frontmatter

Hierarchical Reasoning → Knowledge Graph

Strategic insights → Extraction focus areas
Operational details → Entity candidates
Tactical structure → Relationship organization
Convergence metrics → Validation criteria

Hierarchical Reasoning → Obsidian

Strategic level → H2 headings
Tactical level → H3 headings
Operational level → H4 headings / detailed content
Confidence scores → Callout annotations

Integration Reference: See references/integration_mappings.md for transformation specifications

Usage Patterns

Automatic Activation (Recommended)

The orchestrator evaluates every request to determine if specialized skills should handle it:

User: "Create a note about microservices architecture with key concepts and relationships"

Orchestrator Analysis:
✓ Detected: creates_md_file (keyword "note")
✓ Detected: requires_extraction (keywords "concepts", "relationships")
✓ Complexity score: 0.75 (multi-step analysis + structure + formatting)
✓ Pattern match: Research → Structure → Document

Execution:
1. [hierarchical-reasoning] Decompose microservices architecture
2. [knowledge-graph] Extract entities (concepts, patterns, technologies)
3. [obsidian-markdown] Format as MOC with wikilinks + mermaid diagram

Result: Comprehensive Obsidian note with strategic insights, linked entities, and visual architecture diagram

Manual Override

Users can explicitly request specific skills or bypass orchestrator:

User: "Use hierarchical-reasoning only to analyze this problem"
→ Orchestrator delegates directly to hierarchical-reasoning without workflow composition

User: "Don't use the orchestrator, just create a simple markdown note"
→ Orchestrator deactivates, standard markdown creation proceeds

Debugging Mode

Request orchestrator to explain its decision-making:

User: "Explain why you selected those skills"
→ Orchestrator outputs:
   • Task features extracted
   • Confidence scores calculated
   • Decision logic applied
   • Workflow pattern matched (if multi-skill)

Configuration

The orchestrator supports optional configuration tuning:

Confidence Thresholds (adjust selection sensitivity):

execute_immediately: 0.90  # High confidence threshold
execute_with_note: 0.70    # Medium confidence threshold
ask_user: 0.50             # Low confidence threshold

Workflow Detection (enable/disable pattern matching):

workflow_patterns_enabled: true
custom_patterns_path: /path/to/custom/patterns.yaml

Context Enrichment (control MCP usage):

mcp_enrichment: hybrid  # Options: hybrid, full, minimal, none
max_enrichment_tools: 3

Validation Strictness (adjust quality requirements):

quality_threshold: 0.6  # Minimum score to pass (0.0-1.0)
strict_mode: false      # Require all checks to pass

Advanced Features

Learning from Patterns

The orchestrator can adapt based on user preferences:

Track which skills user manually selects after seeing orchestrator suggestions
Adjust confidence weights for future similar tasks
Learn user-specific workflow preferences

Recursive Refinement

If validation fails or quality is low:

Analyze what went wrong (missing info, low confidence, structural issues)
Determine if re-running with enriched context would help
Optionally loop workflow with additional constraints

Skill Extensibility

The orchestrator can be extended to coordinate additional skills:

Add new skill to task analyzer keyword catalog
Define trigger conditions and confidence scoring
Map integration points (how skill outputs transform to other skill inputs)
Add validation criteria for new skill's outputs

See references/extending_orchestrator.md for extension guide

Resources

This skill includes comprehensive reference documentation:

references/

decision_logic.md - Complete decision rules, examples, and edge cases
workflow_patterns.md - Canonical patterns with customization options
integration_mappings.md - Transformation specifications between skills
validation_criteria.md - Quality checklists for each skill
mcp_integration.md - MCP tool usage patterns and best practices
extending_orchestrator.md - Guide for adding new skills to orchestration

scripts/

task_classifier.py - Standalone task feature extraction utility
skill_selector.py - Test skill selection logic on sample inputs
validate_workflow.py - Validate custom workflow pattern definitions

Skill Interaction Examples

Example 1: Knowledge Base Construction

User: "Help me build a knowledge base about distributed systems"

Orchestrator:
  Task Analysis: complexity=0.85, artifact=knowledge+file, requires_decomposition=true
  Selection: Multi-skill workflow (Research → Structure → Document)

Execution:
  1. Hierarchical-reasoning decomposes distributed systems into strategic themes
  2. Knowledge-graph extracts key entities (CAP theorem, consensus algorithms, etc.)
  3. Obsidian-markdown creates MOC with wikilinks and concept map

Output: Structured Obsidian vault entry with linked concepts and visual diagrams

Example 2: Research Synthesis

User: "Analyze this research paper and create a structured summary"

Orchestrator:
  Task Analysis: complexity=0.70, artifact=file, requires_extraction=true
  Selection: Multi-skill workflow (Extract → Validate → Format)

Execution:
  1. Knowledge-graph extracts authors, methods, findings, citations
  2. Hierarchical-reasoning validates coherence and completeness
  3. Obsidian-markdown formats with proper citations and structure

Output: Well-structured note with extracted entities, validated insights, proper formatting

Example 3: Learning Workflow

User: "I'm learning about GraphQL - help me organize what I'm learning"

Orchestrator:
  Task Analysis: complexity=0.60, artifact=file, domain=technical_learning
  Selection: Single skill with enhancement (obsidian-markdown + light graph extraction)

Execution:
  1. Identify GraphQL concepts to track
  2. Create learning note template with progress tracking
  3. Suggest related concept links

Output: Learning-optimized note with concept relationships and tracking structure

Best Practices

Trust automatic selection - The orchestrator analyzes task features systematically
Provide context - More detail in requests → better skill selection and context enrichment
Use explain mode - When selection seems wrong, ask orchestrator to explain reasoning
Extend thoughtfully - Only add new skills when they provide unique capabilities
Validate outputs - Review quality scores and validation results for critical work
Iterate patterns - Custom workflow patterns can be added for domain-specific needs

Limitations

Learning curve: Understanding orchestrator decision logic takes time
Overhead: Task analysis adds token usage (offset by better skill selection)
Skill dependency: Requires obsidian-markdown, hierarchical-reasoning, knowledge-graph skills
Context limits: Very large workflows may approach context window constraints
Manual better sometimes: Simple tasks may not benefit from orchestration

When Not to Use

Simple single-skill tasks: "Fix this typo" doesn't need orchestration
Explicit skill preference: User states "only use X skill"
Time-critical tasks: Analysis overhead may not be worthwhile
Highly specialized domains: Custom skills may be more appropriate than orchestration

Core Philosophy: The orchestrator emerges sophisticated capabilities from simple skill coordination, enabling workflows greater than the sum of their parts while preserving the autonomy and specialization that makes individual skills valuable.

knowledge-orchestrator