Solutions · AI agents · Templates

Eighteen agents ready to ship.

Most agentic frameworks hand you a model and a prompt loop, then let you discover the rest. LM-Kit.NET ships 18 specialized agent templates with calibrated system prompts, sensible defaults, and typed configuration enums. Pick a template, set a model, run. Customize by overriding what you need.

Start building free API reference

18 templates Typed configuration Customizable

Less prompt engineering

Calibrated system prompts and tool sets shipped with the SDK. Stop reinventing them.

Less glue code

Templates inherit from AgentBuilder. Override what you need; everything else stays.

Same model, many roles

Spin up a research agent, a reviewer, and a code agent against one resident model.

Why pre-built templates

Skip the blank-page tax.

Building an agent from scratch means choosing a planning strategy, writing a system prompt, picking tools, calibrating temperature, deciding how to format output. Every team rediscovers the same defaults. Templates encode them once.

Calibrated prompts

Each template's system prompt is tuned for the task. ResearchAgentTemplate knows how to cite. DebuggerAgentTemplate knows how to reproduce. ReviewerAgentTemplate knows how to flag risk severity.

Typed customization

Templates expose enums like WritingTone, SummaryStyle, ReviewSeverity, CodeStyle, FormalityLevel. Configure intent without editing prompts.

Composable

Every template returns a standard Agent. Plug it into a PipelineOrchestrator, give it tools, attach memory. Templates are starting points, not walled gardens.

Local first

Templates run on whatever model you load. No vendor lock-in to a specific cloud, no API key required. Bring your own GGUF.

Versioned

Templates evolve with the SDK. When prompt research advances, your agents inherit the upgrade by bumping a NuGet version.

Deterministic shape

Templates pair with grammar-constrained generation when needed. Get JSON, schemas, or structured fields out of an extractor without parsing prose.

The catalog

Eighteen specialised agents.

Every template inherits from AgentBuilder and lives under LMKit.Agents.Templates. Below is the full catalog grouped by what each one is built to do.

Conversation & assistance

ChatAgent

Open-ended chat

General-purpose conversational agent. Tunable via WritingTone and FormalityLevel. The default starting point when you do not have a more specific need.

AssistantAgent

Task assistant

Goal-oriented assistant tuned for answering questions and completing concrete tasks. Pairs naturally with tools and memory.

QAAgent

Question answering

Direct, concise answers. Configurable via AnswerStyle and QAOutputFormat. Drop into RAG pipelines for grounded responses.

TutorAgent

Tutoring & explanation

Pedagogical agent that breaks concepts down for a target level. Configure with TutorLevel and TutorStyle.

Reasoning & planning

ReActAgent

Tool-using reasoning

Pre-wired with PlanningStrategy.ReAct. Iterates Thought, Action, Observation until the goal is met. Pair with web search, calculators, or custom tools.

PlannerAgent

Plan-and-execute

Breaks a goal into a structured plan, then executes it. Configurable via PlanningStyle. Useful when tasks have multiple stages.

ResearchAgent

Research & synthesis

Designed for multi-source research. ResearchDepth controls how thorough; ResearchOutputStyle controls how it's reported. Pairs with web search and document tools.

Code, content & review

CodeAgent

Code writing

Tuned for generating, refactoring and explaining code. Configurable via CodeStyle and ToolStrategy.

DebuggerAgent

Debugging

Reproduces, hypothesises, isolates. Configurable via DebugVerbosity and DebugContext. Made to be pointed at a stack trace and a snippet.

EditorAgent

Editing & rewriting

Polishes prose. Configurable via EditIntensity and EditType from light copyedit to substantive rewrite.

ReviewerAgent

Review & critique

Multi-perspective review with severity flagging. ReviewType, ReviewTone and ReviewSeverity shape the output. Drops into multi-agent review workflows.

Information processing

AnalystAgent

Analysis

Configurable analytical lens via AnalysisFormat. Pairs with the data tools in BuiltInTools.AddDataTools() for CSV, JSON, spreadsheets and databases.

ClassifierAgent

Classification

Pre-tuned for label assignment. ClassificationType selects taxonomy style; ClassificationOutputFormat selects shape (single label, multi-label, JSON).

ExtractorAgent

