This release

  • Executor 1.0.0Version
  • Early previewChannel
  • PublishedStatus
  • 14 November 2026Published
  • 6Build targets

Status: Published

Install it with one command: curl -fsSL https://openeng.ai/executor/install | bash. Get the Executor explains what the installer does, Windows and uninstalling.

FilePlatformSizeSHA-256
oee-1.0.0-linux-x86_64Linux x86_6420,805,072 bytes632c226e773cfeeafee87080f6b1dcdd6da62728ba3c62f2b6efe16b925e76fc
oee-1.0.0-macos-aarch64macOS aarch6413,785,152 bytes357425e67493dd262bbfb56ebcc49a598aeb3379376080a3078e481616c45485
oee-1.0.0-macos-x86_64macOS x86_6416,570,240 bytesf3edd80a285befe15c0ffe67ad105e9957c881a19fe8e0cc4c45be53012a82aa

oee update checks the signed release feed and replaces oee only after it verifies the file's signature and digests.

One signed binary per application

  • oee build packages the application, its portable language runtime and its signed policy on top of the native Rust supervisor oee-stub into a single standalone executable.
  • The executable has five integrity-protected segments: the supervisor, the Ed25519-signed policy manifest, the zstd-compressed runtime archive, the zstd-compressed application bundle and a fixed 128-byte OEE! footer with the segment offsets, a BLAKE3 Merkle root over segments 1 to 4 and a 64-byte Ed25519 signature.
  • oee build selects the smallest supervisor variant that satisfies the manifest: core (limit: under 4.5 MB, 3.86 MB measured on the Linux x86_64 baseline; integrity verification, sandboxing, native capping and every exit event except message brokers and the inbound webhook) or extended (limit: under 6.0 MB, 5.26 MB measured; adds Kafka, MQTT, NATS and Redis sources, the inbound webhook, the auto-scaler and the built-in load balancer).
  • Python, JVM and Node.js workloads are extracted once into a content-addressed, read-only runtime cache (~/.cache/oee/runtimes/<blake3-merkle-root>/, overridable with OEE_CACHE_DIR); later starts reuse the verified cache.
  • Builds for another platform: oee build --target builds, for example, a windows-x86_64 binary from Linux CI.

Polyglot runtimes

  • Native binaries (Go, Rust, C, C++): compiled ELF, PE or Mach-O executables, compressed into the application segment with no runtime segment.
  • Python 3.10 to 3.13: a .py entrypoint, .whl wheels, requirements.txt, pyproject.toml or a full project directory (uvicorn, FastAPI, Celery), bundled with a relocatable python-build-standalone interpreter and isolated from host Python packages (PYTHONNOUSERSITE=1).
  • Java and Kotlin on the JVM 17, 21 and 25: a fat .jar, a .war or a modular JAR directory, with a minimal stripped JRE assembled by jlink and jdeps at build time and container-aware heap sizing.
  • Node.js, Deno and Bun: .js, .mjs or .ts entrypoints with package.json and a lockfile, with a static runtime binary and a deterministic node_modules bundle.

Command-line tool

  • oee init detects the project (pyproject.toml, requirements.txt, go.mod, pom.xml, package.json) and scaffolds an annotated oee.yaml; oee init --interactive walks through application, runtime, start command, exit events, capping, auto-scaling, sandbox and build target, and prints the exact oee build command to run next.
  • oee validate --strict checks manifest syntax, sandbox path permissions, cron expressions, JSONPath queries and environment variable references before building.
  • oee keygen generates the Ed25519 key pair (oee.key to sign, oee.pub to verify); oee build --sign-key signs the policy.
  • oee inspect verifies a built binary and prints its policy summary, target OS and architecture and bundled runtime versions.
  • oee run runs any local command under the sandbox and exit event engine without building a binary first.
  • oee status reports running instances: process tree count, sandbox state, uptime, last exit event poll, resolved caps with current usage, replica count and load balancer backend health. oee stop stops an instance gracefully or immediately through an authenticated local control socket.
  • oee runtime list | fetch | verify manages the portable CPython, jlink JDK and Node.js distributions in the local build cache.
  • oee update checks the signed feed at https://releases.openeng.ai/executor/feed.json and installs a newer release (oee update --check exits 10 when an update is available); oee changelog [--since VERSION] shows the release notes; a one-line notice about a new version follows commands on a terminal, and the feed is checked at most once every 24 hours.

