🇫🇷 Version française

Orkeon Code

CI License: MIT Documentation

Orkeon Code mascot — a chameleon surfing a wave

An agentic coding assistant in TypeScript on the Orkeon runtime. Pair with it in the terminal under a permission mode you choose, let it run a task to the end on its own, or start its crews from a script, a scheduler or your own application. It reads, searches, edits and runs code in your project through tool calls, and everything it can touch is declared: one mounted project, an allow-listed shell, a tool catalogue trimmed by the mode. Every command, crew and prompt is a source file: change it, or add yours.

Status: alpha. The loop, the crews and the permission modes work end to end against real LLMs. Expect rough edges and breaking changes before 1.0.

What it does

  • /assistant: the interactive loop. The model explores the code with search and code-intelligence tools (hybrid code search, symbol source, call graphs, impact analysis), edits files and runs commands, turn after turn, under an execution budget. Free text typed without a leading / goes there.
  • Permission modes: plan (read-only), default (asks you before an edit, a command or a network call), acceptEdits (edits without asking), dontAsk, bypassPermissions, chosen per request (plan: explain the auth flow) or for the session (/mode), plus allow/deny rules on a tool or on its arguments (allow shell_command command=npm test*). The Orkeon runtime enforces them and asks the questions.
  • Tools from MCP servers and plugins: the tools Orkeon connects (MCP:Servers, Plugins) join the assistant's catalogue once tools.extra names them (Configuration).
  • Speech-to-text: a Whisper MCP server ships in mcp/whisper/; ORKEON_CODE_AUDIO_DIR turns it on, and the assistant transcribes voice notes, meetings and screen recordings on your machine; /voice dictates a request and /say reads aloud (Configuration).
  • Crews for the recurring jobs: /init (describe the project for the agent), /commit (a conventional commit from the diff), /review (multi-lens code review; --lens security for the security lens alone), /analyze (deterministic codebase analysis), /compact and /summary (context management), /init-verifiers, /advisor.
  • A dev workflow, step by step: /dev-spec writes the spec or the change brief, /dev-plan cuts it into batches a read-only reviewer questions, /dev-batches runs a plan's batches one after the other, each test-first (red tests, then the least code, then a read-only audit) and closed with a commit (<code> F<n> one batch, <code> F<n> --audit its audit alone), /dev-status says where a piece of work stands and /dev-learn proposes rules from the audits' recurring gaps. Each step runs under deny rules its crew checks again (Permissions).
  • A shared memory: decisions, structures, methods and mistakes the steps recall, admitted only through /memory admit (Shared memory).
  • Context management: automatic compaction with a circuit breaker, snip-first /compact, file restore after compaction, context pressure tiers, typed durable memory (/memory).
  • 48 slash commands in all: docs/commands.md.

Quick start

You need the Orkeon runtime and an API key for an LLM provider Orkeon supports (any OpenAI-compatible endpoint, Anthropic...). Orkeon Code is checked against Orkeon's sources at the commit of .orkeon-version; the releases run it too, behind that pin. Any of these runs Orkeon Code:

  • orkeon-repl of the last release, 1.0.0-rc.6, from the orkeon Debian/Ubuntu package (amd64 and arm64; a release candidate is published on the apt rc channel, the default stable channel carries finals only) or from the Orkeon release archive of your platform (Linux x64 and arm64, macOS x64 and arm64, Windows x64 .zip), self-contained: no .NET to install;
  • Docker: the last orkeon-runners image published (amd64 and arm64; 1.0.0-rc.5, the 1.0.0-rc.6 image is not published), nothing else to install;
  • an Orkeon checkout at the pin, the reference runtime: ORKEON_SOURCE=<checkout> ./orkeon-code --mode source.

Windows: orkeon-code.ps1 has no source mode and no --demo (-Mode takes docker or tool): the tool mode on the release's orkeon-<version>-win-x64.zip is the one for Windows; the path this project exercises is WSL with the bash launcher (tutorial).

