qntx/ovo
Agent behavior that compiles
What is Ovo?
Ovo is a Rust library that provides an embeddable, multi‑agent runtime kernel. It lets a host application spawn lightweight agents (called turns) that can run isolated workflows written in the Rhai scripting language. The runtime can be configured to run agents in‑process or inside a sandboxed OS environment (macOS Seatbelt or Linux Landlock) and includes a small set of built‑in policies for approving or denying actions.
Why you might care
- Agent‑centric design – If you are building a system that needs many small, independent AI or automation agents (e.g., chat‑bot orchestration, tool‑calling pipelines, or RAG‑style agents), Ovo gives you a ready‑made kernel to manage their lifecycles.
- Safety first – The library separates the policy (what an agent is allowed to do) from the runtime and can enforce OS‑level sandboxes, reducing the risk of malicious or buggy agents affecting the host.
- Rust‑native – All of this is written in safe Rust, so you get the usual performance and memory‑safety guarantees.
- Pluggable back‑ends – You can plug in either the macOS Seatbelt sandbox, the Linux Landlock helper, or run without a sandbox for testing.
Core concepts
| Concept | Description |
|---|---|
| Turn | The smallest unit of work an agent performs. Turns are scheduled by the kernel and can be approved/denied via a TurnOptions policy. |
| TurnOptions | Configuration that decides how a turn is approved (AutoApprove for tests, AlwaysDeny for a locked‑down host, or a custom UI gate). |
| Host | The surrounding environment that runs the kernel. You can create an InProcessHost (pure Rust, no OS sandbox) or a sandboxed_host that uses a SandboxBackend. |
| SandboxBackend | Trait that abstracts the OS sandbox implementation. Implementations are SeatbeltBackend (macOS) and LandlockBackend (Linux). |
| Rhai workflow | Agents are scripted in Rhai, a lightweight embedded scripting language. The workflow is journaled, meaning actions can be replayed or inspected. |
Getting started (code snippet)
use std::sync::Arc;
use ovo::{AlwaysDeny, TurnOptions, sandboxed_host};
// Choose a sandbox backend (example for Linux with the Landlock helper)
let backend = Arc::new(ovo::LandlockBackend::with_helper()?);
// Create a sandboxed host that will run agents inside a jailed directory
let host = sandboxed_host(sampler, backend, jail_path)?;
// TurnOptions controls how the host asks the user to approve actions.
let opts = TurnOptions::for_host(Arc::new(AlwaysDeny)); // replace with UI gate in prod
sampler– an object that provides randomness to agents (e.g., a PRNG).jail_path– the directory that will be used as the filesystem sandbox.AlwaysDenyis a safe default; in a real deployment you would supply a UI‑driven gate that asks a human or policy engine whether a turn may proceed.
Feature matrix
| Feature flag | What it adds | Sandbox support |
|---|---|---|
default (runtime + workflow) |
Core kernel + Rhai workflow engine; links ovo-sandbox for TrustedExecution (no sandbox by default) |
– |
| toolkit | Adds a jailed filesystem shell (cwd‑jailed) |
Requires seatbelt (macOS) or landlock (Linux) to be enabled |
| sandbox | Exposes policy types and the SandboxBackend trait |
– |
| seatbelt | Enables macOS /usr/bin/sandbox-exec sandbox |
macOS only |
| landlock | Enables Linux Landlock sandbox via the ovo-landlock helper binary |
Linux only (helper must be present on PATH or via OVO_LANDLOCK_HELPER) |
| full | Bundles toolkit, state management, observation hooks, and optional OpenAI/Ollama integrations | No – still needs explicit sandbox back‑ends |
| --all-features | Compiles everything (full + seatbelt + landlock) |
Compile‑time back‑ends; Linux still needs the helper binary |
Maturity & stability
- The current series is 0.9.x, labelled pre‑stability. Breaking changes may appear without a compatibility layer, so treat it as a fast‑moving library rather than a 1.0‑stable API.
- The crate is published on crates.io under the name
ovo(previouslymachi). - Documentation is primarily in the README and the generated Rust docs; there is no separate tutorial yet.
License
Ovo is dual‑licensed under MIT and Apache‑2.0, giving you the flexibility to choose the permissive license that best fits your project.
Who maintains it?
It is an open‑source project of QuantX (https://qntx.org), a community focused on open‑source tools for quantitative and AI‑driven work.
TL;DR
Ovo = a Rust library for running many small, sandboxed agents (via Rhai scripts) with a clear separation between policy and execution. It’s aimed at developers who need a safe, embeddable multi‑agent runtime and are comfortable working in Rust.
Related
- Project
- Project
- Project
- Project
- Project