Kernel-enforced sandboxing

  • Sandboxing is one declarative switch, sandbox.enabled. With it off, the application runs on the host under the Executor's process-tree supervision and exit event control; with it on, the Executor isolates it without root privileges or a hypervisor.
  • Five isolation dimensions: process tree containment, filesystem access control, system call filtering, network isolation and resource quotas.
  • Linux: user and PID namespaces with a child subreaper, mount namespaces with Landlock LSM path allowlists, seccomp-BPF compiled in pure Rust, network namespaces with port and CIDR rules, and cgroups v2 quotas. Windows: Job Objects, AppContainer with explicit NTFS grants, process mitigation policies and Windows Filtering Platform rules. macOS: process groups tracked with kqueue, Seatbelt profiles for files, network and kernel calls, and setrlimit quotas.
  • read_only_paths and read_write_paths declare exactly what the application may read and change; files written to read_write_paths persist after it stops, and reads of paths outside the policy, such as ~/.ssh or ~/.aws, are refused by the kernel.
  • Three system call presets: strict (default for Go and Rust static binaries), runtime-managed (selected for Python, JVM and Node.js, keeping JIT memory transitions) and custom.
  • Inside unprivileged Docker containers and Kubernetes Pods, container_fallback: "auto" layers Landlock, seccomp-BPF, subreaper containment and setrlimit quotas without --privileged or added capabilities; "strict" refuses to start when a requested primitive is unavailable.
  • With network sandboxing on, the supervisor keeps polling its HTTPS exit event endpoint while the application itself cannot reach the internet.

Native CPU and memory capping

  • Declare CPU and memory as a share of the machine ("10%") or as an absolute amount ("1vcpu", "10GB", "512MB"); percentages resolve once at startup against the host, or against the enclosing container's own limits.
  • strict mode is a hard ceiling that is never exceeded and never changed at run time; flexible mode is a soft target with an optional burst_limit. CPU and memory choose their mode independently.
  • Caps are sealed into the signed binary: no environment variable, CLI argument, control-socket command or remote response can raise or disable them. Changing a cap takes a new signed build.
  • Caps apply to the whole process tree, so forked workers share one budget. Linux uses cgroups v2 (cpu.max, memory.max with swap disabled), Windows uses Job Object CPU rate and memory limits, macOS uses supervisor governors.
  • When a strict cap cannot be enforced on a host, the Executor refuses to start with exit code 69 instead of silently downgrading it; the enforcement tier is printed in the startup audit event.

