Agent runtime infrastructure for .NET.

Tools, sessions, threads, events, middleware, providers, audio, bots, and hosted runtimes as explicit system surfaces.

Start Small

Begin with one builder and one run, then add streaming, tools, sessions, persistence, and hosting without changing the architecture.

Follow the path

Durable State

Keep session history, fork alternate threads, compact context, and preserve the runtime state a real agent app depends on.

Understand state

Event Native

Stream text, tool calls, permissions, workflow traces, audio, custom events, and bidirectional host decisions through one event model.

Explore events

Composable Surfaces

Register tools, harnesses, middleware, providers, subagents, bot adapters, and hosted clients with source-generation-friendly APIs.

Add capabilities

First 30 minutesBuild one agent that streams, calls a tool, remembers context, and can be hosted.Follow the shortest working path.Runtime visibilityRender live turns, tool calls, permissions, audio, and workflows from the event stream.Make the agent observable from day one.Control planeAdd retrieval, policy, state, usage tracking, and custom behavior around each turn.Shape the runtime without hiding it.

The core loop stays readable

One builder surface. Real production escape hatches.

HPD Agent keeps the beginner path small, then opens the runtime surfaces that usually get bolted on later: sessions, threads, event streams, middleware, tool harnesses, hosted APIs, and provider-specific clients.

csharp

var agent = await new AgentBuilder()
    .WithOpenAI(model: "gpt-5-mini")
    .WithInstructions("You are a concise product assistant.")
    .WithTool(new WeatherTools())
    .BuildAsync();

using var stream = agent.Subscribe<TextDeltaEvent>(e =>
    Console.Write(e.Delta));

var (sessionId, threadId) = await agent.CreateSessionAsync("demo");
await agent.RunAsync("What should I pack for Seattle?", sessionId, threadId);

What you can build

Agents that are useful outside the demo.

HPD Agent gives .NET teams the runtime pieces around the model call: tools, state, events, channels, audio, hosting, evaluation, and orchestration.

ChannelsConnect agents to Slack, Discord, Telegram, WhatsApp, and Teams.

Use platform adapters when you want the same agent to show up where users already work.

ToolsExpose real C# capabilities as model-callable functions.

Live UXRender streaming text, tool calls, permissions, audio, and workflow traces.

Project the event stream into transcripts, timelines, dashboards, logs, or custom clients.

StateKeep sessions, fork threads, compact history, and resume work.

Build agents that remember enough to be useful without turning state into hidden magic.

AudioAccept speech, produce voice, or run realtime audio experiences.

Use provider-specific audio clients while keeping audio events attached to the agent runtime.

OrchestrationCompose subagents, handoffs, workflows, and conversation policies.

Move from one assistant to structured multi-agent systems when the problem calls for it.

ControlAdd middleware for permissions, retrieval, memory, usage, and policy.

Wrap the agent lifecycle without burying the behavior inside provider-specific code.

HostingExpose agents over HTTP with streaming, stored definitions, and clients.

Start locally, then turn the runtime into an application surface your frontend can call.

Start small

One agent first, then the rest of the system.

The beginner path gets you from a local console agent to tools, sessions, streaming, persistence, and hosting without forcing every advanced surface into the first page.

Open Getting Started