Microsoft Agent Framework + Ertas

Build production agents on Microsoft Agent Framework — the GA-released successor to AutoGen and Semantic Kernel, with enterprise-grade orchestration and full support for Ertas-trained local models.

Overview

Microsoft Agent Framework is the unified successor to AutoGen and Semantic Kernel, released as RC1.0 in February 2026 and reaching general availability with version 1.0 on April 3, 2026. The early-May 2026 v1.3.0 release added class-based skills, experimental harness context providers, prompt-injection defenses, and expanded OpenAI / Anthropic / Foundry support, alongside published durable-workflows documentation. It consolidates the multi-agent conversation patterns from AutoGen with the orchestration primitives from Semantic Kernel into a single framework with .NET, Python, and TypeScript runtimes. Microsoft's publicly stated direction is that AutoGen is in maintenance mode and new development should target Microsoft Agent Framework — making it the canonical Microsoft agent stack going forward.

The framework's architecture borrows from both predecessors. From AutoGen it inherits the multi-agent conversation pattern: agents with distinct roles communicate through structured messages and arrive at outcomes through dialogue. From Semantic Kernel it inherits the planner abstraction, the connector ecosystem, and tight integration with the Microsoft enterprise stack (Microsoft 365, Azure AI, Power Platform). The result is a framework that fits cleanly into Microsoft-centric enterprise architectures while remaining flexible enough to host any LLM provider on its model abstraction.

The framework supports any OpenAI-compatible endpoint as a model provider, which makes self-hosted and fine-tuned local models first-class citizens alongside Azure OpenAI and the broader Azure AI Foundry catalog. For teams already invested in Microsoft tooling — Visual Studio, Azure DevOps, Microsoft 365 — this is the lowest-friction path to production agents that don't depend on cloud API economics.

How Ertas Integrates

Ertas-trained models integrate with Microsoft Agent Framework through its OpenAI-compatible provider. After fine-tuning in Studio and exporting to GGUF, you serve the model via Ollama, vLLM, or Ertas Cloud, then configure the framework's `OpenAIChatClient` (or the equivalent in .NET / TypeScript) with your endpoint URL and a placeholder API key. The agent abstractions, multi-agent orchestration, and Microsoft-stack connectors all work transparently against your fine-tuned model.

The combination is particularly relevant for enterprises that want Microsoft's developer tooling and connector ecosystem without the per-token costs of Azure OpenAI at scale. Microsoft Agent Framework + Ertas-trained models + on-premise inference produces an agent stack that fits into existing Microsoft Enterprise Agreements while keeping inference costs fixed and predictable. For agentic applications that handle high call volumes — customer support, internal knowledge retrieval, document processing — this can flip per-task economics by 10–100x.

For teams migrating from AutoGen, the framework provides a documented migration path. Existing AutoGen multi-agent conversations port to Microsoft Agent Framework with mostly mechanical changes, and the underlying model provider can be swapped from Azure OpenAI to a local Ertas-trained model in the same migration step. This is often the right time to convert per-token API costs into per-VM compute costs as part of a broader platform-modernization effort.

Getting Started

1
Fine-tune a domain model in Ertas Studio
Train on data that captures your enterprise's specific patterns — terminology, document conventions, internal tool schemas. Studio's data format works with multi-agent conversation traces from existing AutoGen or Semantic Kernel deployments.
2
Deploy to an OpenAI-compatible endpoint
Export to GGUF and serve via Ollama, vLLM, or Ertas Cloud. Microsoft Agent Framework calls any endpoint that exposes the standard chat-completion API.
3
Install Microsoft Agent Framework
Install the framework in your language of choice (.NET via NuGet, Python via pip, TypeScript via npm). All three runtimes share the same agent and orchestration abstractions.
4
Configure the model client and define agents
Create an `OpenAIChatClient` pointed at your Ertas inference endpoint. Define agents using the framework's agent abstraction with roles, instructions, and tools.
5
Orchestrate with built-in patterns or custom workflows
Use the framework's built-in orchestration patterns (sequential, group chat, hierarchical) or build custom workflows. Microsoft 365 connectors, Power Platform integrations, and Azure AI Search work transparently against the local model.

python

from agent_framework import ChatAgent, OpenAIChatClient, GroupChat
from agent_framework.tools import function_tool

# Point the framework at your Ertas-trained model served via Ollama
client = OpenAIChatClient(
    base_url="http://localhost:11434/v1",
    api_key="not-needed",
    model="ertas-finance-ops-14b",
)

@function_tool
async def fetch_invoice(invoice_id: str) -> dict:
    """Look up an invoice from the finance system."""
    return await finance_api.get_invoice(invoice_id)

@function_tool
async def approve_payment(invoice_id: str, amount: float) -> dict:
    """Approve and queue a payment."""
    return await finance_api.approve(invoice_id, amount)

# Define specialized agents
auditor = ChatAgent(
    name="Auditor",
    client=client,
    instructions="You verify invoice details and flag anomalies.",
    tools=[fetch_invoice],
)

approver = ChatAgent(
    name="Approver",
    client=client,
    instructions="You approve payments after the auditor verifies them.",
    tools=[approve_payment],
)

# Multi-agent group chat
chat = GroupChat(agents=[auditor, approver])
result = await chat.run("Process invoice INV-2026-0512 — verify and approve if valid.")

Build a multi-agent finance workflow with Microsoft Agent Framework backed by an Ertas-trained 14B model. The framework handles orchestration; the local model handles inference at no per-token cost.

Benefits

GA-released — successor to AutoGen and Semantic Kernel with Microsoft long-term support
.NET, Python, and TypeScript runtimes share unified abstractions
Native integration with Microsoft 365, Azure AI, and Power Platform
Built-in orchestration patterns: sequential, group chat, hierarchical multi-agent
Works with any OpenAI-compatible endpoint — Azure OpenAI, OpenAI, Ertas-trained local models
Migration path from AutoGen multi-agent conversations is documented and mechanical
Enterprise-grade tracing, evaluation, and Azure AI Foundry integration