Every agent project bolts the controls on last
The demo works. Someone asks whether it actually works, so evaluation gets added. It writes something wrong to a live system, so approvals get added. The bill arrives, so cost tracking gets added. Each control is a retrofit, wired around a system that was never designed to carry it.
Retrofitted controls are the ones that get switched off under deadline. And the second agent gets built the same way as the first, because nothing about the first one was reusable - the ops discipline lived in one team's habits, not in the runtime.
Software takes its safety from reversibility. Operations have none to take. A dispatched truck, a sent supplier notice, a posted stock movement - none of them has a rollback, and the system of record only ever confirms what already happened. So safety has to come from governance applied before the action, not recovery after it. That's the whole reason the controls belong in the kernel: not tidiness, but the absence of an undo.
The controls live in the kernel, so every module inherits them
Orchestriq Core is a runtime that knows nothing about your domain. No document schemas, no industry logic, no opinion about what a good answer looks like. What it does know is how to run an agent under supervision: typed actions, a tool registry that decides what a module may call, full transcripts, scorers, an eval gate, and an approval inbox where unattended runs park their requests instead of acting.
Autonomy isn't a setting. Each module starts approval-gated on everything and widens only as its measured accuracy justifies it, per action type, with the evidence in the ledger. The kernel enforces this - a module can't opt out of its own governance.
Transparency is part of that enforcement. Output the model wrote leaves the kernel carrying EU AI Act Article 50 marking - a line a person can read and metadata a machine can detect - and content a person wrote doesn't. A module can't publish unmarked model output, because the marking is emitted where the action is dispatched.
Bring your own model. Cloud API, your own cloud tenancy, or a local model on your own hardware. Swapping providers is configuration, and the eval suite tells you what the swap cost you.
Spec, gate, park, earn
The kernel runs without any module. A module can't run without declaring how it will be judged.
Governance in the runtime, not in the habits of the team
No schemas, no industry logic, no connectors to anything specific. The moment domain knowledge leaks into the kernel, every module inherits assumptions it never asked for.
Most agent frameworks let you switch autonomy on. Here it's a ladder, climbed per action type on evidence from annotated cases. The ladder is the product.
Provider-agnostic transport, so the same module runs on a frontier API, an EU-resident tenancy, or a local model. What changes is cost and accuracy, and both are measured.
Disclosure marking is emitted by the runtime, not written per module. Every module is compliant on the day it ships because it never had the option not to be.
The test set is written with the spec, before the code. A module that can't say how it will be judged doesn't get built.
Where Orchestriq Core is heading
Typed actions, tool registry with central dispatch, provider-agnostic transport, run state and full transcripts. The parts every module sits on.
Modules register their own checks - deterministic where code can decide, calibrated judges where it can't. Failing sets block the merge, enforced by the kernel.
Approvals as first-class objects with a person, a timestamp and a reason. Autonomy widening per action type against recorded calibration.
Document intake, built with nothing added to the kernel to make it fit. If the interface bends, the abstraction was wrong.
The real test. A kernel proven by one module has proven nothing.
Self-hosted, cloud, and EU-resident builds of the same artifact, with cost and latency documented per option.