Solutions · AI Agents · Multi-Agent

Coordinate AI agents into production workflows.

Compose specialized agents into pipelines, parallel fan-outs, routers, and supervisor hierarchies. Each agent reasons independently while the orchestrator manages handoffs, aggregation, and convergence. All inference runs entirely on-device with full data privacy.

Build your first workflow API reference

4 orchestration patterns Shared model memory Built-in resilience

Pipeline

Chain agents in sequence. Each output becomes the next input.

Parallel

Run agents concurrently, then merge all results.

Router

Classify intent and dispatch to the best specialist.

Supervisor

Lead agent delegates, aggregates, and decides next steps.

Pipeline orchestration

User goal → Orchestrator → Agent A + Agent B → Result

Orchestration patterns

Four patterns. Every workflow.

Each pattern solves a different coordination challenge. Pick the one that matches your task shape, or combine them for complex multi-step workflows.

Pattern 01 · Pipeline

PipelineOrchestrator

Chain agents in strict sequence. Each agent's output automatically becomes the next agent's input. Ideal for tasks where each step builds on the previous result.

Content creation: research, write, then edit
Data pipelines: extract, transform, load
Document processing: parse, summarize, translate

API docs Demo How-to guide

Pipeline.cs

// Chain 3 agents: research -> write -> edit
var researcher = Agent.CreateBuilder(model)
    .WithName("Researcher")
    .WithSystemPrompt("Find key facts and data.")
    .Build();

var writer = Agent.CreateBuilder(model)
    .WithName("Writer")
    .WithSystemPrompt("Draft content from research.")
    .Build();

var editor = Agent.CreateBuilder(model)
    .WithName("Editor")
    .WithSystemPrompt("Polish and finalize.")
    .Build();

var pipeline = new PipelineOrchestrator(
    researcher, writer, editor);

var result = await pipeline.ProcessAsync(
    "Write a blog post about AI agents");

Parallel.cs

// 3 reviewers analyze concurrently
var techReviewer = Agent.CreateBuilder(model)
    .WithName("TechReviewer")
    .WithSystemPrompt("Evaluate technical accuracy.")
    .Build();

var bizReviewer = Agent.CreateBuilder(model)
    .WithName("BusinessReviewer")
    .WithSystemPrompt("Assess business impact.")
    .Build();

var secReviewer = Agent.CreateBuilder(model)
    .WithName("SecurityReviewer")
    .WithSystemPrompt("Check for security risks.")
    .Build();

var parallel = new ParallelOrchestrator(
    techReviewer, bizReviewer, secReviewer);

var results = await parallel.ProcessAsync(
    "Review this architecture proposal");

Pattern 02 · Parallel

ParallelOrchestrator

Run multiple agents concurrently and merge their results. Every agent sees the same input and works in parallel, reducing total latency to the slowest agent.

Multi-perspective document review
Ensemble analysis for higher accuracy
Concurrent data extraction from multiple sources

API docs Demo How-to guide

Pattern 03 · Router

RouterOrchestrator

Classify the user's intent and dispatch to the most appropriate specialist agent. Only one agent handles each request, keeping responses focused and efficient.

Helpdesk triage across specialist domains
Multi-model routing by task complexity
Cost optimization: small model for simple tasks, large model for complex

API docs Demo How-to guide

Router.cs

// Route to the best specialist
var codeHelper = Agent.CreateBuilder(model)
    .WithName("CodeHelper")
    .WithDescription("Handles coding questions.")
    .WithSystemPrompt("You are a coding expert.")
    .Build();

var dataAnalyst = Agent.CreateBuilder(model)
    .WithName("DataAnalyst")
    .WithDescription("Handles data analysis.")
    .WithSystemPrompt("You are a data analyst.")
    .Build();

var docWriter = Agent.CreateBuilder(model)
    .WithName("DocWriter")
    .WithDescription("Handles documentation.")
    .WithSystemPrompt("You are a technical writer.")
    .Build();

var router = new RouterOrchestrator(
    codeHelper, dataAnalyst, docWriter);

var result = await router.ProcessAsync(
    "Fix the null reference in line 42");

Supervisor.cs

// Supervisor delegates dynamically
var supervisor = new SupervisorOrchestrator(model);

supervisor.RegisterWorker(
    Agent.CreateBuilder(model)
        .WithName("Researcher")
        .WithDescription("Finds information.")
        .WithTools(t => t.Register(
            BuiltInTools.WebSearch))
        .Build());

supervisor.RegisterWorker(
    Agent.CreateBuilder(model)
        .WithName("Analyst")
        .WithDescription("Analyzes data.")
        .Build());

supervisor.RegisterWorker(
    Agent.CreateBuilder(model)
        .WithName("Writer")
        .WithDescription("Writes reports.")
        .Build());

var result = await supervisor.ProcessAsync(
    "Research and summarize AI trends");

Pattern 04 · Supervisor

SupervisorOrchestrator

