Autonomous action. Human authority.
AristotleOS lets agents, robots, workflows, and machine systems act at speed under explicit human authority. Every consequential action must cross a governed boundary: authority first, Warrant at allow, evidence after decision, even when the network disappears.
Built as an open-core commercial platform.
AristotleOS is the product surface for execution governance. AristotleOS LLC handles hosted deployments, enterprise support, customer contracts, and market-facing services around the MPL-2.0 open-source core incubated by Aristotle Agentic.
The Command Center is where the thesis becomes operable.
The live Command Center gives reviewers and operators a direct way to inspect authority, refusals, Warrants, evidence, replay, and vertical simulations before treating the system as pilot-ready.
See the boundary.
Track which agents, wards, commits, warrants, escalations, and evidence records are active across the governed surface.
Challenge the proof.
Run the live paths, inspect the repo, test the reviewer flow, and look for weak authority, evidence, or replay assumptions.
Map one real action.
Start with one consequential workflow: the Ward, authority scope, refusal cases, evidence requirements, and replay path.
Autonomy becomes an authority problem at the moment of action.
Agent governance usually starts with prompts, policies, approvals, or logs. AristotleOS starts at the moment an autonomous system tries to make a real change.
The operating question: what action is being attempted?
A capable agent can call a tool, open a ticket, move a vehicle, alter a record, deploy infrastructure, change a configuration, or trigger a workflow.
The question is "under whose authority?"
AristotleOS makes authority a runtime object. The action is evaluated against its Ward, delegation, constraints, runtime state, revocation posture, and evidence requirements before execution.
Choice before action. Authority before consequence. AristotleOS turns delegated human authority into verifiable machine execution.
Warrants are how authority becomes executable.
A Warrant is the signed, single-use bridge between human authority and autonomous action.
One command proves the boundary.
The fastest check runs the actual governed-action boundary: allow, signature verification, refusal, escalation, evidence bundle, and GEL chain.
$ git clone -b ward-warrant-execution-control https://github.com/AristotleAgentic/AristotleOS $ cd AristotleOS/extracted $ corepack pnpm@10.32.1 install $ npm run demo AristotleOS governed autonomous-action self-check PASS ALLOW issues a Warrant PASS Warrant signature verifies PASS REFUSE blocks an out-of-scope action PASS Evidence Bundle self-verifies PASS GEL hash chain verifies DEMO READY - Warrant, refusal, GEL, and Evidence Bundle checks passed.
Built for systems where a bad action matters.
The first use case is autonomous action with consequence: production tools, infrastructure, vehicles, robots, regulated workflows, and machine-to-machine commitments.
The wire is guarded.
Adapters refuse unauthorized writes before bytes leave the process. The execution boundary governs the action as it leaves the agent framework.
Standing power gets narrowed.
Long-lived credentials may exist below the surface, but AristotleOS requires a per-action Warrant for the consequence itself.
The proof travels.
Warrants, refusals, and GEL records package the evidence auditors need to verify what happened from offline artifacts.
Governance that survives disconnection.
Central control is fragile at the edge. AristotleOS is built for disconnected, intermittent, and partitioned environments where autonomous systems still need bounded authority.
Built for the moments when central control disappears.
Edge nodes act inside delegated authority. Scope is set before partition, carried as verifiable artifacts, and reconciled when connectivity returns.
Disconnection preserves delegated authority.
Fluidity Tokens, Wards, Authority Envelopes, Warrants, and GEL records carry approved scope across cloud handoff, human review intervals, and central policy service gaps.
Partition scenario ROOT + 2 WITNESS + 40 EDGE nodes nominal operation network partition revocation under partition heal + reconcile result: deterministic replay artifact evidence: offline-verifiable report hash
Execution governance at the consequence layer.
Capability tokens govern access. Guardrails shape model behavior. AristotleOS adds a Warrant-based runtime layer for autonomous action at the point it becomes consequence.
| Layer | Common approach | AristotleOS |
|---|---|---|
| Authority | Role, token, approval, or session permission. | Ward -> Authority Envelope -> single-use Warrant for a canonical action. |
| Execution | The agent or tool decides whether to proceed. | Commit Gate decides before the action can cross the boundary. |
| Drift | Caller discipline and runtime checks. | Canonical action hash binding refuses repurposed or mutated authority. |
| Evidence | Logs, traces, screenshots, or approval history. | Hash-chained GEL records plus offline Evidence Bundles. |
| Partition | Usually centralized, online, or bespoke. | Mesh runtime supports bounded disconnected operation and reconciliation. |
| Peer execution-control projects | Often make local agent tool-call enforcement simple and developer-friendly. | AristotleOS aims for equal reviewability while extending the model to Wards, Warrants, offline evidence, and edge/disconnected operation. |
Reviewer-verifiable by design.
The repo includes an 18-check reviewer flow, 820+ tests, adapter tests for refusal before emission, and a deterministic 40-asset partition scenario that proves governance can survive network loss.
$ cd AristotleOS/extracted $ pnpm reviewer:verify AristotleOS reviewer verification: PASS total checks: 18 passed: 18 all checks: PASS Stage 1 Commit Gate 4/4 Stage 2 Public Warrant Verifier 5/5 Stage 3 40-Asset Swarm Scenario 5/5 Stage 4 Replay Artifact 4/4
Open core for buyer and reviewer confidence.
AristotleOS uses MPL-2.0 for the public core so qualified reviewers can test the execution boundary, Warrant binding, evidence ledger, and disconnection model directly.
Test the boundary.
Review Commit Gate coverage, replay behavior, Warrant binding, evidence immutability, adapter ordering, and default configurations.
Pressure-test the model.
Evaluate whether Wards, Authority Envelopes, Warrants, and GEL records form a coherent governance architecture for autonomous action.
Port the boundary.
Help harden framework adapters, policy examples, runtime services, live console flows, and production deployment patterns.
Commercial platform access.
The public core stays open for review. Commercial access funds hosted support, pilot design, managed command-center evaluation, and enterprise implementation around AristotleOS. Prices are listed in US dollars.
Free
MPL-2.0 core source, public docs, reviewer packet, quickstart, and live Command Center inspection. Built for reviewers, researchers, and early technical evaluators.
$12,500 USD one-time
Four-week scoped pilot around one consequential action: Ward design, authority model, refusal cases, evidence requirements, and pilot-readiness memo.
$5,500 USD / month
Six-month managed engagement with monthly command-center review, evidence model support, pilot dashboard, governance findings, and operator/reviewer briefing.
from $12,500 USD / month
Custom multi-ward or regulated-autonomy support for infrastructure, public sector, insurance, defense-adjacent, UAV, robotics, or critical operations.
by agreement
University, foundation, public-interest, and civic AI review paths can be structured around grants, sponsored research, or public-benefit pilots.
Commercial support and delivery.
Pricing covers evaluation, pilot design, hosted support, training, implementation help, operational review, and buyer-ready documentation.
Access center.
Start with one repo, one quickstart, one reviewer packet, one live console, and one pilot intake path. The public path stays reviewable; commercial work begins when a real autonomous-action workflow is ready to be scoped.
| Access | What it gives you | Start here |
|---|---|---|
| Open-source core | Source code, docs, examples, packages, and the public warrant/evidence model. | GitHub repo |
| Quickstart | Fast local path for setup, orientation, and the first governed-action checks. | Run quickstart |
| Self-check | The in-page proof path for allow, refusal, Warrant verification, evidence bundle, and GEL chain. | Run the self-check |
| Reviewer packet | Claims to test, verification flow, comparison notes, and critique path for outside reviewers. | Open packet |
| UI prototype | Public web build for inspecting the operator interface and moving from site narrative into console behavior. | Open prototype |
| Live Command Center | Public operator surface for Warrants, commits, Wards, replay, evidence, and vertical simulations. | Open console |
| Pilot intake | A scoped discussion for one consequential action, one Ward, and one evidence path. | Send inquiry |
| Managed subscription | Commercial support for recurring command-center evaluation, pilot governance, and implementation scope. | View pricing |
Start with review, pilot fit, or implementation scope.
AristotleOS is the warrant layer for teams that want machine speed under explicit human authority. The right first step is usually a reviewer pass, a narrow pilot action, or a scoped implementation conversation.