Exit events of any type

  • An exit event is any condition that ends the application cleanly. Any number of rules combine under ANY or ALL, and each rule may set its own stop mode.
  • Time: a monotonic duration (after: "1h") that clock changes cannot extend, a cron cutoff window, a fixed timestamp and an idle timeout.
  • Utilization: CPU, memory, process count, disk used or disk free above or below a threshold for a sustained period, with the dedicated exit code 76.
  • Remote HTTP and HTTPS polling at any interval with jitter, GET, POST or HEAD, heartbeat payloads with live supervisor metrics, and stop conditions on JSONPath fields ($.ep_flag equals "ABC"), text, regular expressions, status codes or headers.
  • Authorization from from_env (scrubbed from the application's environment by default), from_file or a sealed token: Bearer, custom header, Basic, HMAC-SHA256 request signing or mutual TLS; or none for open endpoints. TLS 1.3 with SPKI certificate pinning and optional Ed25519-signed responses.
  • check_before_start blocks startup with exit code 78 when a stop is already active; FAIL_OPEN keeps running through transient outages, FAIL_CLOSED stops after max_consecutive_failures with exit code 75.
  • External sources: an inbound webhook on loopback with optional bearer or HMAC authorization, file_watch (deleted, created, modified or matching content), tcp_probe for dependencies, process_watch for a parent or PID file, and a command probe for any other system.
  • Messages: kafka, mqtt, nats and redis subscriptions over plaintext or TLS, with each broker's native authentication.
  • Application: authenticated local IPC checkpoints (OEE_IPC_SOCKET, OEE_IPC_TOKEN), log_match on standard output and error, on_task_complete for batch jobs, an operating-system signal, and oee stop for operators.

State-preserving stop pipeline

  • Every stop runs one five-stage pipeline: latch the stop and record an audit event, deliver the graceful stop signal to the whole process group, wait up to grace_period_ms, terminate the remaining tree (cgroup.kill, TerminateJobObject or SIGKILL across tracked descendants) and flush output before exiting.
  • GRACEFUL mode lets uvicorn, Go HTTP servers and JVM shutdown hooks drain requests; IMMEDIATE mode halts the tree at once. No worker process is left orphaned.
  • The built binary, the runtime cache, logs and every file the application created stay intact on disk.
  • Deterministic exit codes for Docker restart policies, Kubernetes Jobs, systemd units and CI pipelines.

Native auto-scaling and built-in load balancer

  • With autoscale.enabled, the supervisor starts another replica of the same service on another free port when usage stays above the upper threshold, and removes the newest replica when usage stays below the lower threshold, between min_replicas and max_replicas.
  • Separate thresholds, sustained-breach windows, a cooldown after every action and one replica per decision prevent oscillation.
  • Each replica is held to its own cap; the optional autoscale.total_limits is a hard ceiling across all replicas.
  • A new replica receives traffic only after its readiness check passes; crashed replicas are replaced with exponential backoff.
  • The load balancer runs inside the supervisor: tcp or http mode, round_robin or least_connections, active and passive health checks and connection draining. With network sandboxing on, only the public port is exposed.

Containers

  • A binary built with the Executor runs as PID 1 in scratch, distroless and alpine images: it forwards container stop signals, reaps zombie processes and exits with the deterministic exit code, so the container stops with its logs and mounted volumes intact.

Performance limits and measurements

The limits Executor 1.0.0 is held to, with the values measured on the Linux x86_64 baseline. The Python, JVM and Node.js start budgets are provisional. macOS and Windows are not verified.

MetricLimit and measured value
Supervisor binary overheadLimit under 4.5 MB per wrapped executable for the core variant (3.86 MB, 3,863,768 bytes, measured) and under 6.0 MB for the extended variant (5.26 MB, 5,264,600 bytes, measured); stripped static Rust supervisor, Linux x86_64 baseline.
Startup overheadNative Go and Rust binaries: under 15 ms warm (5.7 ms measured) and under 350 ms on a first run with cold cache extraction (28 ms measured). Python, JVM and Node.js workloads: provisional budgets of under 50 ms warm (20 ms measured for Python) and under 10 s on a first run (4.4 s measured for Python); 15 ms and 350 ms remain the long-term goal. Linux x86_64 baseline.
Supervisor footprintUnder 6 MB RSS and under 0.1% CPU at a 1-minute HTTP exit event polling interval, core variant, no load-balancer connections.
Immediate stop latencyUnder 5 ms from exit event evaluation to complete process-tree termination in IMMEDIATE mode across 50 concurrent worker processes.
Strict cap accuracyWith kernel enforcement, CPU usage never exceeds the limit by more than 2% over any 1-second window, and memory never exceeds the limit at all.
Load balancer overheadUnder 1 ms added median latency per proxied connection on loopback, and under 20 KB supervisor memory per idle proxied connection in tcp mode.
Scale-out reactionA new replica launches within 1 s of the scale-out window elapsing and receives traffic within 100 ms of passing readiness.
Manifest and payload integrityAny byte modification to the supervisor, the embedded policy or the bundled runtime archive fails BLAKE3 and Ed25519 verification before the application starts.

Exit codes

Every stop ends with a deterministic exit code, so Docker restart policies, Kubernetes Jobs, systemd units and CI pipelines can act on the cause.

Exit codeCauseMeaning
Guest code (0 to 255)Normal guest exitForwards the wrapped application's own exit code.
0Checkpoint stopThe application reached its completion checkpoint and stopped cleanly.
78Pre-launch exit gate blockA remote exit event was already active before the application started.
75Exit event lease lost (FAIL_CLOSED)The control endpoint was unreachable past max_consecutive_failures.
69Required enforcement unavailableA strict cap or a strict sandbox primitive cannot be enforced on this host, so the application never started.
70Sandbox quota or policy violationThe application exceeded a strict memory cap or PID quota, or triggered a fatal system call trap.
124Time-based exit eventA duration, schedule, timestamp or idle timeout was reached.
76Utilization exit eventCPU, memory, process count or disk usage stayed beyond its threshold for the configured period.
143External or message exit eventA remote response, webhook, file event, message, probe, watched process or configured signal matched its rule; also used for oee stop.

Build targets

Executor 1.0.0 is specified for Linux x86_64, Linux aarch64, macOS aarch64, macOS x86_64, Windows x86_64, OCI/Docker. Enforcement differs by platform, as the requirements and limits below say.

PlatformArchitectureBuild
Linuxx86_64Static musl executable, no glibc version coupling
Linuxaarch64Static musl executable, no glibc version coupling
macOSaarch64Native Mach-O executable
macOSx86_64Native Mach-O executable
Windowsx86_64Static MSVC CRT executable
OCI/DockerLinux images of the listed architecturesRuns as PID 1 in scratch, distroless and alpine images

Requirements and limits

  • A strict CPU or memory cap needs a kernel-enforced hard limit: on Linux a delegated cgroups v2 subtree or a transient systemd scope. Where none is available, the Executor refuses to start with exit code 69 unless the manifest opts in to the supervisor governor with resources.allow_governor_fallback: true.
  • On macOS, CPU and memory caps are enforced by supervisor governors that sample the process tree, with a documented sampling tolerance.
  • Inside unprivileged containers, namespace isolation is replaced by the primitives the container permits (Landlock, seccomp-BPF, subreaper containment, setrlimit); use container_fallback: "strict" to refuse to start instead.
  • Auto-scaling needs a cap on every metric it scales on, and runs replicas on one host.
  • Message-broker exit events, the inbound webhook, the auto-scaler and the load balancer need the extended supervisor variant (limit: under 6.0 MB, 5.26 MB measured); every other capability fits the core variant (limit: under 4.5 MB, 3.86 MB measured).
  • Other messaging systems, such as AMQP and cloud queues, are reached through the webhook or command probe exit events.

Verify a binary built with the Executor

Verify Executor builds

Terminal
oee inspect ./dist/my-service --verify-key ./certs/oee.pub

oee inspect checks the OEE! footer, the BLAKE3 Merkle root across the supervisor, policy, runtime and application segments, and the Ed25519 signature, then prints the embedded policy summary, the target OS and architecture and the bundled runtime versions.

The command-line tool itself

Verification details for the oee command-line tool are published with the release.

How Executor versions and channels work.

Early preview — message us for access

Executor 1.0.0 is in early preview. Install it with one command, or write to us for a platform that has no build yet.