delegation-core
npx machina-cli add skill athola/claude-night-market/delegation-core --openclawTable of Contents
- Overview
- When to Use
- Philosophy
- Delegation Flow
- Quick Decision Matrix
- Detailed Workflow Steps
- 1. Task Assessment (
delegation-core:task-assessed) - 2. Suitability Evaluation (
delegation-core:delegation-suitability) - 3. Handoff Planning (
delegation-core:handoff-planned) - 4. Execution & Integration (
delegation-core:results-integrated) - Leyline Infrastructure
- Service-Specific Skills
- Module Reference
- Exit Criteria
Delegation Core Framework
Overview
A method for deciding when and how to delegate tasks to external LLM services. Core principle: delegate execution, retain high-level reasoning.
When To Use
- Before invoking external LLMs for task assistance.
- When operations are token-heavy and exceed local context limits.
- When batch processing benefits from different model characteristics.
- When tasks require routing between models.
When NOT To Use
- Task requires reasoning by Claude
Philosophy
Delegate execution, retain reasoning. Claude handles architecture, strategy, design, and review. External LLMs perform data processing, pattern extraction, bulk operations, and summarization.
Delegation Flow
- Task Assessment: Classify task by complexity and context size.
- Suitability Evaluation: Check prerequisites and service fit.
- Handoff Planning: Formulate request and document plan.
- Execution & Integration: Run delegation, validate, and integrate results.
Quick Decision Matrix
| Complexity | Context | Recommendation |
|---|---|---|
| High | Any | Keep local |
| Low | Large | Delegate |
| Low | Small | Either |
High Complexity: Architecture, design decisions, trade-offs, creative problem solving.
Low Complexity: Pattern counting, bulk extraction, boilerplate generation, summarization.
Detailed Workflow Steps
1. Task Assessment (delegation-core:task-assessed)
Classify the task:
- See
modules/task-assessment.mdfor classification criteria. - Use token estimates to determine thresholds.
- Apply the decision matrix.
Exit Criteria: Task classified with complexity level, context size, and delegation recommendation.
2. Suitability Evaluation (delegation-core:delegation-suitability)
Verify prerequisites:
- See
modules/handoff-patterns.mdfor checklist. - Evaluate cost-benefit ratio using
modules/cost-estimation.md. - Check for red flags (security, real-time iteration).
Exit Criteria: Service authenticated, quotas verified, cost justified.
3. Handoff Planning (delegation-core:handoff-planned)
Create a delegation plan:
- See
modules/handoff-patterns.mdfor request template. - Document service, command, input context, expected output.
- Define validation method.
Exit Criteria: Delegation plan documented.
4. Execution & Integration (delegation-core:results-integrated)
Execute and validate results:
- Run delegation and capture output.
- Validate format and correctness.
- Integrate only after validation passes.
- Log usage.
Exit Criteria: Results validated and integrated, usage logged.
MCP Authentication
OAuth Client Credentials (Claude Code 2.1.30+)
For MCP servers that don't support Dynamic Client Registration (e.g., Slack), pre-configured OAuth client credentials can be provided:
claude mcp add <server-name> --client-id <id> --client-secret <secret>
This enables delegation workflows through MCP servers that require pre-configured OAuth, expanding the range of external services available for task delegation.
Claude.ai MCP Connectors (Claude Code 2.1.46+)
As an alternative to manual OAuth setup, users can configure MCP servers directly in claude.ai at claude.ai/settings/connectors. These connectors are automatically available in Claude Code when logged in with a claude.ai account — no claude mcp add or credential management required. This provides a browser-based auth flow that may be simpler for services with complex OAuth requirements.
Worktree Isolation for File-Modifying Delegations (Claude Code 2.1.49+)
When delegating tasks that modify files to subagents, use isolation: worktree in the agent frontmatter to run each agent in a temporary git worktree. This prevents file conflicts when multiple delegated agents operate in parallel on overlapping paths. The worktree is auto-cleaned if no changes are made; preserved with commits if the agent produces changes.
# Agent frontmatter for isolated delegation
isolation: worktree
Leyline Infrastructure
Conjure uses leyline infrastructure:
| Leyline Skill | Used For |
|---|---|
quota-management | Track service quotas and thresholds. |
usage-logging | Session-aware audit trails. |
service-registry | Unified service configuration. |
error-patterns | Consistent error handling. |
authentication-patterns | Auth verification. |
See modules/cost-estimation.md for leyline integration examples.
Service-Specific Skills
For detailed service workflows:
Skill(conjure:gemini-delegation): Gemini CLI specifics.Skill(conjure:qwen-delegation): Qwen MCP specifics.
Module Reference
- task-assessment.md: Complexity classification, decision matrix.
- cost-estimation.md: Pricing, budgets, cost tracking.
- handoff-patterns.md: Request templates, workflows.
- troubleshooting.md: Common problems, service failures.
Exit Criteria
- Task assessed and classified.
- Delegation decision justified.
- Results validated before integration.
- Lessons captured.
Source
git clone https://github.com/athola/claude-night-market/blob/master/plugins/conjure/skills/delegation-core/SKILL.mdView on GitHub Overview
Delegation Core Framework enables delegating execution to external LLM services such as Gemini and Qwen while keeping high-level reasoning in-house. It integrates quota-management and usage-logging, plus error handling, to manage cost, traceability, and reliability. Use it for token-heavy tasks that exceed local context or when cheaper processing is desirable; avoid it when Claude must perform core reasoning.
How This Skill Works
Tasks are first assessed for complexity and context size, then prerequisites and model fit are evaluated. A handoff plan is generated and executed via delegation-executor against the chosen external LLMs, with results validated and integrated back into the workflow. Errors are captured using predefined error patterns and logged for auditing and retry decisions.
When to Use It
- Before invoking external LLMs for task assistance, to route tasks appropriately.
- For token-heavy operations that exceed local context limits and need external processing.
- When batch processing benefits from different model characteristics (Gemini, Qwen).
- When you need to route tasks between models depending on capability or price.
- When quota-management and usage-logging are required to control costs and trace activity.
Quick Start
- Step 1: Assess the task using delegation-core:task-assessed to classify complexity and context.
- Step 2: Evaluate suitability and plan a handoff with delegation-core:delegation-suitability and delegation-core:handoff-planned.
- Step 3: Execute via delegation-executor, then validate, log, and integrate results.
Best Practices
- Define task boundaries clearly before delegation (inputs, outputs, success criteria).
- Estimate context size and cost with modules/task-assessment & cost-estimation.
- Configure quota-management to cap external-LLM usage and prevent overruns.
- Validate external results against expected schema and quality checks.
- Implement robust error handling patterns and structured retries.
Example Use Cases
- Chunk a long document and delegate summarization to Qwen to fit within the context window.
- Delegate data extraction from large logs to Gemini for speed and cost efficiency.
- Route pattern-counting tasks to different models to optimize accuracy and latency.
- Use delegation-core for bulk translation tasks where external models excel.
- Integrate external results into a Claude-driven control plane with validated outputs.
