Early preview
Executor 1.0.0 release notes
Executor 1.0.0 is the first version of the Executor: a native runtime wrapper, operating-system sandbox supervisor and exit event engine, operated through the oee command-line tool. It packages an application, its language runtime and its security policy into one standalone executable that runs the application under every restriction you configure.
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.
| File | Platform | Size | SHA-256 |
|---|---|---|---|
oee-1.0.0-linux-x86_64 | Linux x86_64 | 20,805,072 bytes | 632c226e773cfeeafee87080f6b1dcdd6da62728ba3c62f2b6efe16b925e76fc |
oee-1.0.0-macos-aarch64 | macOS aarch64 | 13,785,152 bytes | 357425e67493dd262bbfb56ebcc49a598aeb3379376080a3078e481616c45485 |
oee-1.0.0-macos-x86_64 | macOS x86_64 | 16,570,240 bytes | f3edd80a285befe15c0ffe67ad105e9957c881a19fe8e0cc4c45be53012a82aa |
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 buildpackages the application, its portable language runtime and its signed policy on top of the native Rust supervisoroee-stubinto 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 buildselects 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) orextended(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 withOEE_CACHE_DIR); later starts reuse the verified cache. - Builds for another platform:
oee build --targetbuilds, for example, awindows-x86_64binary 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
.pyentrypoint,.whlwheels,requirements.txt,pyproject.tomlor a full project directory (uvicorn, FastAPI, Celery), bundled with a relocatablepython-build-standaloneinterpreter and isolated from host Python packages (PYTHONNOUSERSITE=1). - Java and Kotlin on the JVM 17, 21 and 25: a fat
.jar, a.waror a modular JAR directory, with a minimal stripped JRE assembled byjlinkandjdepsat build time and container-aware heap sizing. - Node.js, Deno and Bun:
.js,.mjsor.tsentrypoints withpackage.jsonand a lockfile, with a static runtime binary and a deterministicnode_modulesbundle.
Command-line tool
oee initdetects the project (pyproject.toml,requirements.txt,go.mod,pom.xml,package.json) and scaffolds an annotatedoee.yaml;oee init --interactivewalks through application, runtime, start command, exit events, capping, auto-scaling, sandbox and build target, and prints the exactoee buildcommand to run next.oee validate --strictchecks manifest syntax, sandbox path permissions, cron expressions, JSONPath queries and environment variable references before building.oee keygengenerates the Ed25519 key pair (oee.keyto sign,oee.pubto verify);oee build --sign-keysigns the policy.oee inspectverifies a built binary and prints its policy summary, target OS and architecture and bundled runtime versions.oee runruns any local command under the sandbox and exit event engine without building a binary first.oee statusreports 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 stopstops an instance gracefully or immediately through an authenticated local control socket.oee runtime list | fetch | verifymanages the portable CPython,jlinkJDK and Node.js distributions in the local build cache.oee updatechecks the signed feed at https://releases.openeng.ai/executor/feed.json and installs a newer release (oee update --checkexits 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, andsetrlimitquotas. read_only_pathsandread_write_pathsdeclare exactly what the application may read and change; files written toread_write_pathspersist after it stops, and reads of paths outside the policy, such as~/.sshor~/.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) andcustom. - Inside unprivileged Docker containers and Kubernetes Pods,
container_fallback: "auto"layers Landlock, seccomp-BPF, subreaper containment andsetrlimitquotas without--privilegedor 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. strictmode is a hard ceiling that is never exceeded and never changed at run time;flexiblemode is a soft target with an optionalburst_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.maxwith swap disabled), Windows uses Job Object CPU rate and memory limits, macOS uses supervisor governors. - When a
strictcap 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
ANYorALL, and each rule may set its own stop mode. - Time: a monotonic
duration(after: "1h") that clock changes cannot extend, acroncutoff window, a fixedtimestampand anidletimeout. - 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,POSTorHEAD, heartbeat payloads with live supervisor metrics, and stop conditions on JSONPath fields ($.ep_flagequals"ABC"), text, regular expressions, status codes or headers. - Authorization from
from_env(scrubbed from the application's environment by default),from_fileor 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_startblocks startup with exit code 78 when a stop is already active;FAIL_OPENkeeps running through transient outages,FAIL_CLOSEDstops aftermax_consecutive_failureswith exit code 75.- External sources: an inbound
webhookon loopback with optional bearer or HMAC authorization,file_watch(deleted, created, modified or matching content),tcp_probefor dependencies,process_watchfor a parent or PID file, and acommandprobe for any other system. - Messages:
kafka,mqtt,natsandredissubscriptions over plaintext or TLS, with each broker's native authentication. - Application: authenticated local IPC checkpoints (
OEE_IPC_SOCKET,OEE_IPC_TOKEN),log_matchon standard output and error,on_task_completefor batch jobs, an operating-systemsignal, andoee stopfor 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,TerminateJobObjectorSIGKILLacross tracked descendants) and flush output before exiting. GRACEFULmode letsuvicorn, Go HTTP servers and JVM shutdown hooks drain requests;IMMEDIATEmode 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,
systemdunits 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, betweenmin_replicasandmax_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_limitsis 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:
tcporhttpmode,round_robinorleast_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 1inscratch,distrolessandalpineimages: 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.
| Metric | Limit and measured value |
|---|---|
| Supervisor binary overhead | Limit 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 overhead | Native 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 footprint | Under 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 latency | Under 5 ms from exit event evaluation to complete process-tree termination in IMMEDIATE mode across 50 concurrent worker processes. |
| Strict cap accuracy | With 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 overhead | Under 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 reaction | A new replica launches within 1 s of the scale-out window elapsing and receives traffic within 100 ms of passing readiness. |
| Manifest and payload integrity | Any 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 code | Cause | Meaning |
|---|---|---|
| Guest code (0 to 255) | Normal guest exit | Forwards the wrapped application's own exit code. |
| 0 | Checkpoint stop | The application reached its completion checkpoint and stopped cleanly. |
| 78 | Pre-launch exit gate block | A remote exit event was already active before the application started. |
| 75 | Exit event lease lost (FAIL_CLOSED) | The control endpoint was unreachable past max_consecutive_failures. |
| 69 | Required enforcement unavailable | A strict cap or a strict sandbox primitive cannot be enforced on this host, so the application never started. |
| 70 | Sandbox quota or policy violation | The application exceeded a strict memory cap or PID quota, or triggered a fatal system call trap. |
| 124 | Time-based exit event | A duration, schedule, timestamp or idle timeout was reached. |
| 76 | Utilization exit event | CPU, memory, process count or disk usage stayed beyond its threshold for the configured period. |
| 143 | External or message exit event | A 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.
| Platform | Architecture | Build |
|---|---|---|
| Linux | x86_64 | Static musl executable, no glibc version coupling |
| Linux | aarch64 | Static musl executable, no glibc version coupling |
| macOS | aarch64 | Native Mach-O executable |
| macOS | x86_64 | Native Mach-O executable |
| Windows | x86_64 | Static MSVC CRT executable |
| OCI/Docker | Linux images of the listed architectures | Runs as PID 1 in scratch, distroless and alpine images |
Requirements and limits
- A
strictCPU 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 withresources.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); usecontainer_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
extendedsupervisor variant (limit: under 6.0 MB, 5.26 MB measured); every other capability fits thecorevariant (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
oee inspect ./dist/my-service --verify-key ./certs/oee.puboee 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.
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.