Orkeon
Open-source framework · .NET 10 · MIT

AI agent teams that stay inside the lines.

Every file, endpoint and budget an agent may use is declared, then enforced by the runtime. The team you tuned is the one that is integrated into the application, without a rewrite.

For example: mail sorted, replies left as drafts; a weekly briefing, sent to a closed list.

.NET, all systems
dotnet tool install -g Orkeon.Scripting.Cli

Requires the .NET 10 SDK. Other ways to install

Version 1.0.0, one maintainer (where the project stands). Models: OpenAI, Anthropic, Mistral, Gemini and other providers, including Ollama locally.

crew.yamlexamples/quickstart
name: "quickstart"
goal: "Write a short note about what an agent can and cannot touch in this run"
process: "sequential"

agents:
  scribe:
    role: "Scribe"
    goal: "Write one short markdown note to /output/hello.md"
    tools: ["file_write"]
    maxIter: 3

tasks:
  write_note:
    description: |
      Call file_write exactly once with path "/output/hello.md"
      … Then answer with the single word DONE.
    expectedOutput: "The word DONE after /output/hello.md has been written"
    agent: "scribe"

The agent sees /output, never your disk: a mount maps this virtual path to a real folder, with its rights. The YAML schema (new tab)

summarize.ork.tsexamples/scripting/03-mixed-llm
/// <reference orkeon-script="1.0" />
const summarizer = agentBuilder()
    .name("Summarizer").role("Editor").goal("Summarize a text in one sentence")
    .body(async (input, ctx) => {
        const text = "Orkeon enables collaborative AI agent teams.";
        const summary = await ctx.llm.complete(`Summarize in one sentence: ${text}`);
        return { summary };
    })
    .build();

const crew = crewBuilder().withAgent(summarizer).build();
globalThis.result = await crew.run();

A .ork.ts file is a team in its own right. Write a crew in TypeScript (new tab)

// host: your application’s .NET host, with the Orkeon services registered (see Bootstrap)
// the path is virtual: it is read through the /config mount
var crewFactory = host.Services.GetRequiredService<ICrewFactory>();
var crew = await crewFactory.CreateFromFileAsync("/config/crew.yaml");

var orchestrator = host.Services.GetRequiredService<ICrewOrchestrationService>();
var output = await orchestrator.KickoffAsync(crew.Id, CrewInput.Empty("Write the note"));
if (!output.Succeeded) Console.Error.WriteLine(output.Error);

The YAML team loaded into your .NET application: an excerpt from Bootstrap and execution (new tab).

orkeonthe CLI, same runtime
$ orkeon run crew.yaml --mount ./out:/output:rw
$ orkeon forge "sort my mail every morning"
$ orkeon run crew.yaml --validate
$ orkeon mcp serve   # experimental

Run a team, generate one from a sentence (orkeon forge), validate it without calling the model, serve Orkeon’s tools to an MCP client (Model Context Protocol). CLI reference (new tab)

A team (a crew in the code) is a set of agents, each with a role; the runtime is the engine that executes it and enforces the rules.

Who it is for

Orkeon is for three audiences

Each audience has its own first step. The same runtime executes their teams.

.NET teamsdoor: the Orkeon NuGet package

Put agents into production without leaving the .NET ecosystem

Orkeon is added to a .NET application as a NuGet package; no service is required. An inconsistent team is refused at load time, before the first call to the model.

First stepdotnet add package Orkeon (and Orkeon.Tools for the built-in tools), then run an agent on a local model.

Write a team · NuGet (new tab) · Try it locally

Architects and security officersdoor: the orkeon CLI

Say precisely what an agent is allowed to do

Each folder is mounted read-only or read-write; any other path is refused to the file tools.

In a container, the shell is not confined. By default, the web tools reach the whole public web and no cost cap is set. More fundamentally, an agent can be wrong, a right that was granted can be misused, and what an agent reads is sent to the model. Security: guaranteed, not guaranteed

First stepReplay the refused write to a read-only folder.

Try it locally · Security · Deploy · Comparison

Business teamsdoor: Orkeon Studio

Automate a task without writing code, knowing exactly what your agents have access to

Orkeon Studio is a desktop application for Windows. Two terminal applications cover Linux, macOS and Windows. Studio drives the orkeon CLI, which must be installed first.

First stepInstall the CLI, then Studio from its repository (unsigned installer).

Orkeon Studio · The five doors

Each first step happens on your machine.

Two minutes · local model

Try it locally: the write allowed, then refused

With Ollama and the .NET 10 SDK installed, the trial takes two minutes, with no API key.

