NetCrew 1.1.0

NetCrew

The .NET agent library you embed in your own product — on any model, with or without a reasoning loop.

NetCrew is not a developer CLI and not a hosted SaaS. It's a library that lives inside your app — web chat, mobile, Telegram, REST API, CRM, background service — and turns conversations with your customers into structured outcomes: leads, bookings, qualified data. Agent behavior is written in DMSL, stored in your database, and runs on any LLM provider you choose.

📖 New here? Start with Why NetCrew? — the philosophy & a full example.

Try it: talk to NetCrew about NetCrew

The repo ships a console sample at samples/NetCrew.Console — a CLI chat agent built entirely on the library itself. So the quickest way to understand NetCrew is to run it and ask the agent: NetCrew is effectively demonstrating (and testing) itself.

It's defined only by local DMSL files (dialogs/demo/) — no custom C# for the conversation — and it shows the framework's headline features live:

• 🗣️ Explain the platform. Ask it what NetCrew is, its architecture, its strengths and weaknesses, and how it compares to Claude Code.
• 📚 Answer from real docs (MCP). It pulls from official Microsoft / .NET documentation and from any public GitHub repository via MCP servers (microsoft-learn, deepwiki) — accurate answers, with sources, no hallucination.
• 🔀 Reasoning-loop routing. A process="root" dispatcher reads your message and routes it to the right skill (platform, docs) — a working example of the loop mode, MCP tools, and multi-skill routing.

# 1. set a key (the demo uses Claude Haiku)
export ANTHROPIC_API_KEY="sk-ant-..."

# 2. run the CLI (auto-greets, then chat)
dotnet run --project samples/NetCrew.Console

Then try:

you: What is NetCrew, and how is it different from Claude Code?
you: How do retries work in Microsoft.Extensions.Http?
you: Explain the architecture of the modelcontextprotocol/csharp-sdk repo.

Empty line to exit; /<memberKey> <topicId> jumps to a topic. The same project is packaged as a .NET tool (PackAsTool) — once published you can dotnet tool install -g NetCrew.Console and just run netcrew. Full walkthrough: Quick Start.

Two ways to meet NetCrew: embed the library in your product, or grab this CLI and chat with an agent that runs on it.

Why teams choose NetCrew

• 🧩 Embeds anywhere. A .NET library, not a standalone tool. Drop it into any product and ship an agent to your end users — on your servers, your perimeter, on-premise if you need it.
• 🔌 Any model, per step. OpenAI, Anthropic, Cerebras, Mistral, local Llama — any provider. Pick a cheap model for greetings and a powerful one for the hard decision in the same topic. No vendor lock-in; switching is one line.
• 🔁 Loop and no-loop — your choice. Run a strict, auditable scripted graph (no free reasoning) for regulated flows, or a reasoning-loop dispatcher (<RUN FUNCTION> / <RUN SKILL>) for open-ended assistants. Same language, one attribute.
• 🧠 DMSL is just an object. A topic is a serializable record that is both a model and a task. Write it by hand, parse it, or generate it in code — and change behavior live, from the database, with no redeploy.
• 🛡️ Data sovereignty by default. Built-in PII anonymization tokenizes names, phones, emails, and reg numbers before anything reaches the LLM (GDPR / UK GDPR). Plus first-class CRM leads, knowledge-base RAG, and multi-tenancy via MemberKey.

Most AI frameworks optimize developer experience. NetCrew optimizes production operations and business outcomes.

How NetCrew differs

vs Claude Code

Claude Code is a brilliant assistant for engineers in a terminal. NetCrew is a library for shipping agents to your customers.

vs CrewAI / LangChain

• DMSL separates business logic from code, so product teams change behavior without a developer.
• Production-first — built to embed in end-user products, not just orchestrate tools for engineers.
• Effortless multi-provider — per-step model selection and cost optimization out of the box.
• Native MCP — connect Model Context Protocol servers as first-class tools.

Want the deep dive on the philosophy (Software 3.0, Agentic Engineering, Jagged Intelligence) and a step-by-step breakdown of a real production topic? → Why NetCrew?

Key Use Cases

1. Production Chatbots

Customer Support & Sales: Build a chatbot that lives in your website, Telegram, or mobile app. The bot greets customers, qualifies leads, answers FAQ, and books appointments—all without human intervention.

Example: Automotive dealership chatbot

• Greet customer
• Collect vehicle interest + budget
• Search inventory
• Offer test drive booking
• Create lead in CRM
• Route to salesperson if needed

2. CRM Integration Layer

Lead Automation: Every customer conversation automatically becomes structured data in your CRM.

Example: During a support chat, NetCrew extracts:

