Introducing LogicGrid — Multi-Agent AI Orchestration for .NET

We're launching LogicGrid — a .NET-native framework for building multi-agent AI systems. It's been ten months in the making, and today the beta is on NuGet.

This post is the "why we built this" version. If you'd rather just see code, jump straight to the Quickstart — five minutes from zero to a running agent.

The problem

We needed to build an AI feature for a regulated environment where customer data couldn't leave the network. Two requirements that turned out to be in tension:

1. We were on .NET. Migrating to Python was a non-starter.
2. We needed local LLMs. Cloud providers were off the table for compliance reasons.

We tried the obvious frameworks:

• Semantic Kernel worked, but the path for local LLMs felt like it had been added late. Most of the documentation, examples, and ergonomics were Azure-first.
• LangChain.NET worked for prototypes, but it lagged the Python version in features and the integration coverage was thin.
• Rolling our own worked too — but every team should not have to rebuild agent orchestration from scratch.

So we built LogicGrid: the framework we wished existed.

What's different

Three things distinguish LogicGrid from what's already out there:

1. Local LLMs are first-class

Same code runs against Ollama, vLLM, LM Studio, TEI, OpenAI, Anthropic, Gemini, or any OpenAI-compatible endpoint. Switching providers is a one-line change:

var llm = LlmClientBase.Ollama("llama3.2");
// var llm = LlmClientBase.OpenAI("gpt-4o");
// var llm = LlmClientBase.Anthropic("claude-sonnet-4-6");

There's no second-tier path for local providers. The streaming protocol, tool calling, and embeddings work identically across all of them.

2. Observability is built in

Every agent step, tool call, retry, and LLM call emits a structured event. Token counts, timings, errors, tool arguments — all of it, no extra code:

var ctx = new AgentContext()
    .WithLogging()
    .WithTracing(out var trace);

await agent.RunAsync("...", ctx);

Pipe it to a console, file, or OpenTelemetry collector. When a customer reports a bad answer, you can pull up the full trace. No black boxes.

3. Zero hidden runtime dependencies

LogicGrid targets netstandard2.0, net6.0, and net8.0. The full SBOM ships in the public repo as bom.json. The dependency graph is small enough that you can audit every package before it touches your build server.

This matters for air-gapped enterprise deployments where every transitive dependency is a question to answer.

What's in the box

The framework is split across five NuGet packages so you only pull in what you need:

dotnet add package LogicGrid.Core     # Agents, admins, orchestration, events
dotnet add package LogicGrid.Memory   # Vector stores, embeddings, hybrid search
dotnet add package LogicGrid.Rag      # Full RAG pipeline
dotnet add package LogicGrid.Tools    # Tool / function calling
dotnet add package LogicGrid.Mcp      # MCP (Model Context Protocol) client

Highlights:

• Multi-agent orchestration — Sequential, GroupChat, Graph, Parallel, MapReduce, Reflexion
• Hybrid search — BM25 + dense retrieval fused with Reciprocal Rank Fusion. Beats either alone for codes, IDs, proper nouns
• Tool calling — Define tools as plain C# methods with attributes. Schema is generated for you
• MCP client — Talk to any MCP server, stdio or HTTP, including resumable sessions
• Observability — Structured events, console / file / OTel sinks, run tracing for audit

A 5-minute example

dotnet add package LogicGrid.Core
ollama pull llama3.2

using LogicGrid.Core.Agents;
using LogicGrid.Core.Llm;

var llm = LlmClientBase.Ollama("llama3.2");

IAgent agent = new Agent<string>(
    name: "Helper",
    description: "Answers questions concisely.",
    systemPrompt: "Answer in one short sentence.",
    llm: llm);

Console.WriteLine(
    await agent.RunAsync("What is the capital of France?", new AgentContext("ask")));

Three using statements. Four logical lines. No appsettings.json ritual, no DI registration dance.

When you outgrow a single agent, the multi-agent patterns are right there:

var admin = new GroupChatAdmin<string, string>(
    name: "Editorial",
    llmClient: llm,
    agents: new[] { researcher, writer, critic });

Console.WriteLine(await admin.RunAsync("Explain RRF in 200 words."));

The Quickstart walks through the rest.

What's next

LogicGrid is at 0.1.3-beta today. The core API is stable enough that we're building production systems on it, and after months of external feedback we're moving to beta.

The roadmap toward beta and 1.0:

• More providers (xAI, Cohere, Bedrock)
• More document loaders (PDF beyond text extraction, structured Office docs)
• More vector store integrations (pgvector, Qdrant, Weaviate first-party)
• A persistent memory store backed by SQLite
• Real-world performance benchmarks

If you try it and something is missing or broken, open an issue or jump into discussions. Early-adopter feedback shapes what we ship next.

How LogicGrid fits with what's already out there

If you're already happy with Semantic Kernel or LangChain.NET, that's great — keep using them. We didn't build LogicGrid to replace them; we built it because we needed something different.

For a side-by-side, see LangChain vs Semantic Kernel vs LogicGrid.

If you're frustrated by Semantic Kernel's posture toward local LLMs, see A Semantic Kernel Alternative for .NET.

If you're new to the whole space, How to use Ollama with C# is the gentlest on-ramp.

Try it

dotnet add package LogicGrid.Core

Five minutes from zero to a running agent. If it doesn't fit your stack, you'll know quickly. If it does, the docs walk you through everything else.

Thanks for reading. We're excited to see what people build.