Scheduler
Priority classes, backpressure and lock-free worker slots. Dispatch by policy, not arrival order.
The platform / Enterprise Agent Engine
One engine. Server to silicon.
Agent graphs compile to native artefacts. A trusted core schedules work, enforces capabilities and records every decision. Nothing else sits between the agent and the machine.
Inside the core
Three jobs.
Three jobs.
No business logic.
The supervisor schedules, checks and appends. That is the whole trusted core. Agent behaviour lives outside it, so the attack surface stays small and the hot path stays predictable.
- Schedule — priority admission with lock-free worker slots.
- Check — capability and policy evaluated before a call leaves the boundary.
- Append — a hash-chained record written in the dispatch path.
01
Build
Agent definitions
Typed graphs, tools and state resolved ahead of time.
02
Verify
Capability verifier
Every agent-to-tool edge proven. Escalation fails the build.
03
x86-64
Server runtime · Go
Scheduler, shared arenas, policy tables and ledger.
04
ARM64
Edge runtime · Rust
The same contract on constrained ARM64 hardware.
05
Enforced
Kernel boundary
seccomp-bpf · Landlock · cgroup v2 enforcement.
Six complementary engines
Everything in the binary. Nothing to reconcile.
The runtime ships as a trusted core plus six complementary engines. They are not libraries to wire together at deploy time; they share one scheduler, one memory model and one ledger.
Capability gate
Per-tool grants with an expiry and a revocation path. No ambient credentials to inherit.
Policy compiler
Rules lower to decision tables at build time. Evaluation is a lookup, not a gateway hop.
Tiered memory
Working state in shared arenas, epoch checkpoints for replay, parent-child retrieval for context.
Audit ledger
One append-only record per dispatch. Export to SIEM, WORM storage or your own evidence store.
Edge engine
Rust on ARM64 for robotics, controllers and field hardware. Same capability model, smaller footprint.
Native all the way down
Systems languages, chosen for the job.
No interpreter between the agent and the machine. Each layer runs in the language that fits its constraints — throughput, footprint, interface velocity or model quality.
Go
Server engine
Scheduler, shared arenas, policy tables and ledger. Compiled to native x86-64 with no per-step serialization.
Dispatch · ≈3 µs
Rust
Edge engine
The same execution contract on constrained ARM64 hardware. Memory safety without a garbage collector.
Target · ARM64 / bare metal
TypeScript
Interfaces
Control plane, operator console and SDK surfaces. Typed end to end, kept out of the hot path.
Surface · control plane
Python
ML / DL
Training, evaluation and data pipelines run offline. Only the compiled agent artefact reaches production.
Workload · offline
Build once, prove every time
From typed source to audit-ready proof.
Compilation is where most of the security model is decided. By the time an agent runs, its capability graph has already been proven.
01 / Build
Define the graph.
Agents, tools and state are declared as typed definitions. Graphs resolve at build time; no interpreter is needed in the hot path.
02 / Verify
Prove the edges.
Static analysis proves each agent-to-tool edge. A capability escalation path fails the build before it can reach an environment.
03 / Compile
Produce one artefact.
Ahead-of-time instantiation produces one static artefact per target. No VM, no interpreter, no runtime glue.
04 / Deploy
Run where the work is.
The same contract on Kubernetes, bare metal and ARM64 edge devices — air-gapped datacenter to constrained hardware.
05 / Audit
Replay the decisions.
Every dispatch appends a hash-chained record. Epoch-ordered replay proves the same decisions in the same order.
Built in, not bolted on
Thirteen capabilities. Zero dependencies.
Each capability is enforced where it acts — at build time, in the kernel, in the scheduler or on the dispatch path.
13 capabilities
01 / ExecutionCoordination
Complex agent patterns
ReAct, plan-execute, debate, consensus, map-reduce, hierarchies and swarms as compiled types.
Agent-to-agent
Typed messages over shared memory, ~2.5 µs round trip, with no broker in the path.
Dynamic skills
Skills admitted at call time and capability-checked before they execute.
Concurrency
Per-agent limits and lock-free worker slots, with no global scheduler lock.
02 / Flow controlResource governance
Resource budgets
CPU, memory and token ceilings per agent, enforced by cgroup v2 and the scheduler.
Backpressure
Admission tightens on queue pressure before latency collapses.
Priority queue
Dispatch by priority class, not by arrival order.
Agent directory
One registry of agents, capabilities and grants that the runtime checks against.
03 / EnforcementIsolation
Kernel isolation
seccomp-bpf syscalls, Landlock paths and cgroup v2 limits per agent.
Policy as code
Policy compiled to decision tables at build time and evaluated in dispatch.
Privacy gate
Data-class and egress checks before any tool or model call leaves the agent boundary.
04 / State & proofMemory & evidence
Tiered memory
Working state in shared arenas, epoch checkpoints for replay, parent-child retrieval for context.
Audit ledger
Hash-chained record per decision, exportable to your SIEM or WORM storage.
Evidence map
Every obligation has an artefact.
The runtime produces the evidence; your DPIA, QMS and conformity assessment consume it. No vendor can certify a deployer's compliance — but the evidence should not be a reconstruction project.
GDPR ART. 30Record of processing
Per-agent purpose and data-scope manifest compiled from the typed definition, with tool-level data classes and retention fields.
Build
GDPR ART. 32Security of processing
Signed build manifest: seccomp-bpf syscall set, Landlock path rules, cgroup v2 ceilings and capability tokens granted per tool.
Check / deploy
EU AI ACT ART. 12Automatic record-keeping
Hash-chained append-only ledger, one record per dispatch: agent, tool, policy verdict, epoch and timestamp.
Audit
EU AI ACT ART. 15Accuracy & robustness
Epoch-ordered replay bundle and a re-execution diff proving the same decisions in the same order.
Compile / audit
EU AI ACT ART. 14 / 26Human oversight
Approval, override and revocation events written to the same ledger, with per-tool grants that expire.
Deploy / audit
Deployment
Where the work is. Not where the cloud is.
The same engine runs from an air-gapped datacenter to a low-power controller. The deployment model changes; the contract does not.
Air-gapped
Offline install, no telemetry and no egress. The runtime, policy and ledger stay inside the perimeter.
Hybrid
Bring the engine into your VPC or private cloud while keeping the control plane and evidence store under your keys.
Edge
Rust on ARM64 for robotics and industrial controllers, with the same capability and evidence model.
Test the runtime
Put the engine against your hardest constraint.
Bring a real workload, a deployment target and an audit requirement. We will scope the pilot around those, not a generic demo.
Go server engine · Rust edge engine · EU-native