delegate-handoff

Define delegate() call parameters for spawning child agents with inherited context.

97|5|Updated Apr 23, 2026
One-click install
npx skills add https://github.com/friday-platform/friday-studio --skill delegate-handoff
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: delegate-handoff
Source: https://github.com/friday-platform/friday-studio/tree/main/packages/system/skills/delegate-handoff
Command: npx skills add https://github.com/friday-platform/friday-studio --skill delegate-handoff

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

When you use the delegate() function to spawn a child agent for a sub-task, the child has no access to your available skills index, load_skill tool, or parent chat history, leading to context-blind execution, wasted tool calls, and incorrect or incomplete results. This skill provides the official contract to avoid those pitfalls.

Core Features & Use Cases

  • Full Context Inheritance Guide: Clearly documents what context the child agent inherits from the parent (tools, datetime grounding, pushed skills) and what it does not (skill catalog, chat history, workspace context) to set accurate expectations.
  • Delegate Configuration Best Practices: Covers how to push relevant skills and surgical reference files to the child, set MCP server allowlists to scope access, configure budget envelopes (max steps, output tokens, delegation depth), and write effective handoff prompts with time anchors and output specifications.
  • Decision Framework for Delegation: Provides clear criteria for when to delegate a sub-task versus calling a tool inline, preventing unnecessary delegation of simple one-off tasks.
  • Return Contract Specification: Defines the standard {ok, answer | reason, toolsUsed} return envelope for child agent results to ensure consistent observability and error handling.
  • Use Case Example: For a task like finding stale GitHub issues across multiple repositories, use this skill to push the GitHub MCP server and relevant GitHub skill to the child, specify the date cutoff and output JSON schema in the handoff, and set a max step budget to avoid runaway execution.

Quick Start

Use the delegate-handoff skill to configure a delegate() call for a sub-task that requires searching multiple GitHub repositories for stale issues, ensuring the child agent has the necessary GitHub MCP access and context to return structured results.

Frequently Asked Questions about delegate-handoff

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
Why does my child agent return incomplete results when I use the delegate function for workflow automation?

Child agent delegation fails because the child lacks your available skills index, load_skill tool, and parent chat history. This context-blind execution causes wasted tool calls and incorrect outputs. You must explicitly push required skills and context to the child agent.

How do I configure MCP server access when spawning a child agent for a sub-task?

To configure MCP server access for child agent orchestration, you must set an MCP server allowlist in the delegate call. This scoping restricts the child's tool access to explicitly permitted servers, ensuring predictable and isolated execution.

What context does a child agent inherit from the parent during task delegation?

A spawned child agent inherits tools, datetime grounding, and pushed skills from the parent. It does not inherit the skill catalog, parent chat history, or workspace context, requiring you to manually push reference files for accurate execution.

When should I delegate a sub-task to a child agent versus calling a tool inline?

Delegate to a child agent for complex, bounded sub-tasks like cross-repository research or data aggregation requiring isolated tool access. Use inline tool calls for simple one-off tasks to avoid unnecessary delegation overhead and runaway execution budgets.

How do I enforce a return contract for child agent results in agent orchestration?

Enforce child agent return contracts by specifying the standard {ok, answer | reason, toolsUsed} return envelope. This configuration ensures consistent observability and structured error handling for the parent agent consuming the delegated output.

How do I set budget envelopes for child agents to prevent infinite delegation nesting?

Prevent infinite delegation nesting by configuring budget envelopes in the delegate call. Specify max steps, output tokens, and delegation depth limits to constrain the child agent's execution scope and avoid runaway tool usage during complex sub-tasks.