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

> Explore HVE Core's architecture and understand the four tiers of AI artifacts: Prompts, Agents, Instructions, and Skills. Learn how they form a delegation chain for Copilot customization.

- Repository: [Microsoft/hve-core](https://github.com/microsoft/hve-core)
- Tags: architecture
- Published: 2026-03-09

---

**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`](https://github.com/microsoft/hve-core/blob/main/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`](https://github.com/microsoft/hve-core/blob/main/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.

```yaml
---
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.

```yaml
---
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`](https://github.com/microsoft/hve-core/blob/main/docs/architecture/ai-artifacts.md) (lines 68-78), instructions provide "standards that are applied automatically" based on file patterns.

```yaml
---
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`](https://github.com/microsoft/hve-core/blob/main/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."

```yaml
---
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`](https://github.com/microsoft/hve-core/blob/main/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`](https://github.com/microsoft/hve-core/blob/main/.github/prompts/hve-core/task-plan.prompt.md) — Initiates planning workflows
- **Agent**: [`.github/agents/hve-core/rpi-agent.agent.md`](https://github.com/microsoft/hve-core/blob/main/.github/agents/hve-core/rpi-agent.agent.md) — Coordinates research, planning, and implementation
- **Instruction**: [`.github/instructions/hve-core/python.instructions.md`](https://github.com/microsoft/hve-core/blob/main/.github/instructions/hve-core/python.instructions.md) — Enforces Python standards via `applyTo:` patterns
- **Skill**: [`.github/skills/hve-core/video-to-gif/SKILL.md`](https://github.com/microsoft/hve-core/blob/main/.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`](https://github.com/microsoft/hve-core/blob/main/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`](https://github.com/microsoft/hve-core/blob/main/.prompt.md), [`.agent.md`](https://github.com/microsoft/hve-core/blob/main/.agent.md), [`.instructions.md`](https://github.com/microsoft/hve-core/blob/main/.instructions.md), and [`SKILL.md`](https://github.com/microsoft/hve-core/blob/main/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`](https://github.com/microsoft/hve-core/blob/main/docs/architecture/ai-artifacts.md) (lines 50-57).