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.
dotnet tool install -g Orkeon.Scripting.CliRequires the .NET 10 SDK. Other ways to install
sudo apt install orkeon orkeon-archive-keyringBefore the first install, add the signed apt source once.
tar -xzf orkeon-cli-*-osx-arm64.tar.gz && cd orkeon-cli-*-osx-arm64 && ./install.shDownload the archive from the releases page (new tab) (osx-x64 on Intel). It is not notarized: verify it before extracting it.
The installer is unsigned: verify its checksum before running it.
Version 1.0.0, one maintainer (where the project stands). Models: OpenAI, Anthropic, Mistral, Gemini and other providers, including Ollama locally.
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)
/// <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).
$ 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.
Orkeon is for three audiences
Each audience has its own first step. The same runtime executes their teams.
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.
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.
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).
Each first step happens on your machine.
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$ orkeon run crew.yaml --mount ./out:/output:rw
out/hello.md is written by an agent that saw only /output, never out/.
$ 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.
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.
- 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.
- What is sensitive stays closed until a human opens it. Sending mail stays blocked until an operator has opened the recipient allow-list.
- 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.
- The rule can bind the code itself. The
Orkeon.Compliance.Vfsanalyzer (new tab), once added to a project, makes any direct file access throughSystem.IOa 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
- One team, three notations, one runtime. It can be written in YAML, TypeScript or C#.
- 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.
- 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
- 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 claudeswitches provider without touching the team (proof). - 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
- 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.
Five doors, one runtime
You do not need to write C# to use Orkeon.
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.
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)
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).
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.
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.