package-agent

name	package-agent
description	Generate a complete OAF-compliant agent package from an Agent Case (requirements) and Agent Design (architecture). Use when asked to "package an agent", "generate an agent package", "create an agent from a design", or when you have both case/ and design/ folders and need to create the package/ folder with AGENTS.md, skills, and scripts.

Package Agent

Generate a complete Open Agent Format (OAF) package from an Agent Case and Agent Design.

Workflow

1. Read inputs - Load the case/README.md and design/README.md
2. Generate AGENTS.md - Create the main agent manifest
3. Generate skills - Create SKILL.md and resources for each skill in the design
4. Generate scripts - Create Python script stubs for each script in the design
5. Verify structure - Ensure all files are created correctly

Step 1: Read Inputs

The user will provide paths to:

• case/README.md - Agent Case with Description, Example Session, Deliverables
• design/README.md - Agent Design with sub-agents, skills, scripts, MCPs, memory, tools

Read both files to understand what to generate.

Step 2: Generate AGENTS.md

Create package/AGENTS.md with this structure:

---
name: [from design identity]
slug: [from design identity]
version: [from design identity]
description: [from design identity]
tags: [from design identity]
license: MIT
---

# [Agent Name]

[Architecture overview paragraph from design section 2]

## Sub-Agents

[For each sub-agent in design section 3, create a subsection:]

### [sub-agent-name]

**Role:** [role from design]
**Tools:** [tools list]

Tasks:
- [delegated task 1]
- [delegated task 2]

## Skills

This agent uses the following skills:

| Skill | Purpose |
|-------|---------|
| [skill-name] | [purpose from design] |

## MCP Servers

[For each MCP in design section 6:]

### [mcp-name]

- **Purpose:** [description]
- **Protocol:** [protocol]
- **Auth:** [auth type]
- **Tools:** [list enabled tools]

## Memory

| Label | Purpose | Retention |
|-------|---------|-----------|
| [label] | [purpose] | [retention] |

## Tools

**Allowed:** [list from design]
**Denied:** [list from design]

## Error Handling

| Failure | Detection | Recovery |
|---------|-----------|----------|
[from design section 10]

Step 3: Generate Skills

For each skill in design section 4, create:

package/skills/[skill-name]/
├── SKILL.md
├── resources/
│   └── [any templates mentioned]
└── scripts/
    └── [any scripts assigned to this skill]

SKILL.md Template

---
name: [skill-name]
description: [purpose from design]. Triggers when [infer trigger from purpose].
---

# [Skill Name]

## Overview

[Expand on purpose - what knowledge/procedures this skill provides]

## Usage

[Describe when and how the agent uses this skill]

## Resources

[List any files in resources/ and what they contain]

## Scripts

[List any scripts and their purpose]

Resource Files

Create stub resource files based on what the design mentions:

• For templates: Create a markdown file with placeholder structure
• For reference docs: Create a markdown file with section headers

Step 4: Generate Scripts

For each script in design section 5:

1. Determine which skill folder it belongs to (from the path in design)
2. Create the Python script with:
   • Docstring explaining purpose, inputs, outputs
   • Function signature matching the design
   • Basic implementation structure with TODOs
   • Dependencies noted in requirements comment

Script Template

#!/usr/bin/env python3
"""
[Script name] - [purpose from design]

Inputs:
  [list inputs from design]

Outputs:
  [list outputs from design]

Dependencies:
  [list from design]
"""

# Requirements: [dependencies]

import json
from typing import Any


def main([parameters from design inputs]) -> dict[str, Any]:
    """
    [Purpose from design]

    Args:
        [param]: [description inferred from design]

    Returns:
        dict with keys: [output keys from design]
    """
    # TODO: Implement [purpose]

    return {
        # [output structure from design]
    }


if __name__ == "__main__":
    import sys
    # TODO: Parse command line args
    result = main()
    print(json.dumps(result, indent=2))

Step 5: Verify Structure

After generating all files, verify the package structure:

package/
├── AGENTS.md              # Main agent manifest
└── skills/
    ├── [skill-1]/
    │   ├── SKILL.md
    │   ├── resources/
    │   │   └── [templates/docs]
    │   └── scripts/
    │       └── [any scripts]
    ├── [skill-2]/
    │   └── ...
    └── ...

Print a summary of what was created.

Example Invocation

User: Package the travel research agent. The case is in examples/travel-research/case/ and design is in examples/travel-research/design/

Claude: [Reads both files, then creates:]
- examples/travel-research/package/AGENTS.md
- examples/travel-research/package/skills/travel-planning/SKILL.md
- examples/travel-research/package/skills/travel-planning/resources/itinerary-template.md
- examples/travel-research/package/skills/travel-planning/scripts/budget-calculator.py
- [etc.]

References

• See references/oaf-structure.md for detailed OAF package format
• See references/agents-md-schema.md for AGENTS.md field reference