AOS8Book a demo
For developers

Build on the Autonomous Operating System.

AOS8 runs operations software as signed models, not code: one engine runs every product, AI agents work inside it, and the rules that govern them live in a small, tested core.

Go 1.26TemporalPostgreSQL 16ConnectReact + TypeScriptv0.12.0
one binary
aos8 api | worker | followers | host | migrate
     seed | key | export | verify | import | doctor
Architecture

One language, one binary, one engine.

The law lives in a pure kernel with no I/O. Everything else is a door to it, a store under it, a follower behind it, or a wall in front of the outside world.

internal/kernel

The pure kernel

Admission, Decide, the model, the guard language and the loop's arithmetic. Standard library only, no I/O. It never errors: it refuses with a code, a sentence, who can fix it and the Handbook line. It is written twice, in Go and in the design mock, and held equal by golden tests.

internal/api

The door

Connect services with identity, tracing and tenancy, and the dry run every screen asks before it shows a button.

internal/store

The store

PostgreSQL with row-level security per tenant. The record and its chain event are written in one transaction.

internal/flow

The flows

Workflows and agent turns on self-hosted Temporal. A turn lands as a proposal the kernel admits like anyone's.

internal/followers

The followers

Tailers that read the chain per tenant: anchoring, publishing and verifying, with a durable cursor.

internal/ai

The one seam to a model

Provider policy per tenant, product and agent; keys sealed and write-only. Provider names live here and nowhere else.

aos8 host

Capabilities behind a wall

Signed Go packages for what data can't say, such as EDI, payments and email, with no store handle and no master key. Only AOS8 signs them.

How a command runs

Every action is admitted, or refused with a reason.

A person, an agent's turn, a partner's connector, an outside AI client or a tenant's own system all use the same path. Nothing records work on the side.

  1. An envelope arrives with the tenant, the command, the payload, what it expects, an idempotency key, and whether it's a dry run.
  2. The door stamps it: the actor, the sign-in time, a trace id and the store's clock. A client can't set these.
  3. The store locks only what the command touches and replays the outcome if the key was seen before.
  4. The kernel admits it or refuses it, in a fixed order: actor, install, version, command, authority, role and limits, record, need-to-know, the door, state, payload, guards.
  5. The events are hashed and appended to the tenant's chain in the same transaction as the records they change.
  6. Everyone watching is told, and the screen updates. A dry run answers the same way and writes nothing.
The rules, in code

The governance is the engine, not a setting.

One decide path

An approval changes only through Decide: one person, or two different agents below the tenant's human floor. An agent never approves its own work, including what it filed, proposed or asked for.

No dead ends

Every refusal is a code with a sentence, who can fix it and the next step. A disabled button carries its reason from the dry run.

The model records; it invents nothing

An agent's output is a proposal or a vote, checked like anyone's command. A figure in its words counts only when the engine verified it.

Names stay in one place

Provider and model names appear only in the tenant's provider records, the Settings page and internal/ai. Agents are seats, never "powered by" a model.

The model · ruled 15 and 16 November, designed, not built yet

Platforms, products and apps, as signed models.

A publisher defines a platform, its products and their apps. A tenant installs them, fills them and may add a layer of its own. Everything that happens is a command, and every command leaves an event.

Three levels and a core

A platform is a set of related products from one publisher, with a signed core for what they share: records, roles, seats, workflows across products. A product is one area of work with its own version, risk class and dial. An app is one main record, the records that live only inside it, and everything that acts on them.

Contracts, and three kinds of dependency

A product publishes a contract: the records others may read, the commands they may issue, the events they may react to, and the points where they may extend it. Dependencies are built on, needs or works with. Each points one way and may not form a cycle. Breaking a contract is a major version.

Installs and layers

An install is a tenant's own record: this version, with these people, agents, bindings and settings. It copies nothing. A tenant changes what it installed by adding a signed layer, never by editing the publisher's model, and the layer is replayed against a new version before an upgrade is pinned.

Tools for outside AI clients

Each product's contract can be offered as tools in the shapes of the Model Context Protocol, which the AI runtime already uses. The client is seated like an agent: every call is a command under a grant, and its reads are bounded by data class and the egress policy.

Workflows, step by step

A workflow is a path of steps over one record, and belongs to one app. A step is one of four kinds: a command, a wait, a crossing, or a call to another workflow. Each names who may act: a role, a seat, or the engine as that app's workflow. A step that changes something outside its record names its way back; one with none is a crossing. A crossing names its verifying seat, and an agent votes only from it, once it has earned its vote on that workflow.