A lead agent dynamically delegates tasks to workers, aggregates responses, and decides next steps. The supervisor reasons about which worker to call and when the task is complete.

Complex research with iterative sub-tasks
Project management with dynamic task allocation
Multi-step reasoning that adapts based on intermediate results

API docs Demo How-to guide

Which pattern?

Choose the right orchestration pattern.

Match your task shape to the correct pattern. When in doubt, start with Pipeline for sequential work or Parallel for independent analysis.

If your task needs...	Use	Example	Agents run
Steps executed in strict order, each building on the last	Pipeline	Research → Draft → Edit → Publish	Sequentially
Multiple independent perspectives on the same input	Parallel	Tech review + Legal review + Security audit	Concurrently
Intent classification to dispatch to the right specialist	Router	Helpdesk: billing vs. tech support vs. sales	One at a time
Dynamic delegation with a lead agent deciding next steps	Supervisor	Research project: gather, analyze, then write report	On demand

Orchestration how-to guide → Orchestration glossary →

API reference

Key API classes.

The core classes that power multi-agent workflows. Every orchestrator builds on the Agent class and its builder pattern.

Class

Agent

Core agent class with system prompt, tools, memory, and execution capabilities.

View API

Class

AgentBuilder

Fluent builder for configuring agents with names, prompts, tools, and memory.

View API

Class

PipelineOrchestrator

Sequential agent chaining where each output flows into the next agent.

View API

Class

ParallelOrchestrator

Concurrent execution of multiple agents with result aggregation.

View API

Class

RouterOrchestrator

Intent-based routing that dispatches to the best specialist agent.

View API

Class

SupervisorOrchestrator

Lead agent dynamically delegates to workers and aggregates results.

View API

Class

AgentRegistry

Central registry for discovering and managing available agents.

View API

Class

AgentMemory

Persistent memory for agents to recall context across sessions.

View API

Class

AgentExecutor

Execution engine that runs agents with tool calling, retries, and tracing.

View API

LMKit.Agents namespace LMKit.Agents.Orchestration namespace

Working demos

Run multi-agent demos locally.

Each demo is a standalone console app you can run on your machine. Clone the repo, pick a model, and see orchestration in action.

Supervisor

Research assistant

A supervisor agent that delegates research, analysis, and writing tasks to specialized workers using ReAct planning.

View demo

Parallel

Multi-agent document review

Three reviewers (technical, business, security) analyze a document concurrently and merge their findings.

View demo

Pipeline

Content creation pipeline

A sequential pipeline that chains researcher, writer, and editor agents to produce polished content.

View demo

Router

Smart task router

Classifies user intent and routes each request to the most appropriate specialist agent automatically.

View demo

Memory

Persistent memory assistant

An agent that retains context across sessions using long-term memory and RAG-based recall.

View demo

Agent

News monitoring agent

A single agent equipped with web search tools that monitors, filters, and summarizes news topics.

View demo

GitHub samples repo Full samples overview

How-to guides

Step-by-step guides.

Hands-on tutorials that walk you through building, deploying, and monitoring multi-agent systems.

GuideBuild a multi-agent workflow GuideOrchestrate with Pipeline, Parallel, Router, and Supervisor GuideCreate an AI agent with tools GuideBuild a conversational assistant with memory GuideBuild a resilient production agent GuideRoute prompts across models with RouterOrchestrator GuideStream agent responses in real time GuideMonitor agent execution with tracing and metrics

Glossary

Key concepts.

Core terminology for understanding multi-agent architectures. Each term links to a detailed explanation.

TermAI agents TermAgent orchestration TermAgent delegation TermAgent execution TermAgent memory TermAgent planning TermAgent reasoning TermAgent guardrails

Related capabilities

Beyond the four patterns.

Pipeline, Parallel, Router, Supervisor cover most workflows. The capabilities below extend them with arbitrary shapes, hand-off semantics, real-time progress, and production-grade reliability.

Graph orchestration

When the four patterns are not enough. Compose Sequential, Parallel, Conditional, and Agent nodes into arbitrary shapes with thread-safe context.

Graph page

Agent delegation

Programmatic DelegationManager for explicit routing, plus model-driven hand-off in SupervisorOrchestrator via delegate_to_agent.

Delegation page

Agent templates

Eighteen pre-built specialised agents make natural workers in any orchestration: Classifier, Reviewer, Extractor, Editor, and more.

Templates page

Streaming

Every orchestrator streams. Delegation tokens identify which worker is producing output. Build live multi-agent UIs.

Streaming page

Resilience

Wrap any orchestrator in retries, timeouts, fallbacks, and bulkheads. One slow worker should not stop the whole crew.

Resilience page

Observability

Each agent, each delegation, each plan step emits a span with parent/child relationships. See the whole workflow in one trace.

Observability 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

Install the SDK

Build your first multi-agent workflow.

Install LM-Kit.NET, pick an orchestration pattern, and have agents collaborating in minutes. No cloud keys, no API costs, no data leaving your machine.

Download View pricing