Solutions · AI Agents · Skills

Portable expertise for any AI agent.

Give agents modular, reusable capabilities using the open Agent Skills standard. Write a SKILL.md once and use it everywhere. Skills from Cursor, GitHub Copilot, and VS Code work out of the box with LM-Kit.NET.

Add skills to your agent Skills API

Open standard Progressive disclosure Hot reload

Adopted by: OpenAI Codex · Microsoft · GitHub · Cursor · VS Code · Figma · Atlassian

SKILL.md

---
name: code-reviewer
description: Review code for quality, security, and best practices
license: Apache-2.0
metadata:
  author: lm-kit
  version: "1.0"
  tags: [code, review, security]
---
# Code Review Skill
When reviewing code, follow these guidelines:
## Security
- Check OWASP Top 10 vulnerabilities
- Validate all input boundaries
## Quality
- Follow patterns in references/style-guide.md
- Verify error handling completeness

What are agent skills

Portable expertise for any agent.

Agent Skills are self-contained folders containing instructions, scripts, and resources that agents discover and load dynamically. Each skill is defined by a SKILL.md file with YAML frontmatter for metadata and Markdown for instructions. Skills can include reference files, templates, and scripts that agents use to perform specialized tasks.

Skills use progressive disclosure to keep context windows efficient. At startup, agents load only the skill name and description from the YAML frontmatter. Full Markdown instructions and associated resources load only when a skill activates, minimizing token usage across large registries.

LM-Kit.NET implements the agentskills.io specification, ensuring your skills are compatible across any platform that supports the standard. Write a SKILL.md once and use it everywhere.

YAML + Markdown format

Each skill is a SKILL.md file. YAML frontmatter holds metadata (name, description, tags). Markdown body contains the agent instructions.

Progressive disclosure

At startup, only skill name and description load. Full instructions and resources activate on demand, keeping context windows efficient.

Local or remote

Load skills from local directories, URLs, ZIP archives, or GitHub repositories. Fetch community skills and update them dynamically.

Hot reload

SkillWatcher monitors your skill directories. Edit a SKILL.md and changes reflect instantly without restarting the agent.

Lifecycle

How skills work.

The complete skill lifecycle, from discovery through hot-reload during development.

Class

SkillRegistry

Central registry for skill discovery, matching, and lifecycle management. Load from directories or remote URLs.

Class

SkillParser

Parse SKILL.md files with YAML frontmatter and Markdown instructions following the agentskills.io spec.

Class

SkillWatcher

Hot-reload skills during development. Changes to SKILL.md files are detected and reloaded automatically.

Class

SkillRemoteLoader

Load skills from URLs, ZIP archives, or GitHub repositories. Fetch community skills directly.

Code

Skills in action.

Load, build, and register skills with just a few lines of C#.

LoadSkills.cs

using LMKit.Agents.Skills;

// Load all SKILL.md files from a directory
var registry = new SkillRegistry();
registry.LoadFromDirectory("./skills");

// List available skills
foreach (var skill in registry.Skills)
{
    Console.WriteLine(
        $"{skill.Name}: {skill.Description}");
}

// Find a specific skill
var codeReview =
    registry.FindByName("code-reviewer");
Console.WriteLine($"Found: {codeReview.Name}");

BuildSkill.cs

using LMKit.Agents.Skills;

// Build a skill programmatically
var skill = new SkillBuilder()
    .WithName("api-tester")
    .WithDescription(
        "Test REST APIs and validate responses")
    .WithInstruction(@"
        When testing APIs:
        1. Validate request parameters
        2. Check response status codes
        3. Verify response body schema
    ")
    .WithResource("references/openapi-spec.json")
    .Build();

AgentWithSkills.cs

using LMKit.Model;
using LMKit.Agents;
using LMKit.Agents.Skills;

using LM model = LM.LoadFromModelID("qwen3.5:9b");

var registry = new SkillRegistry();
registry.LoadFromDirectory("./skills");

// Create agent with skills
var agent = Agent.CreateBuilder(model)
    .WithSkills(registry)
    .WithPlanning(PlanningStrategy.ReAct)
    .Build();

// Agent activates skills based on the task
var result = await agent.ExecuteAsync(
    "Review this pull request for security issues");
// Activates "code-reviewer" skill automatically

API reference

Key API classes.

The building blocks for skill-powered agents in LM-Kit.NET.

Class

AgentSkill

Modular capability with instructions, metadata, and optional resources.

Class

SkillActivator

Handles activation and context injection for conversations.

Class

SkillBuilder

Fluent builder for creating skills programmatically in code.

Class

SkillContext

Encapsulates activation info, user context, and available resources.

Class

SkillResource

Scripts, templates, and reference files loaded lazily on demand.

Class

SkillTool

ITool implementation exposing skills to models with progressive disclosure.

Browse the full Skills API reference →

Demos

Demo applications.

Explore ready-to-run examples that showcase Agent Skills in real scenarios.

Skills

Skill-based assistant

Load SKILL.md files, register skills with SkillRegistry, switch between Code Reviewer, Technical Writer, and Data Analyst skills at runtime.

Tools

Tool calling assistant

Dynamic function invocation with [LMFunction] attribute alongside skill-based capabilities.

Agent

Research assistant

Supervisor pattern using skills to define research methodologies and output formats.

Memory

Persistent memory assistant

Combine skills with persistent memory for long-running assistant workflows.

View documentation View on GitHub Agent Skills spec

How-to guides

Step-by-step tutorials.

Tutorials to get started with skills and agents.

GuideAdd skills to your AI assistant GuideCreate an AI agent with tools GuideBuild a function-calling agent GuideBuild a conversational assistant with memory GuideConnect to MCP servers GuideBuild a multi-agent workflow

Glossary

Key concepts.

Key concepts for understanding agent skills and orchestration.

TermAI agent skills TermAI agents TermAgent tools TermFunction calling TermAgent memory TermAgent planning TermPrompt engineering TermContext windows

Browse the full glossary →

Related capabilities

Skills plus the rest.

Agent templates

Layer skills on top of any of the 18 specialised templates. The template ships the persona; skills layer the expertise.

Templates page

Tools & function calling

Skills can declare allowed tools in their YAML frontmatter. Pair with the typed tool catalog and permission policies.

Tools page

Permissions & guardrails

Skills inherit the host agent's permission policy. Untrusted remote skills cannot escape the boundary you defined.

Permissions page

Agent delegation

Combine skills with delegation: a generalist supervisor delegates to a skill-equipped specialist for the right slice of work.

Delegation page

Demos & docs

Build it. Read it. Try it.

Working console demos on GitHub, step-by-step how-to guides on the docs site, and the API reference for the classes used on this page.

Demo

Skill-based assistant

Agent demo: agents loaded from SKILL.md files for specialisation.

Open on GitHub → How-to guide

Add skills to an assistant

How-to: write SKILL.md, load into an agent, swap skills at runtime.

Read the guide →

Install the SDK

Give your agents superpowers with skills.

Start building skill-powered agents today with LM-Kit.NET. Load community skills, create your own, and compose modular AI workflows.

Download View pricing