One shape, six faces proposed

A platform, a core, a product, an app and a workflow each show the same six faces, one for each product of AOS Platform. A change to any of them is said in a sentence, drafted, decided and written to the chain: a setting lands at the signature, a change to a model at its build. For an installer the change goes into its own layer.

One path, held by seven rules.

Inside one tenant there is no network interface between products or platforms. They run on one engine, one chain and one admission law. A workflow's next step is a command again, so the path closes on itself.

AOS's own products are numbered from 5.0.0, each on its own. A product has versions; the engine has releases.

  1. A record changes only by a command of its own app. Another app, product or platform issues that command; it never writes the record.
  2. An event is a fact, not an instruction. Whatever may read it may react to it.
  3. A trigger changes nothing itself. It starts or signals a workflow, with the authority of its own app or of a named agent.
  4. A workflow has one owner and carries the highest risk class it reaches.
  5. An agent acts in a seat, under a grant; a person acts in a role. A grant names its seats and steps by id. The engine acts only as a named app's workflow or trigger, and never decides.
  6. What comes from outside enters through a connector. What leaves is held by the egress policy, and in a preview nothing leaves.
  7. A refusal is an answer. It names the rule, who can fix it and what to do next, and it is recorded.
Where it runs · proposed as ADR-AOS8-015, a draft

One codebase, cells of two kinds.

A tenant is not a unit of deployment: many tenants share a cell, and a cell runs one release of the engine. The proposal adds a second kind of cell behind a set of ports. Nothing above the ports knows which kind it runs in, and nothing a publisher signs names one.

cells.profile

temporal-postgres, or lambda-dynamodb

A person reads Always on or On demand. The same binary runs as containers in one and as functions in the other, and a cell refuses a release the checks did not prove on its profile. Admitted against the same world, under the same clock and by the same release, the same commands produce the same chain, hash for hash.

flow engine on main

Runs a flow durably

Temporal workflows and activities; Lambda durable functions in an On demand cell.

chain keeping on main

Seals, publishes, verifies

SQL and a write-once file; items and S3 with Object Lock in an On demand cell.

keys on main

Seals and wraps

Seals provider keys and wraps each tenant's data key: KMS or SoftHSM; AWS KMS in an On demand cell.

ledger port planned

Commits atomically, once

One SQL transaction under row and chain locks today; one conditional transaction under the tenant's writer lease on DynamoDB.

reads port planned

A declared read set

As of one head, filtered by role: SQL under row-level security, or key reads under a tenant session, filtered by the adapter.

meter port planned

Every model call, settled

A turn saves before it spends. A model call that is retried is never billed or landed twice, on any flow engine.

Twelve ports in all; four exist on main today. What differs is said plainly: PostgreSQL enforces the tenant and role walls in the database, while on DynamoDB the cloud vendor enforces the tenant wall and the adapter's code enforces the role wall. A tenant chooses its cell at birth and changes it only by a move.

The chain

A public recipe anyone can recompute.

Records are projections; the chain is the truth. Anchors seal windows of events, and Verify recomputes the whole thing in the app or offline.

What Verify proves

  • Nothing was altered or reordered
  • What was signed, and by whom
  • Who decided, under which decision

What it doesn't prove alone

  • That a guard evaluated correctly
  • That a model saw what the trace says
the recipe
# every change is an event, appended in the same transaction
event  = [seq, tenant, type, entity_id, actor,
          payload, commitment, prev_hash, ts, ...]

hash   = sha256(canonical_json(event))

anchor = [seq, tenant, from_seq, to_seq, root,
          prev_hash, ts, signature, key_id, ...]

# canonical: JSON, no spaces, non-ASCII escaped
How AOS is built

Held to the same rules as the product.

AOS is built by the AOS Harness, which follows the same process AOS Platform gives a tenant's product: the same stages, roles, records and promises. Two differences are allowed: the artifact is code in git, and a named person may make a break-glass change, under a grant, on the record.

Tests first

The failing test is committed before the code that turns it green. Coverage of changed code is total, and the scenario count only goes up.

One gate

Every change passes one gate before it is called done. It covers the core, the app, the mock, the design system and mutation tests, the same on a laptop and in CI.

An agent never approves its own work

That includes the coding agents that help build AOS8. Every change is reviewed, and every merge is a person's decision until agents have earned a vote.

Book a technical demoHow AOS8 governs decisions