Orkeon
Security

Trust is built in the runtime, not in the prompt.

An instruction in a prompt is a request: the model may ignore it. A rule in the runtime is a limit: it applies whatever the model decides.

Kama, boxing gloves on, has knocked out a folder marked “Refused”; a folder marked “Accepted” jumps for joy
Key points

Orkeon guarantees a perimeter

An agent reaches only what was declared, with the rights declared, within the budget allotted.

What happens inside is not guaranteed: the known limits.

The boundary

What the runtime enforces

  1. An agent sees only virtual paths (new tab)

    Each path corresponds to a mounted folder, read-only or read-write. Outside the mounts, access is refused to the file tools.

  2. Code runs in a sandbox, the shell under its own confinement (new tab)

    In a container, this confinement is turned off: the shell sees what the container sees, and it is the container that must be hardened (hardened profile).

  3. What is sensitive stays closed until a human opens it (new tab)

    Mail and drive are closed by default: sending and sharing go only to the addresses an operator has listed. When a host turns on the permission gate, an action that needs approval goes to the host’s approval channel, and so to a person, and it is refused if the host has none: the model cannot grant it to itself. Opening access is a human decision, never an agent’s deduction.

  4. Autonomy has a budget (new tab)

    An autonomous run operates under the budget the team declares, with five dimensions: tool calls, delegation depth, duration, tokens, spawned agents. Circuit breakers interrupt loops. The other orchestration modes are bounded by the token and cost cap that the host (the application that starts the runtime) sets; there is none by default.

  5. Five other layers apply automatically (new tab)

    The web and HTTP tools refuse private and local addresses. Guardian is a heuristic filter against prompt injection. Tool results reach the model marked as data. Secrets are redacted in the logs. Each tool call an agent makes is recorded in the audit trail.

The rule can bind the code itself. In a C# application, a developer could bypass the virtual file system without meaning to, by writing directly to disk. Once the Roslyn analyzer Orkeon.Compliance.Vfs (new tab) is added to a project, any direct file access through System.IO becomes a compile error in that project. It is a standalone package, usable in any C# project, with or without Orkeon.

Threats and limits

What Orkeon guarantees, and what it does not

Threats
Injected content, a model that is wrong or that is being manipulated. A malicious operator is not covered: they write the configuration.
Guaranteed
A perimeter: mounts and rights, listed recipients, confined shell (except in a container), sandboxed code, the budget the team declares in autonomous mode.
Not guaranteed

What the boundary does not judge

  • An agent can be wrong. The boundary contains the consequences of a mistake; it does not make the result right. Human review remains necessary where the stakes call for it.
  • A right that was granted can be misused. In a folder opened for writing, an agent can write what it should not. The boundary is only as good as the precision of its declarations.
  • What an agent reads is sent to the model. With a cloud provider, that data leaves the company; with a local model, it stays inside. Orkeon allows both and leaves the choice to the people accountable for it.

What stays open until you close it

  • The web tools reach the whole public web until the domain list is declared.
  • There is no token or cost cap by default. Without a declared budget, an autonomous run caps neither tokens nor duration. The other three dimensions then keep their default values: 50 for tool calls (counted per dispatched task), 4 for depth (counted in delegations), 10 for spawned agents.
  • Still opt-in (new tab): the permission gate, data loss prevention, memory encryption and per-tool limits.
  • In the plan and dontAsk permission modes, an outgoing GET is still allowed: these modes leave the workspace unchanged, but the URL can carry data out.
  • AllowHostExecution, a setting that is off by default, lets code run on the machine where the runtime runs, outside the sandbox, when Docker is absent.

What the filters and the confinement do not cover

  • Guardian is a heuristic filter, outside the guarantee: a rephrased attack can get past it.
  • Marking tool results is only a hint: the model may ignore it.
  • In a container, the shell is not confined: it sees the process that holds the API keys.
  • A tool called directly by the code of a .ork.ts file does not go through the invocation point.

What the logs keep, and what remains to be proven

  • The audit trail does not record arguments: no data is copied into it, but nothing in it says what a tool read or sent.
  • RetentionDays, the audit retention period, is not applied yet: rotation is up to the operator.
  • --llm-log keeps the processed data in clear text; this log is never purged automatically.
  • MCP and A2A, the two interoperability protocols, are still experimental.
  • The drive tools have yet to be proven on real accounts.

What the delivery does not provide

  • The container image carries no provenance attestation (new tab): pin it by its digest (@sha256:…).
  • orkeon-host, the service that hosts teams on a server, is neither a cluster nor a scheduler; it comes from the full archive on the releases page (or its .msi on Windows), not from the apt package.
The hardened profile, the tightened configuration for a container, comes down to two settings and one command

For a real run, replace --network none with a network limited to the model provider.

appsettings.jsondocs/reference/configuration.md
{
  "Security": {
    "Url": { "AllowedDomains": [ "docs.example.org" ] },
    "ToolResults": { "Policy": "Block" }
  }
}
docker run --rm --network none --read-only --cap-drop ALL \
  --security-opt no-new-privileges --user 1000:1000 \
  --tmpfs /tmp --tmpfs /home/ubuntu:uid=1000,gid=1000 \
  -v "$PWD:/workspace" ghcr.io/orkeon/orkeon:1.0.0 \
  run /workspace/crew.yaml --validate

The example uses a tag from the releases page (new tab); on a server, replace it with the digest.

Proof

Replay the refused write

refusedAn agent tries to write to a folder mounted read-only.
$ 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 command from the README, run by continuous integration (CI).

Guardian (new tab) is heuristic: its refusal can vary from one run to the next. Outside a container, without a confinement (new tab) backend (bubblewrap on Linux, Seatbelt on macOS, AppContainer on Windows), the shell refuses to run. This shell refusal was recorded in October 2026.

Reporting

Report a vulnerability privately

Write to contact@orkeon.org or use GitHub’s private reporting, never a public issue. The security policy (new tab) says what to include.

Further reading

Documentation