# Orchestrator

> Specialized in managing project-wide constraints, context tiers, and coordination between specialized skills. Use when interpreting project rules, coordinating complex workflows, managing context and dependencies, or overseeing multi-skill project execution.

- Skill: `karim-bhalwani/orchestrator` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds@latest add karim-bhalwani/orchestrator`
- Raw SKILL.md: https://api.skillmd.com/api/skills/karim-bhalwani/orchestrator/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: karim-bhalwani (https://skillmd.com/u/karim-bhalwani)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/karim-bhalwani/orchestrator

---


# Orchestrator Skill - Project Governance & Context Management

## Overview

The Orchestrator skill acts as the project's "Knowledge Keeper." It ensures that every action taken by other skills aligns with the project's technology stack, architecture styles, and critical rules.

## Core Responsibilities

### 1. Tiered Context Management

- **Tier 1 (Constant)**: Ensure tech stack, OS platform, and critical security rules are always top-of-mind.
- **Tier 2 (Task-Specific)**: Load domain context (e.g., API patterns for web tasks, schemas for data tasks) only when needed to save tokens.
- **Tier 3 (Historical)**: Reference `decisions.md` to understand *why* certain patterns were established.

### 2. Constraint Validation

- **Authority**: Maintain the "Approved Libraries" list.
- **Guardrail**: Block any implementation that violates project-wide "Non-Negotiables" (e.g., "No raw SQL", "Mandatory Pydantic validation").
- **Escalation**: Identify when a specialist's request conflicts with existing documentation.

### 3. Skill Coordination

- Analyze a task and determine the sequence of skills required (e.g., `navigator` -> `architect` -> `implementer` -> `guardian`).
- Manage handoffs between skills, ensuring the output of one serves as a clean input for the next.

## Output Format: Tiered Context Block

When preparing a task, the Orchestrator should output:

- **Project Pillars**: Core tech and architecture.
- **Hard Constraints**: Non-negotiable rules for this specific task.
- **Handoff Map**: Sequence of skills to be invoked.

## When to Use

- When first joining a project.
- To clarify "how we do things here."
- To validate if a new library or pattern is allowed.
- To plan the multi-step execution of a complex feature.

## Constraints

- **NO implementation.** Only governs and validates.
- **NO writing source code.**
- **DO NOT invent context.** If rules aren't documented, explicitly state the gap.

## Outputs & Deliverables

- **Primary Output**: Tiered context block (Tier 1/2/3), handoff map, and skill routing recommendations
- **Secondary Output**: Constraint validation report identifying conflicts or gaps
- **Success Criteria**: All team members agree on the handoff sequence and context requirements
- **Quality Gate**: Approved by project owner or lead before skill delegation begins

## Common Pitfalls

- **Inventing Constraints**: "I assume we use TypeScript" when it's undocumented. If rules aren't documented, explicitly state the gap.
- **Over-Constraining**: Blocking everything with "team standards" that don't exist yet. Only enforce documented rules.
- **Poor Handoff Maps**: Routing tasks to the wrong skill because you didn't understand the requirement. Always think through skill dependencies.
- **Missing Context Tiers**: Throwing everything at an agent at once instead of tiering (Tier 1: always, Tier 2: on demand, Tier 3: history).
- **Ignoring New Patterns**: Not updating constraints when the codebase evolves. Review and refresh quarterly.
- **Conflict Blindness**: Not catching when a new requirement contradicts existing documented rules. Always cross-reference.

## Integration Points

| Phase | Input From | Output To | Context |
|-------|-----------|-----------|---------|
| Project Onboarding | Project README, existing rules | Context setup | Create initial Tiered Context Block |
| Task Routing | Task request + project context | Skill coordination | Map required skill sequence |
| Constraint Validation | New implementation requests | Approval/Feedback | Verify against documented standards |
| Context Refresh | Evolution of codebase | Updated `project-context.md` | Keep context current as project matures |
| Conflict Resolution | Conflicting requirements | Escalation | Document discrepancies between old/new rules |