• Customer name, email, phone (via Data Rules)
• Problem description (via LLM extraction)
• Product interest (via intent detection)
• Creates Lead record in CRM
• Notifies sales team in real-time

No manual data entry. No lost leads.

3. Knowledge Base Agent

Accurate Q&A Without Hallucinations: Connect your knowledge base via RAG + LLM. The agent answers customer questions precisely, citing sources, never making up information.

Example: "What's the warranty on my product?"

• NetCrew searches knowledge base
• LLM reads retrieved docs
• Answers: "Your product has a 2-year warranty (see Warranty Policy v3.2 in our docs)."
• If info not found, agent says "I don't know—let me connect you to support" (graceful fallback)

4. Multi-Step Workflows with Branching

Conditional Logic: Based on user input, route to different sub-workflows.

Example: Tax filing assistant

• Step 1: Income type? (Self-employed / W-2 / Both)
• Step 2a (Self-employed): Collect business expenses, deductions
• Step 2b (W-2): Ask for W-2 forms
• Step 2c (Both): Ask for both
• Step 3: Calculate estimate → Offer filing service

5. Multi-Tenant Systems

One Engine, Many Brands: Dealership group with Vauxhall, Opel, Citroën brands. Each brand has different tone, inventory, workflow. NetCrew runs one instance serving all brands via configuration (MemberKey).

Architecture Overview

┌─────────────────────────────────────────────────────────┐
│                   User Channels                         │
│         (Web Chat, Telegram, Mobile, REST API)          │
└──────────────────────┬──────────────────────────────────┘
                       │
┌──────────────────────▼──────────────────────────────────┐
│                    NetCrew                              │
│  ┌──────────────────────────────────────────────────┐   │
│  │  Message Pipeline                               │   │
│  │  Validate → Init Rules → Data Rules → Tool Call │   │
│  │  → LLM → Post Rules → Response                  │   │
│  └──────────────────────────────────────────────────┘   │
│                       │                                  │
│      ┌────────────────┼────────────────┐                │
│      │                │                │                │
│  ┌───▼────┐   ┌──────▼──────┐  ┌──────▼──────┐        │
│  │  DMSL  │   │   Tools     │  │    LLM      │        │
│  │ Script │   │  (Custom +  │  │  Services   │        │
│  │        │   │   MCP)      │  │ (GPT, etc.) │        │
│  └────────┘   └─────────────┘  └─────────────┘        │
│                                                         │
│  ┌──────────────────────────────────────────────────┐   │
│  │           Data & State Management                │   │
│  │  - Conversation history                          │   │
│  │  - Variables (var-stack)                         │   │
│  │  - PII Anonymization layer                       │   │
│  │  - File-based or SQL Server storage              │   │
│  └──────────────────────────────────────────────────┘   │
└──────────────────────┬──────────────────────────────────┘
                       │
        ┌──────────────┴──────────────┐
        │                             │
   ┌────▼────┐               ┌───────▼────┐
   │   CRM   │               │  Knowledge │
   │ System  │               │    Base    │
   └─────────┘               └────────────┘

Core Components

Agents (chosen by the <olp process="..."> attribute):

• CrewNetAgent — Base agent: single deterministic pipeline pass, tool selection
• CrewNetChatAgent — process="graph" (default): multi-step scripted workflows with routing, IF/BEGIN/END, no free-reasoning loop
• CrewNetSkillAgent — process="root" / "skill": dispatcher with a reasoning loop (<RUN FUNCTION x> ×N, <RUN SKILL>)
• CrewNetDelegateNodeAgent — process="delegate": a sub-task node that returns a result to its caller

DMSL / OLP (Domain Specific Language): Declarative, XML-like syntax for defining agents and tasks without code. A topic is stored in the database and executed by the framework. The root <olp> tag picks the execution style via process= (graph by default, or root/skill/delegate).

Example DMSL topic:

<olp process="graph">
<agent name="lead_qualifier">
  <role>You are a sales assistant qualifying leads and booking demos.</role>
  <communication_style>Professional, friendly, concise.</communication_style>
  <tools model="GPT40MINI">
    <tool name="search_products" />
    <tool name="check_availability" />
    <tool name="create_lead" args="source_topic:7" />
  </tools>
</agent>

<task id="12" name="qualify">
  <describe>Run when a visitor is interested in a product or a demo.</describe>
  <target>Qualify the lead and book a demo.</target>

  <init_rules>
    <tool name="init_welcome" />
  </init_rules>

  <prompt model="GPT5MINI">
1. Ask what product the customer is interested in.
2. Confirm budget and timeline.
3. Offer demo slots and book one. <RUN CALENDAR>
  </prompt>

  <data_rules>
    <rule fields="product:string, budget:int, wants_demo:int"
          question="Extract the product of interest, the budget, and whether the customer wants a demo (1=yes,0=no). Return only a JSON object." />
  </data_rules>

  <post_rules>
    <tool name="markdown_formatter_tool" />
  </post_rules>
