What Are the Four Tiers of AI Artifacts in HVE Core’s Architecture?

HVE Core organizes every Copilot customization into a four-tier artifact system—Prompts, Agents, Instructions, and Skills—that creates a hierarchical delegation chain from high-level user intent down to concrete executable utilities.

The microsoft/hve-core repository implements a strict separation of concerns for AI-driven development workflows. By dividing responsibilities across four distinct tiers of AI artifacts, the architecture enables teams to reuse components, enforce standards automatically, and maintain clear hand-off paths between user requests and tool execution.

The Four Tiers of AI Artifacts

According to the architecture documentation in docs/architecture/ai-artifacts.md, HVE Core categorizes every AI artifact into one of four hierarchical tiers. Each tier serves a specific role in the delegation chain.

1. Prompts: Workflow Entry Points

Prompts capture user intent and serve as the primary interface between developers and the AI system. These files define inputs and outputs using ${input:varName} syntax and reference specific agents in their front-matter to delegate execution.

In docs/architecture/ai-artifacts.md (lines 16-24), prompts are described as the entry point that "hand-off to an agent." They use YAML front-matter to specify which agent should handle the request.

---
description: 'Protocol for creating ADO pull requests'
agent: Task Planner          # ↳ points to a .agent.md file

---

This example from lines 28-33 of the architecture guide shows how a prompt file references the Task Planner agent to handle the workflow.

2. Agents: Task Orchestrators

Agents act as orchestrators that determine how a task should be performed. They declare available tools, specify hand-offs to other agents, and maintain conversation context throughout the execution cycle.

The architecture documentation (lines 37-46) defines agents as the layer that implements task orchestration logic. Agents can transfer control to other agents using structured hand-off configurations.

---
description: 'Orchestrates task planning with research integration'
tools: ['codebase', 'search', 'editFiles', 'changes']
handoffs:
  - label: "⚡ Implement"
    agent: Task Implementor
    prompt: /task-implement
    send: true
---

This agent definition from lines 50-57 demonstrates how an agent declares its toolset and configures hand-offs to specialized implementors.

3. Instructions: Technology Standards

Instructions represent technology-specific standards that apply automatically to matching files. Unlike prompts and agents, instructions use applyTo: glob patterns to enforce coding conventions without explicit invocation.

As documented in docs/architecture/ai-artifacts.md (lines 68-78), instructions provide "standards that are applied automatically" based on file patterns.

---
description: 'Python scripting standards with type hints'
applyTo: '**/*.py, **/*.ipynb'   # ↳ auto‑applied to matching files

---

This instruction from lines 81-85 automatically enforces Python standards on all .py and .ipynb files in the repository.

4. Skills: Executable Utilities

Skills are concrete, executable utilities that agents invoke for specialized work. Each skill contains executable scripts (.sh, .ps1, etc.) alongside a SKILL.md file describing the utility's interface and requirements.

According to lines 97-106 of the architecture documentation, skills function as the final tier in the delegation chain, providing "executable utilities that agents can invoke."

---
name: video-to-gif
description: 'Video‑to‑GIF conversion with FFmpeg optimization'
---

This skill front-matter from lines 121-126 identifies a reusable video conversion utility that agents can call when processing media files.

The Delegation Flow Across Tiers

The four tiers of AI artifacts in HVE Core form a strict hierarchical delegation flow. As illustrated in docs/architecture/ai-artifacts.md (lines 52-58), the execution chain follows this path:

User → Prompt → Agent → (Instructions + Skills)

This structure ensures that:

• Users interact only with high-level prompts
• Prompts delegate to appropriate agents
• Agents leverage instructions for context and skills for execution
• Instructions apply automatically based on file type
• Skills perform concrete utility work

Source File Locations

The microsoft/hve-core repository contains representative implementations of each tier:

• Prompt: .github/prompts/hve-core/task-plan.prompt.md — Initiates planning workflows
• Agent: .github/agents/hve-core/rpi-agent.agent.md — Coordinates research, planning, and implementation
• Instruction: .github/instructions/hve-core/python.instructions.md — Enforces Python standards via applyTo: patterns
• Skill: .github/skills/hve-core/video-to-gif/SKILL.md — Provides video conversion utilities

Summary

• Prompts serve as workflow entry points that capture user intent and reference specific agents for execution.
• Agents orchestrate task performance by selecting tools and delegating to other agents through structured hand-offs.
• Instructions automatically enforce technology-specific standards on matching files using glob patterns.
• Skills deliver executable utilities that agents invoke for specialized, concrete operations.

Frequently Asked Questions

How do the four tiers of AI artifacts interact in HVE Core?

The tiers form a hierarchical delegation chain. Users trigger Prompts, which reference Agents to handle orchestration. Agents then utilize Instructions for context-aware standards and invoke Skills to execute concrete utilities. This flow is explicitly defined in docs/architecture/ai-artifacts.md (lines 52-58).

What distinguishes Instructions from Skills in HVE Core's architecture?

Instructions apply automatically to files matching glob patterns (e.g., **/*.py) and provide contextual standards, while Skills are explicit utilities that agents must invoke to perform actions like file conversion or data processing. Instructions shape behavior; Skills perform operations.

Where are the four tiers of AI artifacts stored in the HVE Core repository?

Prompts reside in .github/prompts/, Agents in .github/agents/, Instructions in .github/instructions/, and Skills in .github/skills/. Each tier follows specific naming conventions (e.g., .prompt.md, .agent.md, .instructions.md, and SKILL.md) as implemented in the microsoft/hve-core codebase.

Can Agents in HVE Core hand off to other Agents?

Yes. Agents declare handoffs in their front-matter to transfer control to specialized agents. For example, a "Task Planner" agent can hand off to a "Task Implementor" agent using the handoffs configuration array, as shown in docs/architecture/ai-artifacts.md (lines 50-57).

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}