$ ollama pull qwen2.5:1.5b
$ dotnet tool install -g Orkeon.Scripting.Cli
$ orkeon quickstart && cd orkeon-quickstart
terminalwritten
$ orkeon run crew.yaml --mount ./out:/output:rw

out/hello.md is written by an agent that saw only /output, never out/.

terminalrefused
$ orkeon run crew.yaml --mount ./out:/output:ro
file_write [FAIL]: Error: Access denied for '/output/hello.md':
required Write, effective ReadOnly. Mounts granting Write: (none).

The refusal happens before a single byte reaches the disk.

The repository’s continuous integration (CI) runs both commands on every change.

Two convictions, ten principles

A rule in the runtime applies whatever the model decides

Trust is built in the runtime, not in the prompt. What you tune must be what you deploy.

A. A boundary declared, then enforcedprinciples 1 to 4
  1. What an agent may touch is declared. Outside the mounted folders, any path is refused to the file tools; the shell runs under its own confinement.
  2. What is sensitive stays closed until a human opens it. Sending mail stays blocked until an operator has opened the recipient allow-list.
  3. Autonomy has a budget. An autonomous run operates under the budget the team declares; without a declared budget, neither tokens nor duration are capped. The other modes are bounded by the token and cost cap that the host (the application that starts the runtime) sets; there is none by default.
  4. The rule can bind the code itself. The Orkeon.Compliance.Vfs analyzer (new tab), once added to a project, makes any direct file access through System.IO a compile error in that project; it is a standalone package, usable with or without Orkeon.

Without a declared domain list, the web tools reach the whole public web. Guardian, the heuristic filter against prompt injection, remains outside the guarantee. Security: guaranteed, not guaranteed

Architecture: Boundary · Budget

B. From idea to application, with no break in betweenprinciples 5 to 7
  1. One team, three notations, one runtime. It can be written in YAML, TypeScript or C#.
  2. The team you tuned is the team you integrate. Only the configuration changes. Orkeon Code, the project’s coding assistant, is built on this same runtime.
  3. An agent is software, not a script. A team is deployed, keeps its state (opt-in) and is observed like a service.

Architecture: Orchestration · State · Observability · Extensibility · Delivery

C. An open projectprinciples 8 to 10
  1. Standards, not lock-in. Orkeon plugs into MCP and A2A (Agent-to-Agent), both still experimental, and into Microsoft Agent Framework. The choice of model stays yours: --llm-profile claude switches provider without touching the team (proof).
  2. A door for each profile. You do not need to write C#. Only Orkeon Workshop, the containerized workshop, relies on Claude Code. The five doors
  3. Open and verifiable. Orkeon is under the MIT license; its known limits (new tab) are documented with the project.

Architecture: Interoperability · Public checks

Each proof links to the repository, its documentation or its CI.

A door for each profile

Five doors, one runtime

You do not need to write C# to use Orkeon.

Orkeon Studiowithout code or a terminal · Windows desktop

Create a team without code or a terminal, in four steps

For business teams: describe, compose, try, adopt.

Studio is a desktop application for Windows; its installer is unsigned. Two terminal applications cover Linux, macOS and Windows. Studio drives the orkeon CLI, which must be installed first.

Orkeon Studio · Orkeon/orkeon-studio (new tab)

orkeonthe CLI

Run a team, or generate one from a sentence

In a terminal or a script, orkeon run runs a team and orkeon forge generates one.

A generated team is, by default, adopted only after a person’s verdict.

Install Orkeon · CLI reference (new tab) · Orkeon/orkeon (new tab)

Orkeon Codethe coding assistant · terminal

The project’s coding assistant is built on the Orkeon runtime

Orkeon Code explores, modifies and reviews code, in a terminal or unattended.

Each new version of Orkeon is pinned and proven in it: the pull requests that attest to it (new tab).

Orkeon/orkeon-code (new tab)

Orkeon Workshopthe workshop · containerized

Design, test and measure teams in a ready-to-use workshop

For developers, the workshop is a container image that relies on Claude Code, with the orkeon CLI and local models.

A paid run waits for your approval.

Orkeon/orkeon-workshop (new tab)

Orkeonthe NuGet package

Integrate the runtime into your own applications

For .NET teams: dotnet add package Orkeon adds the runtime to an application, and Orkeon.Tools the built-in tools.

A team written in YAML or TypeScript can stay there.

NuGet (new tab) · Bootstrap and execution (new tab) · Write a team

Five doors, four repositories: the CLI and the NuGet package share the runtime’s.