Structured extraction

Pulls fields from unstructured text. Configurable via ExtractionFormat and ExtractionType. Combines naturally with grammar-constrained generation.

SummarizerAgent

Summarisation

Configurable via SummaryStyle (executive, bullet, narrative) and SummaryLength. Built on top of the same engine as the standalone Summarizer.

TranslatorAgent

Translation

Domain-aware translation via TranslationDomain. Useful when general translation does not respect the terminology of legal, medical or technical text.

Specialised

ResponderAgent

Reply drafting

Drafts replies in a given ResponseStyle and FormalityLevel. Useful for inbox triage, support workflows, and ticket templates.

CreativeAgent

Creative writing

Tuned for narrative, marketing and exploratory writing. ContentType selects the form; WritingTone selects the voice.

Five-line agents

From `LM` to specialised agent.

Every template returns a fully configured Agent in a few lines. Same model, many roles, no system-prompt boilerplate.

FromTemplate.cs

using LMKit.Model;
using LMKit.Agents;
using LMKit.Agents.Templates;

// One resident model, several specialised agents.
var model = LM.LoadFromModelID("qwen3.5:4b");

// Researcher: cites sources, plans before writing.
var researcher = AgentTemplates
    .Research(model)
    .WithDepth(ResearchDepth.Thorough)
    .WithOutputStyle(ResearchOutputStyle.Briefing)
    .Build();

// Editor: tightens prose without rewriting voice.
var editor = AgentTemplates
    .Editor(model)
    .WithIntensity(EditIntensity.Light)
    .WithEditType(EditType.Copyedit)
    .Build();

// Reviewer: flags risk severity, neutral tone.
var reviewer = AgentTemplates
    .Reviewer(model)
    .WithReviewType(ReviewType.Technical)
    .WithSeverity(ReviewSeverity.Strict)
    .Build();

var draft  = await researcher.RunAsync("Summarise vector quantisation tradeoffs");
var tight  = await editor.RunAsync(draft.Content);
var notes  = await reviewer.RunAsync(tight.Content);

Templates compose

Snap them into orchestrators.

Templates produce regular Agent instances, so they slot straight into PipelineOrchestrator, ParallelOrchestrator, RouterOrchestrator, SupervisorOrchestrator, or the new GraphOrchestrator.

PipelineFromTemplates.cs

using LMKit.Agents;
using LMKit.Agents.Orchestration;
using LMKit.Agents.Templates;

var outline   = AgentTemplates.Planner(model).Build();
var writer    = AgentTemplates.Creative(model)
                          .WithTone(WritingTone.Confident)
                          .Build();
var editor    = AgentTemplates.Editor(model)
                          .WithIntensity(EditIntensity.Moderate)
                          .Build();

// Three-stage content pipeline. No glue, no orchestration scaffolding.
var pipeline = new PipelineOrchestrator(outline, writer, editor);

var result   = await pipeline.ExecuteAsync("Blog post: why local LLMs win on latency");
Console.WriteLine(result.FinalContent);

Versus the alternatives

Why ship pre-built agents at all?

LangChain

Provides primitives but no shipped templates. Every team writes their own system prompts, defines their own output formats, picks their own tools. Reinvention is the default.

Semantic Kernel

Plugins and planners exist, but agent personas are unopinionated. Specialised behaviours live in your prompt files, not in the SDK.

LM-Kit.NET

Eighteen calibrated templates with typed configuration. Inherit from AgentBuilder for full customisation. Calibration improves with each release.

Sample projects

Templates in the wild.

Demo Research assistant (ReAct) Demo Data analyst Demo Multi-agent document review Demo Email triage agent Guide Build reusable templates API AgentTemplates reference

Related capabilities

Pair with the rest of the agent stack.

Tools & function calling

Attach the 70+ built-in tools or custom ITool implementations to any template.

Tools page

Agent memory

Add persistent memory to a template so it remembers users and prior sessions.

Memory page

Multi-agent workflows

Compose templates into pipelines, parallel reviews, or supervised crews.

Orchestration page

Agent skills

Layer SKILL.md skills on top of a template for portable expertise that travels with the project.

Skills 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

Eighteen agents. One NuGet.

Get Community Edition Download