Build AI agents inside your .NET applications
Runiq is a .NET-native agent framework for adding agents, tools, streaming execution, and an embedded dashboard to your ASP.NET Core applications.
The gap
Agent prototypes are easy. Production agent infrastructure is not.
Direct LLM API calls are easy to start with, but real products need agent identity, instructions, typed tools, streaming, runtime events, observability, debugging, and a way to inspect what actually happened.
Direct model calls
One-off API calls become hard to trace, retry, and inspect.
Unsafe tool boundaries
Business actions need typed, approved capabilities — not prompt-only behavior.
Unstructured streaming
Responses, tool calls, and runtime events need a consistent event model.
Limited visibility
Teams need to see what the agent did, which tools ran, and what changed.
The runtime
Runiq brings the agent runtime into your ASP.NET Core host.
Register agents, attach typed C# tools, stream responses, and inspect execution flow from an embedded dashboard served by your application.
No separate SaaS dashboard
The dashboard is served by the host application you already deploy.
Runtime in the app
Agent execution becomes part of your ASP.NET Core application boundary.
AI logic stays in .NET
Developers do not need to move product behavior into a separate platform.
Core pillars
The pieces you need to ship agent features
Agents
Define focused agents with instructions, model settings, and predictable runtime behavior.
Tools
Expose trusted C# capabilities to agents through strongly typed tool contracts.
Runtime
Execute agents through a consistent runtime instead of wiring model calls manually.
Streaming
Stream assistant responses and tool execution events as they happen.
Dashboard
Inspect agents, prompts, tools, and execution flow inside your own application.
Developer experience
Add agents without leaving your .NET application
Runiq fits into the ASP.NET Core application model you already use. Keep business rules in C#, register agents through application startup, and expose only approved tool capabilities.
builder.Services.AddRuniqServer(options =>
{
options.AddAgent(
new Agent(
id: "travel-agent",
name: "Travel Agent",
instructions: "Plan practical trips for users.",
model: "openai/gpt-5",
apiKey: builder.Configuration["OpenAI:ApiKey"])
.AddTool<WeatherTool>());
});
var app = builder.Build();
app.UseRuniqDashboard(options =>
{
options.Path = "/dashboard";
options.Title = "Runiq Dashboard";
});Embedded visibility
A dashboard that ships with your application
Runiq Dashboard is served from your ASP.NET Core host, so your team can inspect registered agents, tools, prompts, runtime settings, and execution flow without building internal AI tooling from scratch.
Tool execution
Keep business logic in your .NET code
Runiq keeps business logic in your .NET code while allowing agents to request approved capabilities when needed.
User prompt
The user asks for an outcome.
Agent runtime
Runiq applies instructions, model settings, and available tools.
Tool call
The model requests an approved capability.
Typed C# tool
Your application code executes the action.
Tool result
The result is returned to the agent runtime.
Final response
The assistant streams the answer back.
Runtime trace
streaming events
Why Runiq
Built for real application integration
.NET-native by design
Built around ASP.NET Core, dependency injection, and C# application boundaries.
Embedded dashboard
Inspect your agents inside the application you already deploy.
Typed tool contracts
Expose approved business capabilities without hiding behavior in prompts.
Streaming-first runtime
Stream assistant output and tool events through one execution model.
Runtime visibility
See what ran, which tool was called, and what the agent returned.
Application integration
Keep AI behavior close to your existing product code.
Start building agents in your .NET application
Use Runiq to add agent runtime, typed tools, streaming execution, and embedded inspection to the application you already own.