π«π· Version franΓ§aise
Orkeon.Hosting β runner & host bootstrap
Orkeon.Hosting is the shared bootstrap layer that turns the Orkeon libraries into a runnable host.
It owns the wiring order that a working runtime needs β LLM provider, core services, the standard tool
suites, the virtual file system, and the DI-backed tool registry β plus the end-to-end execution flows
(one-shot kickoff, interactive loop, tool listing) used by every Orkeon runner and CLI.
Inside this repository it is consumed by Orkeon.Scripting.Cli (the orkeon tool) and by
Orkeon.Host (the orkeon-host daemon). It is not distributed as a NuGet package β see
Distribution below. This page documents its public bootstrap surface, the
telemetry a host built on it exports, and the .NET Aspire
integration that launches its executables.
Distribution
Orkeon.Hosting ships inside the Orkeon.Scripting package. Its own csproj stays
IsPackable=false, so there is no Orkeon.Hosting id on any feed: the
publication matrix lists the Orkeon.Scripting
opt-in, whose wrapper (src/packaging/Orkeon.Scripting/Orkeon.Scripting.Package.csproj) embeds
Orkeon.Hosting.dll next to Orkeon.Scripting.dll; Orkeon.Constants.Cli comes as a package dependency.
dotnet add package Orkeon.Scripting
It is not in the Orkeon umbrella: the runner host composes every built-in tool family, so the
package depends on Orkeon.Tools and Orkeon.Tools.Embeddings.Local β weight a consumer of the
umbrella alone never restores.
| Assembly | Orkeon.Hosting.dll (src/hosting/Orkeon.Hosting) |
| Package | Orkeon.Scripting (embedded; the project itself is IsPackable=false) |
| Package dependencies | Orkeon, Orkeon.Tools, Orkeon.Tools.Embeddings.Local, Jint, Microsoft.Extensions.Hosting, Microsoft.Extensions.Options, CommandLineParser |
| Also ships through | the orkeon dotnet tool (Orkeon.Scripting.Cli) and the release.yml installer archives / .deb / MSIs, where Orkeon.Hosting.dll sits next to orkeon and orkeon-host |
Running a crew in-process
A .NET application runs a crew.ork.ts β or a crew.yaml, or a multi-file crew directory β
without starting the orkeon process: ICrewScriptRunner is the in-process form of orkeon run.
using Microsoft.Extensions.DependencyInjection;
using Orkeon.Hosting;
var services = new ServiceCollection().AddOrkeonScripting(options =>
{
options.SettingsPath = "appsettings.json"; // the Llm section, mounts, tools - as for orkeon run
options.Mounts.Add("./out:/output:rw"); // --mount
options.Diagnostics = Console.Error; // the operator lines orkeon run writes on stderr
});
using var provider = services.BuildServiceProvider();
var output = await provider.GetRequiredService<ICrewScriptRunner>().RunAsync("crew.ork.ts");
Console.WriteLine(output.Succeeded ? output.FinalOutput : output.Error);
new CrewScriptRunner(options) does the same without a container.
- What a run is. Each
RunAsyncbuilds a runner host of its own through the shared bootstrap (RunnerExecution, the codeorkeon runruns): the crew target is resolved and mounted, the settings file is found the same way, the mount guards run, thenRunnerHost.Buildcomposes the LLM provider, the built-in tools, the VFS, the permission gate (Orkeon:Security) and the configured MCP servers. The crew is loaded and kicked off in one scope; the host is disposed when the run ends. Nothing but the runner is added to the application's own container. - What comes back. The orchestrator's
CrewOutput: a crew that ran and failed is an output withSucceeded == falseand itsError. A run that cannot start β a missing target, a setting or a mount the host refuses, a crew that does not load β throwsCrewScriptRunExceptionwith the lineorkeon runwould have printed. A cancelledcancellationTokenthrowsOperationCanceledException, before the crew starts or while it runs β never a failed output. - Paths are the process's. The crew path,
SettingsPathand theMountsdirectories resolve against the process working directory when relative, as fororkeon run; a crew outside that directory is refused unlessAllowExternalMountsis set. A service whose working directory is not its content root passes absolute paths. - One configuration per container.
AddOrkeonScriptingregisters the runner withTryAdd: the first call wins, and a second call β with other options or none β is ignored. A second configuration is anew CrewScriptRunner(options). Runs of one runner may proceed at once; each builds its own host. - The script shape. A
.ork.tsmust hand its crew off (globalThis.crew = crew), the declarative shapeorkeon runsends through the same pipeline. A procedural script (one that drives agents itself, with no handoff) is not a crew definition: run it withorkeon run. - Options.
SettingsPath,Mounts,MountIds,AllowExternalMountsandLlmProfileare theorkeon runoptions of the same names.ConfigureServicesis applied after Orkeon's registrations, so it replaces one (anILlmProviderFactory, a human-input provider).ConfigureLoggingsets the run's logging; without it the run logs nothing, and the operator lines go toDiagnosticsonly. - esbuild. A
.ork.tsis bundled by esbuild, which the package does not ship β the stance of theorkeontool (Scripting). Put it onPATH(npm install -g esbuild), or pointORKEON_ESBUILD_PATHorOrkeon:Scripting:Toolchain:EsbuildPathat a binary. A YAML crew never needs it. - Not a daemon. A crew that must keep running between requests β a chat channel, A2A, several
hosted crews β belongs in
orkeon-host(service host).
RunnerHost.Build
RunnerHost is a static host builder. Build returns a fully configured IHost:
IHost host = RunnerHost.Build(
settingsPath: "appsettings.json", // resolved appsettings path (nullable)
mounts: new RunnerMountPlan // the whole VFS surface, in one object
{
CliMounts = ["/data:/data:ro"], // CLI --mount args ("physical:virtual:rights")
InternalMounts = [], // mounts registered MountVisibility.Internal β resolvable
// by the VFS, never listed to an agent (ADR-008)
AllowExternalMounts = false, // whitelist mount base paths outside the workspace root
SelectedMountIds = [], // --mount-id values, parsed: the settings entries kept when
// several declare one virtual root
CrewMountReferences = [], // the crew's mounts: block β selects and validates, never restricts
InputDirectories = [], // folders a command reads as its inputs, readable without the
// external-mounts opt-in
WithdrawsAmbiguousRoots = false, // true: a root the settings declare several times with nothing
// selecting one is withdrawn instead of refusing the host
LlmLogVirtualPath = null, // when set, a VIRTUAL directory the caller has mounted:
// LLM HTTP exchanges are captured there as .jsonl
WorkingDirectory = null, // the folder ./.orkeon/state resolves against (null: the process's)
RunHistoryByDefault = false, // the run history on when the settings do not say (orkeon-host sets it)
LlmMockResponses = null, // --llm-mock: a VIRTUAL JSONL file every LLM profile answers from
LlmRecordCassette = null, // --llm-record: a VIRTUAL JSONL cassette every LLM call is written to
LlmReplayCassette = null, // --llm-replay: a VIRTUAL JSONL cassette every LLM call is answered from
},
configureLogging: null, // optional ILoggingBuilder customization
configureServices: null, // optional hook to register runner-specific services
configureBuilder: null, // optional IHostBuilder hook β orkeon-host uses it for UseSystemd()/UseWindowsService()
llmProfile: null); // optional host LLM profile id (--llm-profile): Llm:Profiles:<id> becomes the run's Llm section
An llmProfile the configuration does not define is refused with a RunnerSettingsException whose message lists the profiles it does define; null or default keeps the Llm section as it is.
A virtual path is always a name starting with / β never a disk path
(ADR-008).
RunnerVirtualRoots β in the dependency-free Orkeon.Constants.FileSystem package
(ADR-009) so the engine and the tooling read one
declaration β names the roots the shipped runners take for themselves: /crew (the crew
definition's directory), /script (a scripting entry point's directory), /llm-logs, /llm-mock and /llm-cassette
(the --llm-mock file and the recorded or replayed cassette), /sandbox (where the code sandboxes stage what they run) and /credentials (the OAuth tokens
of the e-mail and drive accounts, refused to a user mount by every command). RunnerVirtualRoots.All is the set a
caller refuses a user --mount against; asking for the set rather than comparing the roots one by
one is deliberate, because the omission of /sandbox survived a pairwise check for as long as it
was green. A caller that enables exchange logging mounts its log directory internally and passes
RunnerVirtualRoots.LlmLogs here β that is what the CLI does.
LoadCrewAsync likewise takes the crew target as a virtual path: it asks the VFS whether the
target is a directory rather than probing the disk, so a physical path handed to it is denied.
It composes Host.CreateDefaultBuilder() with:
- App configuration β the default builder's sources removed, those of every Orkeon host
(
RunnerSettings.ComposeSources, whichRunnerSettings.ReadConfigurationβorkeon doctor, the probe oforkeon initβ and the REPL compose too): the environment variables without a prefix, thesettingsPathfile when it exists, then theORKEON_-prefixed environment (ORKEON_Llm__ModeloverridesLlm:Model). Neither theappsettings.jsonandappsettings.{Environment}.jsonof the content root β the current directory β nor user secrets Then an in-memory layer carrying the mount decisions: the--mountvalues placed by virtual root, the internal mounts, the/credentialsmount of the e-mail and drive OAuth tokens, and thePathSecurity:AdditionalAllowedDirectoriesentries that let the path validator reach those mounts' folders (a--mountoutside the working directory only withAllowExternalMounts). - Services β
ConfigureRunnerServices(below). configureBuilderβ invoked last, on theIHostBuilderitself.
Once built, the host first judges its settings, whether the run uses them or not: every
section a registration declared β its options created, so the binder converts them and their rules
run, the names they hold among them β, the section names under Orkeon: and its groups, the keys of
every declared section, and Orkeon:Rag:LlmProfile against the profiles it offers
(when a setting is refused). Only options and the
named factories are created: no store, provider, model or connection. The first refusal is a
RunnerSettingsException naming its key, the host disposed: nothing is logged, warned or started.
Then the host logs the mount decisions it took, warns (on the log and on stderr) when
an OAuth e-mail account has no token store or when there is no Llm section β the runtime
then falls back to the echo provider β, says where the key of the default and of each profile
offered to crews comes from β the profiles its allow-list hides (LlmProfileAccessOptions, which
orkeon-host binds) on one line of their own, never warned about β and resolves the OpenTelemetry tracer and meter
providers, because the runners never start the host and the providers would otherwise never
exist (see Telemetry).
RunnerHost carries an [SuppressVfsCompliance] bootstrap exception because it resolves user-supplied
settings paths and provisions VFS mounts before the DI container (and thus IFileSystemService) exists.
ConfigureRunnerServices behavior
The registration order is deliberate:
- Logging β runner logging (a single-line console at Warning level by default;
--verbose 1/2or aconfigureLoggingcallback raises it) and, whenRunnerMountPlan.LlmLogVirtualPathis set, the LLM exchange loggingDelegatingHandler. - LLM provider first β
RegisterLlmProviderreads theLlmconfig section and registers the provider (and itsIChatClient, on that section's configuration) beforeAddOrkeonApplication/AddOrkeonInfrastructureβ or the echo provider when the section is missing. The infrastructure registers no model of its own: a host that registers none fails at its first LLM resolution, naming the missing service. - Core services β
AddOrkeonApplication()thenAddOrkeonInfrastructure()(the parameterless overload), thenAddOrkeonTelemetry(configuration)for theTelemetrysection. - Strict tools β
CrewFactoryOptions.StrictToolsdefaults totruehere (a crew referencing an unknown tool fails loudly withunknown tool(s): β¦; available: β¦); opt out with"Orkeon:CrewFactory:StrictTools": false. (The library default stays lenient.) The.ork.tssandbox limits and the esbuild toolchain (ScriptingLimitsOptions,ScriptingToolchainOptions) are bound here too and judged at the host's start. - Permission gate β
AddOrkeonPermissionGate(configuration)(config opt-inOrkeon:Security:PermissionGate:Enabled; a no-op otherwise). - Core tool suites β file system, data, web, code, abstractions, session tools; then the
in-memory EventHub plus its agent tools and the EventHub ACL (
AddOrkeonEventHubAcl, permissive default: a crew without alinks:block sends to any other crew); then the e-mail tools (AddOrkeonEmailTools(configuration), inert until an account is declared) and, when an OAuth e-mail account is declared, their token store over the internal/credentialsroot β mounted by the configuration step, reached throughPrivilegedFileSystemAccess; then the drive tools (AddOrkeonDriveTools(configuration), inert until an account is declared) and, when the internal/credentialsroot is mounted, their token store in a subdirectory of their own; then the RAG subsystem and its three tools (AddOrkeonRag,AddOrkeonRagTools). - VFS mounts β
AddOrkeonFileSystemwhenOrkeon:FileSystem:MountsorOrkeon:FileSystem:InternalMountsexists and holds at least one entry (two empty arrays register nothing). Either list alone makes the VFS real:--list-toolshas only the second. Several entries ofMountsmay declare one root when each carries an id:MountSelection.Resolvedecides, while the configuration is composed, which one this run keeps β a--mounton the root, elseSelectedMountIds, elseCrewMountReferencesβ and writes the others tonullat their own index; a selection nothing resolves throws with the very text the runners' guards print, so a host built without them refuses the same way. - Late tool suites β RaggableTree (semantic-graph tools, opt out with
"RaggableTree:Enabled": false; pre-registers local embeddings when they are the selected provider), the WebSearch andcache_searchtools, and the Brave search tool whenBRAVE_API_KEYis present (configuration key or environment variable). - MCP β
AddOrkeonMcp(configuration)when theMCPsection declares at least one server underMCP:ServersandMCP:Enabledis notfalse. Registering is not connecting: the servers are connected by the flows below, before the crew loads (see MCP). No setting starts an MCP server. - Decision models β
RegisterDecisionModels: one active decision provider (TypeSafe, Liquid or Kev), named byOrkeon:Decision:Provideror deduced (theOrkeon:TypeSafeorOrkeon:Liquidsection, even empty, else the one whose key variable is set; none when nothing is present), and the decision profiles ofOrkeon:Decision:Profiles. The start is refused for an unknown provider name, for TypeSafe and Liquid both present without a named provider (both sections, or no section and both keys; with one section, its provider is chosen) (the message names both and the setting), for a Kev address without anhttporhttpsscheme (Orkeon:Kev:BaseUrl), for a Kev key towards a non-localhttpaddress. The start log names the active provider, its model, its address and how it was chosen; every provider section that is not the active one gets a warning ("is ignored: the active decision provider is β¦"), the Kev one adding, when no provider is named, that Kev is never deduced and must be named withOrkeon:Decision:Provider. See Decision models. - Tool registry β nothing of its own:
AddOrkeonInfrastructure()already registered the defaultToolRegistry, which reads everyIBaseToolthe steps above registered when it is first resolved. - Runner services β the caller's
configureServiceshook runs last.
semantic_search is not in this list: it is registered by AddSemanticSearchTool(), which
orkeon run calls through its configureServices hook and orkeon-host does not.
The tool registry (ToolRegistry)
The default IToolRegistry (Orkeon.Infrastructure.Tools, registered by AddOrkeonInfrastructure(),
shipped in the Orkeon package) resolves YAML/TS tool names to IBaseTool instances from DI. Its
constructor takes IEnumerable<IBaseTool> β every tool the tool suites registered β and indexes them by
name (case-insensitive); two tools registered under one name make the constructor throw, naming both
types. CrewFactory consumes it to build agents with their declared tools, which is why every tool suite
registers under IBaseTool: a tool that is not registered cannot be resolved (and, with StrictTools,
fails crew loading rather than silently dropping). RegisterToolAsync adds a tool at run time β the MCP
client does β and refuses (returns false) a name another tool already holds. Reads and run-time
registrations are safe to interleave: orkeon-host runs several crews while its MCP servers connect.
The registry indexes names only β there is no lookup by tag or capability.
RunnerExecution β execution flows
RunnerExecution is the shared execution glue: graceful shutdown (SIGTERM/SIGINT), AutoSummaryWriter
wiring when an /output:rw mount is declared, verbosity presets, and the run flows. All entry points
build the host internally (via the same bootstrap), resolve settings/mounts, and return a process exit
code.
| Entry point | Purpose |
|---|---|
RunOneShotAsync(opts, loggerCategory, configureServices?, externalCt?) |
Runs a single crew kickoff end-to-end. Exit codes: 0 success, 1 config error, 2 crew failure, 75 the run stopped on a question and waits for its answer (--resume), 130 canceled. |
RunInteractiveLoopAsync(opts, loggerCategory, stopWords, kickoffPerInputAsync, onSessionStart, β¦) |
REPL loop; each input drives a kickoff via the caller-supplied delegate; a stop word ends the loop (exit 0). |
RunListToolsAsync(opts, loggerCategory, configureServices?, externalCt?) |
Builds the host with no crew and prints the sorted, de-duplicated runtime tool names to stdout (logs to stderr) β the runtime tool contract consumed by packaging/lint tooling. |
RunValidateAsync(opts, loggerCategory, configureServices?, externalCt?) |
Dry-run behind --validate: builds the host and loads the crew (strict tool resolution) without probing the LLM or running a kickoff. |
LoadCrewAsync(host, factory, configPath, logger, ct, targetIsDirectory?) |
Loads and maps the crew definition from its virtual path (YAML file, crew directory, .ork.ts/.ork.js script) β the building block the flows above share, and what orkeon-host calls per run. It does not connect MCP servers. |
RunOneShotAsync, RunValidateAsync and RunListToolsAsync connect the configured MCP servers
before they load or list anything, so the three see the same tool surface. The guards the CLI runs
before building a host are public too β EnsureReservedRootsAreFree (always adds /credentials),
EnsureVirtualRootsAreUnique, EnsureMountSelectionIsResolvable, EnsureMountSourcesExist β as are
RegisterGracefulShutdown, DetectOutputMountPath, ConfigureVerboseLogging (1: Information for the
Orkeon modules; 2: Debug) and IsScriptedCrewDefinition (.ork.ts / .ork.js).
Consuming from a long-running host
A long-running service can simply wrap RunnerHost.Build β that is exactly what the
orkeon-host daemon does (Orkeon.Host/Program.cs), passing configureBuilder for
UseSystemd()/UseWindowsService(). The daemon stays out of the mount selection: its crews mount under per-crew roots (/crews*), so no root is ever declared twice
there, an operator --mount carrying an id prefix parses like any other, and no crew
mounts: block is read. A host that already owns its IHostBuilder (an ASP.NET
app, for example) instead replicates ConfigureRunnerServices' registration order inside its
own Program.cs β there is no packaged shortcut for this; the REPL console inlines the same
sequence by hand:
// 1. Register the LLM provider (AddOrkeonLlmProvider): AddOrkeonInfrastructure registers no model
// of its own, and a container without one fails at its first LLM resolution.
// 2. Core services:
services.AddOrkeonApplication();
services.AddOrkeonInfrastructure(configuration);
// 3. Tool suites (drive which tools crews can use):
services.AddOrkeonFileSystemTools();
services.AddOrkeonDataTools();
services.AddOrkeonWebTools();
// β¦ the remaining AddOrkeon*Tools() suites β¦
// 4. VFS mounts from configuration (the web host provisions at least one mount):
services.AddOrkeonFileSystem(configuration);
// 5. Nothing for the tool registry: AddOrkeonInfrastructure registered the default
// ToolRegistry, which reads every IBaseTool registered above when first resolved.
Because a web host typically runs each crew in its own DI scope (Orkeon's crew repositories are scoped),
the ToolRegistry β a singleton over the registered IBaseTool set β is shared across runs,
while CrewFactory and the orchestrator resolve per scope.
Telemetry
AddOrkeonTelemetry(configuration) reads the Telemetry section:
| Key | Default | Effect |
|---|---|---|
Enabled |
true |
false registers no provider and no exporter: the meter Orkeon measures for no one. |
OtlpEndpoint |
β | An explicit OTLP endpoint; it wins over the environment. An http:// or https:// address: anything else is refused, naming the key. |
MaxMemoryMB |
2048 |
Threshold of the system_resources health check. |
Console. No setting attaches a console exporter: it would write on stdout, where --events jsonl, the
--list-tools manifest and orkeon mcp serve speak to a program. A C# host that wants the console adds the
exporter to its own AddOpenTelemetry().
Where the data goes. An explicit Telemetry:OtlpEndpoint is used as the exporters' endpoint.
Without one, a non-empty OTEL_EXPORTER_OTLP_ENDPOINT attaches the OTLP exporters with no
Orkeon-specific setting β the exporter then reads the endpoint, the protocol and the headers from the
standard OTEL_EXPORTER_OTLP_* variables itself, which is how a process launched by .NET Aspire
reports with nothing configured. It reads them in the host's configuration, through its layer of
environment variables without a prefix: the reason every Orkeon host keeps that layer, under its
settings file (where settings are read from).
Without either, nothing is exported.
What is exported. Traces from the Orkeon.Crew, Orkeon.Agent, Orkeon.Task, Orkeon.Llm,
Orkeon.Tool, Orkeon.Memory, Orkeon.EventHub and Orkeon.Scripting activity sources plus the HttpClient
instrumentation; metrics from the Orkeon meter plus the runtime and HttpClient instrumentation; and,
whenever OTLP export is on, the structured logs (formatted message and scopes included) to the same
endpoint. The resource names the service Orkeon and gives it the version of the running release (service.version), which the activity sources and the meter report too. The span and metric names follow the OpenTelemetry
GenAI conventions β see Opt-in subsystems.
The section also registers three health checks β llm_provider, memory_provider (which reads a key
that does not exist: every provider serves it, Pinecone and ChromaDB included),
system_resources. orkeon serves no HTTP; orkeon-host exposes them on its opt-in run API (Orkeon:Host:Api): /healthz runs system_resources, /readyz runs memory_provider and, when ReadinessTags lists llm, llm_provider (see the host API).
.NET Aspire β Orkeon.Hosting.Aspire
Orkeon.Hosting.Aspire (package Orkeon.Hosting.Aspire, see the
publication matrix) describes Orkeon processes as resources of an Aspire
AppHost, so the Aspire dashboard shows their spans, metrics and logs
(ADR-011). It runs no crew itself: it launches the
shipped executables, found on the PATH or named by command.
Install. In an Aspire AppHost project (Aspire.AppHost.Sdk):
dotnet add package Orkeon.Hosting.Aspire
dotnet tool install -g Orkeon.Scripting.Cli # the `orkeon` executable AddOrkeonCrewRun launches
orkeon-host comes from the full installer archives or the per-machine service MSI β which
is not code-signed: Windows asks before it runs it, see the
service host β; pass its path as command when it is not on the
PATH. Then dotnet run the AppHost and open the dashboard.
What flows. Into each process: its arguments and the ORKEON_ variables set with
WithOrkeonSetting/WithOrkeonModel, plus the OTEL_EXPORTER_OTLP_* and OTEL_SERVICE_NAME
variables Aspire injects. Out of it: the traces, metrics and structured logs described under
Telemetry, and the console output. Nothing else β no endpoint, no health probe, no
state: the dashboard observes, it does not drive a run.
var builder = DistributedApplication.CreateBuilder(args);
// the orkeon-host daemon, its crews registered in its settings file
builder.AddOrkeonHost("orkeon-host", settingsPath: "host.appsettings.json")
.WithOrkeonSetting("Orkeon:Host:RunTimeout", "00:10:00");
// one `orkeon run`, files under ./out, on a local model
builder.AddOrkeonCrewRun("quickstart", crewPath: "../../quickstart/crew.yaml")
.WithOrkeonModel(new Uri("http://localhost:11434"), "qwen2.5:1.5b");
builder.Build().Run();
| Member | What it does |
|---|---|
AddOrkeonHost(name, settingsPath?, workingDirectory?, command = "orkeon-host") |
An OrkeonHostResource (executable) started as orkeon-host [--settings <settingsPath>] --allow-external-mounts, in workingDirectory (default: the AppHost directory), with the OTLP exporter wired. No endpoint is declared: the daemon's run API and A2A server are opt-in settings (Orkeon:Host:Api, Orkeon:Host:A2A) the resource does not wire. |
AddOrkeonCrewRun(name, crewPath, outputDirectory?, settingsPath?, command = "orkeon") |
An OrkeonCrewRunResource started as orkeon run <crewPath> --mount <output>:/output:rw --allow-external-mounts [--settings <settingsPath>] in the AppHost directory, with the OTLP exporter wired. The output directory (default <AppHost>/out) is created when the resource is declared. |
WithOrkeonSetting(key, value) |
Sets any configuration key through the ORKEON_ environment the runners read: Llm:Model becomes ORKEON_Llm__Model. The key is the full configuration path β the daemon's own keys live under Orkeon:Host, so Orkeon:Host:RunTimeout, not Host:RunTimeout. |
WithOrkeonModel(baseUrl, model, apiKey?) |
Shorthand for Llm:BaseUrl (trailing / trimmed), Llm:Model and, when given, Llm:ApiKey. |
A runnable AppHost lives in
examples/aspire/AppHost.
Microsoft Agent Framework
To run a crew from a Microsoft Agent Framework application β or a MAF agent inside a crew β see
Agent Framework interop: its example builds its host with
RunnerHost.Build and adds the bridge through configureServices.