01A UNIFIED ENGINE FOR EVERY KIND OF WORKLOAD
One kernel runs agents and dynamic agentic workflows.
An agent chooses its next step; a workflow follows a script you compose; sub-agents nest inside either. All of them run on the same execution machinery, so declare any of them and the rest of this page comes for free: the journal, the permissions, replay, live modification, for every workload alike.
02DURABLE AND OBSERVABLE, BUILT IN
Kill the process mid-run; resume continues exactly where it left off.
Every message in and every action out is written to an append-only journal as it happens, in order, with provenance: which model produced it, which tool ran, under which grant. Crash recovery, resume, replay, and audit all read from that one journal.
Because the record is complete, questions are retroactive: a query you write next month runs over everything that already happened. Durability and observability come from the storage model itself, with zero instrumentation code in your agent.
03GOVERNABLE AND AUDITABLE AT THE FOUNDATION
Explicit, granular, time-bound permissions.
Every grant names its grantor, its scope, its budget, and its expiry. Tools, secrets, filesystem mounts, and network origins are declared and bound before use; when authority is missing, the call fails closed with an error naming exactly what is missing.
Every effect leaves a receipt, so you can audit who was allowed to do what, and what they actually did, long after the fact.
04MODULAR, HOT-SWAPPABLE, PORTABLE
Designed for self-modifying agents.
Every part of the system is individually packaged and versioned: tools, operations, policies, model profiles, manifests, each addressed by a content hash. Packaged parts swap safely: a tool or a policy can be replaced under permission while the system runs, and the change lands in the record like any other action. It is what lets an agent upgrade its own tools mid-flight, governed by the same permissions and visible on the same record as everything else it does.
And packaged parts travel. An agent is a folder: manifest plus files, defining everything it is. Check it into git, diff it, zip it, reproduce it on another machine. A manifest from the kernel's examples, trimmed:
[agent] name = "researcher" version = "0.1.0" [[model_profiles]] id = "default" model_ref = "model://local/default" [[tools]] id = "http_fetch" operation_ref = "op://http-fetch@sha256:…" grants = ["net.http:GET:https://*"] [[tools]] id = "file_read" operation_ref = "op://file-read@sha256:…" grants = ["fs.read:/workspace"] [policies] network = "declared-origins" filesystem = "vfs"
The entire runtime ships as one self-contained binary under 80 MB. Run the same folder on your laptop, on your servers, or hand it to Verlet Cloud and we run it for you.
The full example lives at examples/agents/researcher in the kernel repo.
05ANY LLM, YOUR OWN HARDWARE, NO VENDOR LOCK-IN
Models are declared profiles, swappable like everything else.
The kernel ships adapters for the OpenAI and Anthropic APIs (Bedrock included) and for local and offline models, and it stores session history provider-neutral: switching providers means editing a model profile, and your agents, tools, and history carry over intact. Mix providers inside one fleet, and outlive any single vendor's roadmap.
06VERSATILE
One kernel, every shape.
Run it as a single coding assistant on your laptop, a research crew that shares one record, or the runner for a fleet of hundreds of different agents. Agents spawn sub-agents, workflows call agents, and the whole fleet writes to one journal end to end, so growing from one agent to a fleet means adding manifests.
The kernel itself assembles to fit: embed it in a process, run it as a daemon, or drive it through the CLI, the RPC app-server, MCP, or ACP, and it is the same machine every way.
WHAT SHIPS TODAY
The kernel is open source (Apache-2.0), written in Rust: roughly 160,000 lines across 18 workspace crates, 800+ tests in CI, released for macOS and Linux. It was extracted from a working consumer agent that a few hundred people text every day, and that agent is moving onto the kernel it seeded as tenant zero of the managed service.
Verlet Cloud pilots run white-glove: we onboard each tenant personally and run their agents ourselves.
The console ships inside the kernel release: cooldis console.