</task>
</olp>

See Why NetCrew? → Walkthrough for a full breakdown of every DMSL construct against the engine.

Tools:

• Custom tools (C# classes)
• MCP servers (external integrations)
• Built-in tools (PII anonymization, CRM creation, RAG search)

Services:

• IModelService — LLM provider abstraction
• IDbService — Conversation storage (file or SQL)
• ILogService — Structured logging
• INetCrewToolsService — Tool registry

Key Features

1. Multiple LLM Providers

Switch between OpenAI GPT-4o, Anthropic Claude, Cerebras Llama, or any OpenAI-compatible API. Change provider per agent or per workflow step. Optimize cost: cheap model for simple tasks, powerful model for complex decisions.

2. MCP Server Integration

Connect Model Context Protocol servers as first-class tools. Read files from filesystem, query databases, call webhooks—all seamlessly integrated into agent workflows.

3. DMSL Language

Define agents in declarative DMSL/XML. Non-developers can edit workflows via database UI. No code recompilation needed.

4. Multi-Step Workflows

• Init Rules: Run before first agent response (set up variables, fetch context)
• Data Rules: Extract structured data from conversation (name, email, intent)
• Tool Selection: Choose which tool to call based on user input
• Post Rules: Run after agent response (validation, transformation, logging)

5. PII Anonymization

Automatically detect and anonymize personal information before sending to LLM. Comply with GDPR, CCPA, and data protection regulations.

User: "My name is John Smith, call me at 555-1234"
       ↓
[PII Anonymization]
       ↓
To LLM: "My name is [PERSON_1], call me at [PHONE_1]"
       ↓
[Agent responds]
       ↓
[PII Restoration]
       ↓
User: "Thanks John! I'll call you at 555-1234"

6. CRM-Ready

Built-in tools for creating leads, updating contacts, logging interactions. Automate lead qualification and customer data enrichment.

7. Flexible Storage

• File-based storage (for development/single-server)
• SQL Server (for production/scale)

8. Multi-Channel Support

• Telegram bot (native)
• Web chat widget (via REST API)
• Mobile app integration (via SDK)
• Custom channels (HTTP adapter)

Before You Start

Prerequisites

• .NET 8.0 or later
• Basic C# knowledge (understanding of async/await, dependency injection)
• Understanding of agent concepts (what agents are, tool use, LLM reasoning)
• At least one LLM API key:
  • OpenAI (GPT-4o): https://platform.openai.com/
  • Anthropic (Claude): https://console.anthropic.com/
  • Cerebras: https://console.cerebras.ai/

What You'll Need to Install

• .NET 8.0 SDK
• A code editor (Visual Studio, VS Code, Rider)
• NuGet packages (automatically installed):
  • NetCrew.Infrastructure
  • NetCrew.Llm
  • ModelContextProtocol (for MCP servers)
  • Microsoft.Playwright (for browser automation)

Next Steps

Quick Example

Here's what a simple agent conversation looks like:

User: "Hi, I want to book a service appointment"

Agent: "Welcome! I'd be happy to help. Do you have your vehicle registration number?"

User: "ABC123XYZ"

Agent: [Calls tool: vehicle_lookup] 
       "I found a 2023 Tesla Model 3 registered to you. Is that correct?"

User: "Yes"

Agent: [Calls tool: check_availability, check_service_types]
       "Great! What service do you need? 
        1. Oil change
        2. Tire rotation
        3. Inspection"

User: "Inspection"

Agent: [Calls tool: create_booking]
       "Perfect! I've booked your inspection for Thursday at 2 PM at our downtown location.
        Confirmation sent to your email. Anything else?"

User: "No, thanks"

Agent: [Conversation ends, lead created in CRM]

The entire flow is defined in DMSL. The agent knows exactly what tools to call, in what order, with what validation rules. No surprises. No hallucinations.

The Philosophy

NetCrew rests on three ideas — Software 3.0 (behavior lives in language, stored in the database), Agentic Engineering (the business defines the graph; the agent executes it), and Jagged Intelligence (confine the LLM to the verifiable tasks where it's precise).

These are explained in full, with a step-by-step breakdown of a real production topic, in Why NetCrew?.

Getting Help

• Issues & Questions: GitHub Issues
• Discussions: GitHub Discussions
• Documentation: See links above
• Contributing: We welcome pull requests and community contributions

License

[Include appropriate license - MIT, Apache 2.0, etc.]

Acknowledgments

NetCrew is inspired by CrewAI, driven by Agentic Engineering principles, and built for production environments where reliability and auditability matter.