---
title: 'Give Your AI Agent Superpowers in .NET Aspire with One Command'
source: 'https://youtube.com/watch?v=0IWvu9Rl-8Q'
video_id: '0IWvu9Rl-8Q'
date: 2026-08-08
duration_sec: 179
---

# Give Your AI Agent Superpowers in .NET Aspire with One Command

> Source: [Give Your AI Agent Superpowers in .NET Aspire with One Command](https://youtube.com/watch?v=0IWvu9Rl-8Q)

## Summary

This video demonstrates how to add AI agent capabilities to .NET Aspire applications using a single command, 'Aspire agent init'. It shows how this command installs Aspire skills and an MCP server, enabling GitHub Copilot to interact with Aspire resources, analyze telemetry, and modify application code.

### Key Points

- **Baseline Aspire Application** [00:01] — The video starts with a baseline Aspire application containing an app host, an API service, and a web UI. Running it with 'Aspire run' launches the Aspire dashboard showing the services and their resource graph.
- **Aspire Agent Init Command** [00:16] — Running 'Aspire agent init' installs Aspire skills for AI agents and optionally sets up the Aspire MCP server. The video selects the GitHub Copilot option, which automatically detects the agent environment and configures it.
- **Installed Skills and MCP Server** [00:44] — After initialization, a list of installed skills and their locations is shown. VS Code is configured to use the Aspire MCP server and GitHub Copilot CLI. A new '.agents' folder appears with skill files.
- **Interacting with Aspire via Copilot** [01:11] — GitHub Copilot can be prompted to start the Aspire application and show resource status. It reads the Aspire skills and uses the MCP server to execute the correct CLI commands, printing the requested details.
- **Analyzing HTTP Request Performance** [01:38] — Copilot can analyze HTTP request performance for the API by finding the relevant skill to hook into logs and telemetry data. It lists traces and structured logs, producing a report of request durations.
- **Adding New Resources via Copilot** [02:04] — Copilot can introduce new resources to the app host, such as adding a Redis cache. It uses the Aspire CLI to make changes, and the diff shows it added a cache resource and connected it to the API service, plus added the Redis client in the API's program file.
- **Further Exploration** [02:35] — The video notes this is just scratching the surface. A link is provided to a talk by Maddie and David Fowler about using agents in more detail.

## Transcript

superpowers to your Aspire applications using AI agents. I've got a baseline Aspire application here with an app host and API service and a web application for the UI. If we go ahead and run this using Aspire run, you should see the
Aspire dashboard start up with your two services, their respective resource graph, and then we can go ahead and use our application. Now, where this becomes interesting is when you run the command Aspire agent init, it's going to do a
couple of things. The first one is it's going to install Aspire skills for your AI agent. I'm going to choose the first option because it works with GitHub Copilot, which is what I will be using to run my agents. One more important
option is installing the Aspire MCP server. It's going to automatically detect my agent environment and set this up to work with GitHub Copilot. After this completes, we should see a list of skills that were installed and the
location where they were added. VS Code is also configured to use the Aspire MCP server as well as the GitHub Copilot CLI. If I take a look at the File Explorer again, there's this new .agents folder with a bunch of skill files
inside, and now we can start to do some very interesting things with this. For example, we can give GitHub Copilot a prompt telling it to start the Aspire application and show us the resource status. This is going to start the MCP
server and read the Aspire skills that we have in the repo. Now it knows which Aspire CLI commands to use so it can achieve the desired result. And it prints out the details that we were looking for. Then I can ask it to
analyze the HTTP request performance for my API. And what's interesting here is that it can find the respective skill to hook into the logs and in general
telemetry data for our Aspire resources. I'm going to let it list the traces for the API as well as the structured logs, and it's going to give us a report of some request duration for our API instance. Another interesting thing that
you can do is ask it to introduce other resources to your app host. For example, I can ask it to add a Redis cache to my Aspire app host. And it knows to use the Aspire CLI to achieve this. We can take
a look at the diff and see which changes it made to our application code. In the app host, it's added a cache resource and connected it to our API service. And in the program file of the API, it added the Redis client so that we can use it
for caching later on. And we are just scratching the surface here what is possible with the Aspire agent integration using GitHub Copilot. If you want to see another very interesting example, I'm going to leave a link in
the pinned comment and the description to a talk from Maddie and David Fowler talking about using agents in a lot more detail. And I'm sure you're going to detail. And I'm sure you're going to find it really valuable.