Orkeon Code itself installs from a release (install.sh, install.ps1) or from npm (npm install -g orkeon-code@next), or runs from a clone as below. Details: Getting started.

git clone https://github.com/Orkeon/orkeon-code.git ~/orkeon-code
cd ~/orkeon-code
cp config/appsettings.example.json config/appsettings.local.json   # pick the model and endpoint
export DEEPSEEK_API_KEY=...                                        # the variable named by Llm:ApiKeyEnvVar

./orkeon-code --demo              # try it on a throwaway sample repository
cd ~/src/my-project && ~/orkeon-code/orkeon-code                   # or on your project

Then, in the REPL (Read–Eval–Print Loop — the interactive console):

/init                                    describe the project (writes AGENTS.md)
plan: how is the configuration loaded?   read-only question
acceptEdits: add input validation to parseArgs and a test for it
/diff
/commit
/review

How it works

 you ──▶ /command ──▶ *.cmd.ts (src/commands) ──script-host──▶ crew.ork.ts (src/crews)
                                                                   │  ctx.llm.act(): LLM ⇄ tools loop
                                                                   â–¼
                                    Orkeon runtime (.NET): tools, permission gate, VFS, LLM providers
                                                                   │
                                                          /workspace = your project

Orkeon Code is the TypeScript layer: slash commands, crews and the shared domain logic they use. The Orkeon runtime executes them (Jint), provides the tools, enforces the permission gate and confines every file access to the mounted project. The runtime is pinned in .orkeon-version, a commit of Orkeon's main. Details: Architecture.

Interactive, autonomous, embedded

The REPL is one way to run the crews, not the only one.

  • Interactive: ./orkeon-code on your project. plan: to ask, acceptEdits: to let it edit, /mode for the session; in default mode the runtime asks you before an edit, a command or a network call.
  • Autonomous: in bypassPermissions the loop runs a task to the end without a question, under a budget (200 tool calls, 30 minutes, 400k tokens) and the host gate. scripts/run-crew.sh runs the same crew in one shot from a shell, a cron line or a CI job, and prints its result as JSON.
  • Embedded: an application starts the orkeon tool (nuget.org) or the orkeon-runners image on a crew and reads the JSON; Orkeon's orkeon-host daemon can host the crews behind a chat channel or an A2A endpoint. In-process .NET embedding waits for the scripting layer to ship as a package.

Details and limits: Autonomous and embedded runs.

Make it yours

A command is a file in src/commands, a crew is a folder in src/crews, a tool is a toolBuilder() in a crew, a prompt is a string with its test, and the permission modes are a table of tool names. There is no build step: the runtime bundles the TypeScript and runs it at the next start. Your own crews and commands can live outside the checkout (--crews-dir, --commands-dir), and the tools of MCP servers and plugins join the catalogue once tools.extra names them, without a line of code. What moves with each change, and the limits: Extending Orkeon Code.

Documentation

The pages below are published as a browsable site, with a search box: https://orkeon.github.io/orkeon-code/. The same pages exist in French; the decisions (ADR) are written in English only.
Getting started Docker, tool and source modes, first session
WSL tutorial Speech and a local model on WSL2, on the GPU, step by step
Configuration LLM providers, settings file, environment variables
Permissions Modes, rules, what the agent can touch
Hooks Your commands around the model's tool calls in the dev steps
Shared memory Admitted decisions, structures, methods and mistakes the agents recall
Slash commands The full list (generated)
Architecture Layers, ports, crews, the loop, prompt assembly, recipes
Autonomous and embedded runs Unattended turns, one-shot runs, schedulers and CI, your application
Extending Commands, crews, tools, prompts, modes, your own directories, the limits
Development Tests, checks, typings, upgrading Orkeon, releasing
Roadmap What is missing and what comes next

Contributing

Issues and pull requests are welcome: read CONTRIBUTING.md first. A problem in the runtime itself (tools, VFS, providers, the REPL host) belongs to Orkeon/orkeon. Security reports follow SECURITY.md.

License

MIT © 2026 Orkeon Contributors.

Edit this page