SmooAI.SmoothOperator.Core 1.5.0

<p align="center"> <a href="https://smoo.ai"><img src="https://raw.githubusercontent.com/SmooAI/smooth-operator-core/main/.github/banner-dotnet.png" alt="smooth-operator-core — The C# / .NET engine for orchestrated AI agents" width="100%" /></a> </p>

<p align="center"> <a href="https://smoo.ai/th"><img src="https://img.shields.io/badge/Smoo_AI-platform-00A6A6?style=for-the-badge&labelColor=020618" alt="Smoo AI"></a> <a href="https://github.com/SmooAI/smooth-operator-core/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-F49F0A?style=for-the-badge&labelColor=020618" alt="license"></a> <a href="https://lom.smoo.ai"><img src="https://img.shields.io/badge/hosted-lom.smoo.ai-FF6B6C?style=for-the-badge&labelColor=020618" alt="lom.smoo.ai"></a> </p>

<p align="center"> <a href="https://www.nuget.org/packages/SmooAI.SmoothOperator.Core"><img src="https://img.shields.io/nuget/v/SmooAI.SmoothOperator.Core?style=flat-square&color=00A6A6&labelColor=020618" alt="NuGet"></a> <img src="https://img.shields.io/badge/.NET-engine-512BD4?style=flat-square&labelColor=020618" alt=".NET engine"> </p>

The C#/.NET sibling of the Rust reference engine. Agents, tools, knowledge/RAG, memory, checkpointing, human-in-the-loop, cost budgets, and workflows — as one embeddable NuGet package. It's the engine, not a notebook demo.

SmooAI.SmoothOperator.Core is the native C# implementation of the Smoo AI agent engine — the in-process observe→think→act loop that powers lom.smoo.ai. It's a sibling of the Rust reference engine and one of the polyglot set (Rust, TypeScript, Python, Go, C#/.NET) whose behavior is held at parity by a shared eval suite. Its API follows Microsoft.Extensions.AI naming.

It's a library, not a client to a remote server: it is the agent, running in your .NET process. Every surface is covered by fast, offline tests built on a deterministic MockLlmProvider, so the loop is verified — not vibe-coded.

Install

dotnet add package SmooAI.SmoothOperator.Core

Quickstart

A complete agent — no credentials needed — using the deterministic mock provider the engine's own tests run on:

using SmooAI.SmoothOperator.Core;

var provider = new MockLlmProvider().PushText("the answer is 42");
var agent = new SmoothAgent(provider, new AgentOptions { Instructions = "You are a helpful assistant" });

var response = await agent.RunAsync("what is the answer?");
Console.WriteLine(response.Text);

new SmoothAgent(chatClient, options) takes an IChatClient (the MockLlmProvider implements it — swap in any OpenAI-compatible client) and an AgentOptions. await agent.RunAsync(...) returns an AgentRunResponse; response.Text is the final assistant message.

Features

The full parity surface — every engine in the polyglot set ships it:

• Agentic tool-calling loop — observe→think→act, looping until the model answers.
• Typed tools — register tools the model can call, with parallel dispatch.
• Knowledge / RAG + vectors — ground the turn in retrieved documents.
• Memory — long-term entries recalled into context each turn.
• Compaction — a sliding-window token budget keeps the prompt under a ceiling.
• Cost / budget — per-model pricing, token + USD accounting, early stop on budget.
• Checkpointing — persist/resume a conversation via a checkpoint store.
• Rerank — rerank retrieved hits before injection (lexical reranker built in).
• Sub-agents / delegation — spawn child agents for sub-tasks.
• Cast + clearance — roles with per-role tool-access policy.
• Human-in-the-loop gate — require approval before designated tool calls run.
• Conversation thread — carry a conversation across multiple RunAsync calls.
• LlmProvider seam + MockLlmProvider — inject any OpenAI-compatible client; the record/replay mock drives the offline tests.
• Deferred tools + tool_search — hide rarely-used tool schemas behind a meta-tool the model calls to promote the ones it needs.
• Typed workflow graph — a node/edge workflow engine alongside the agent loop.
• Parallel tool calls — dispatch ≥2 tool calls concurrently (transcript order preserved).
• Retry / backoff — retry transient model-call failures with exponential backoff.
• Streaming — stream incremental text, tool calls, and tool results as the turn runs.

Streaming

RunStreamingAsync is the streaming variant of RunAsync: it yields incremental updates — text deltas as the model produces them, each tool call before dispatch, each tool result after it finishes, and a terminal update carrying the same response RunAsync would have returned.

Part of Smoo AI

smooth-operator-core is built and open-sourced by Smoo AI — the AI-powered business platform with AI built into every product: CRM, customer support, campaigns, field service, observability, and developer tools.

• 🚀 Smooth on the platform — smoo.ai/th
• 🧰 More open source from Smoo AI — smoo.ai/open-source
• 🧩 Run it hosted — lom.smoo.ai

Links

• lom.smoo.ai — run it hosted
• smooth-operator-core — the polyglot engine repo
• Polyglot Engines — install + hello-agent in all five languages
• smoo.ai — the product · smoo.ai/open-source — more open source

License

MIT — see LICENSE.

<p align="center"> Built by <a href="https://smoo.ai"><strong>Smoo AI</strong></a> — AI built into every product. </p>