Permission Inheritance Prompt for Sub-Agent Delegation

This prompt is for engineering teams building hierarchical agent systems where a parent agent must delegate work to specialized sub-agents. The core problem it solves is defining a machine-readable permission inheritance specification that determines which scopes transfer from parent to child, which are stripped, and how the sub-agent validates its authority before executing a task. Use this when you need a structured delegation contract that can be injected into a sub-agent's system prompt or consumed by an orchestration layer to enforce scope boundaries programmatically. The ideal user is an AI architect or platform engineer who already has a multi-agent topology and needs to prevent privilege escalation, scope creep, or unauthorized tool access during delegation.

This prompt is not appropriate for single-agent permission declarations or flat tool allowlists. If you are defining what a single agent can access without delegation, use the Agent Tool Permission Boundary System Prompt instead. If you are building an allowlist for MCP server integration, use the Tool Allowlist Declaration Prompt for MCP Servers. This prompt specifically addresses the inheritance problem: when Agent A delegates to Agent B, what permissions survive the transfer, which require re-validation, and how Agent B confirms its effective scope before acting. The output is a permission inheritance specification, not a general role definition or a tool catalog. It should be used alongside your existing role-based access control manifests and tool permission declarations.

Before using this prompt, ensure you have already defined the parent agent's full permission scope and the sub-agent's intended role. The prompt requires these as inputs to produce an inheritance map. Do not use this prompt to design the permission system from scratch; it assumes you have existing permission boundaries and need to formalize how they propagate across delegation boundaries. After generating the inheritance specification, wire it into your orchestration layer so that sub-agent invocations are gated by the declared scope. For high-risk domains such as finance or healthcare, always include human review of the generated inheritance rules and run adversarial test cases from the Permission Scope Simulation Prompt for Testing to validate that sub-agents cannot escalate privileges through handoff or re-delegation.

This prompt template is designed to be pasted into your orchestration layer or sub-agent system prompt assembly. It instructs a parent agent to produce a structured permission inheritance specification before delegating a task to a sub-agent. The specification acts as a contract, preventing privilege escalation and ensuring the sub-agent operates strictly within its intended scope. Replace every square-bracket placeholder with your specific permission model, tool definitions, and delegation policies before use.

textCopy
You are a permission inheritance compiler for a hierarchical agent system. Your task is to produce a strict permission inheritance specification for a sub-agent before task delegation.

## Parent Agent Scope
[PARENT_PERMISSION_MANIFEST]

## Sub-Agent Role Definition
[SUB_AGENT_ROLE_DEFINITION]

## Task to Delegate
[TASK_DESCRIPTION]

## Inheritance Rules
- [INHERITANCE_RULE_1: e.g., 'Read-only data access is inherited by default']
- [INHERITANCE_RULE_2: e.g., 'Write permissions are never inherited; sub-agent must request explicit grant']
- [INHERITANCE_RULE_3: e.g., 'User PII access is stripped unless the sub-agent role explicitly requires it']

## Output Schema
Produce a JSON object with the following structure:
{
  "sub_agent_id": "string",
  "inherited_permissions": [
    {
      "permission": "string",
      "scope": "string",
      "constraints": ["string"],
      "inherited_from": "string"
    }
  ],
  "stripped_permissions": [
    {
      "permission": "string",
      "reason_stripped": "string",
      "risk_if_inherited": "string"
    }
  ],
  "requires_revalidation": [
    {
      "permission": "string",
      "validation_method": "string",
      "failure_action": "string"
    }
  ],
  "effective_scope_statement": "string"
}

## Constraints
- [CONSTRAINT_1: e.g., 'Never inherit permissions marked as "delegation-denied"']
- [CONSTRAINT_2: e.g., 'If the sub-agent role does not explicitly list a tool, it cannot be inherited']
- [CONSTRAINT_3: e.g., 'All inherited write permissions must be flagged for revalidation']

## Examples
### Example 1: Safe Delegation
Parent Scope: [EXAMPLE_PARENT_SCOPE]
Sub-Agent Role: [EXAMPLE_SUB_AGENT_ROLE]
Task: [EXAMPLE_TASK]
Expected Output: [EXAMPLE_EXPECTED_OUTPUT]

### Example 2: Blocked Delegation
Parent Scope: [EXAMPLE_PARENT_SCOPE_2]
Sub-Agent Role: [EXAMPLE_SUB_AGENT_ROLE_2]
Task: [EXAMPLE_TASK_2]
Expected Output: [EXAMPLE_EXPECTED_OUTPUT_2]

## Risk Level
[RISK_LEVEL: e.g., 'HIGH — sub-agent will have access to customer data']

Generate the permission inheritance specification now.

After pasting this template, adapt the inheritance rules to match your organization's security policy. The stripped_permissions array is your primary defense against privilege escalation; ensure every stripped permission includes a clear risk_if_inherited rationale for auditability. The requires_revalidation array should list any permission that the sub-agent must confirm with a human or a secondary system before first use. For high-risk deployments, route the generated specification through a human approval step before the sub-agent is instantiated. Test this prompt with adversarial task descriptions that attempt to trick the compiler into inheriting write or PII-access permissions.

The Permission Inheritance Prompt for Sub-Agent Delegation is not a standalone prompt—it is a specification generator that must be consumed by your agent orchestration layer before any sub-agent is spawned. The prompt's output is a structured permission manifest that your orchestrator reads to configure the sub-agent's tool allowlist, argument constraints, and data scope. Treat this manifest as a machine-readable contract: the orchestrator must enforce it, not just pass it as advisory text. The model that generated the manifest should never be the same instance that executes under it without an intermediate validation step.

Wire this prompt into your delegation pipeline as a synchronous pre-flight check. When a parent agent decides to delegate a task, call this prompt with the parent's current permission scope, the proposed sub-task description, and the target sub-agent role. Parse the output against a strict JSON schema that includes allowed_tools, argument_constraints, data_scope, denied_actions, and requires_human_approval. Validate that every tool in allowed_tools exists in your tool registry and that no denied_actions overlap with the parent's own deny list. If validation fails, abort delegation and log the conflict. For high-risk domains, insert a human approval step before the sub-agent is instantiated—the manifest should be reviewable in a dashboard or CLI before execution proceeds.

After validation, use the manifest to bootstrap the sub-agent's execution context. This means constructing the sub-agent's system prompt with the inherited permissions explicitly declared, configuring its tool gateway to reject calls outside the allowlist, and setting argument validators that enforce range limits and forbidden patterns from the manifest. Log the full permission inheritance chain—parent scope, inheritance rules applied, and resulting sub-agent scope—as an audit record. When the sub-agent completes its task, do not automatically merge its results into the parent's context without re-validating that the sub-agent did not exceed its granted scope. The next step is to pair this prompt with the Agent Handoff Permission Transfer Prompt to manage context return and scope cleanup after delegation completes.