The spec · v0.4.2 · Apache-2.0

@flashyos/aao

The manifest format an agent workforce is declared in

The AAO manifest and charter format, naming standard and conformance suite — what makes an organization an Agentic Autonomous Organization on the DeAI Operating System.

npm install @flashyos/aaonpm ↗source ↗

Why it exists

An AAO manifest declares an organisation of AI agents the way a cap table declares ownership: who each agent is, what it may do, which human answers for it, and what must wait for approval. This package is that format plus the validator and the conformance questions, so a declaration is something a machine checks rather than something a website asserts.

What it refuses to do

No model configuration, no prompts, no infrastructure. Those change weekly; identity, authority and accountability have to stay stable enough to be worth declaring.

How it works

An AAO manifest is a JSON charter: a roster of agents, the roles that grant them authority, and the human who answers for each. `validateCharterDocument` checks it against the published JSON Schema, and `runStaticConformance` asks the questions a schema cannot — is every advertised capability answered for by a role, is each agent revocable, does a human hold accountability.

The suite is executable rather than prose: the same functions the site runs are the ones an adopter imports, and a golden set of fixtures with expected verdicts lets a parser in any language prove it accepts and rejects the same documents this one does.

Role names are governance labels capped at 24 characters; capabilities are discovery tags. The two vocabularies are linked, not merged — every capability must be answered for by some role, by name or through that role’s `x-capability`.

Related concepts

IntentMesh machine-readable organizational trust AI agent trust register verifiable agent transactions

Use it

Validate a charter, and fail the build on any issue

import { validateCharterDocument, runStaticConformance } from '@flashyos/aao';

const issues = validateCharterDocument(doc);
const failed = runStaticConformance(doc).filter((r) => r.status === 'fail');

if (issues.length || failed.length) process.exit(1);

In practice

Gate a charter in CI

A team keeps `flashyos.roles.json` in its repo and runs `validateCharterDocument` plus `runStaticConformance` on every push; a role that stops answering for an advertised capability fails the build before it reaches a domain.

Prove interop in another language

An implementer writing a validator in Go loads the conformance suite — golden documents with expected verdicts — and proves their parser accepts and rejects exactly what ours does, without importing any FlashyOS code.

How it stays honest

The suite an adopter runs is the same code the site runs, and a portable fixture set at packages/aao/conformance/suite.json — golden documents with expected verdicts — pins any implementation to the same accept/reject decisions. Re-check it yourself with `npx @flashyos/conformance yourdomain.com`, which reads your charter from /.well-known/flashyos-charter.json and runs every static question against it.

Questions

What is an AAO charter?

An AAO charter is a machine-checkable manifest declaring an organisation of AI agents: who each agent is, what it may do, which human answers for it, and what must wait for approval. It is validated, not asserted.

What does the AAO conformance suite check?

It runs the static questions a JSON Schema cannot: that every advertised capability is answered for by a role, that agents are revocable, and that a human holds accountability. A failing answer fails the build.

Why is a role name limited to 24 characters?

A role name is a governance label, so it is capped at 24 characters; a function with a longer name carries an `x-capability` tag rather than a truncation, keeping the label readable and the capability precise.

Does an AAO manifest include prompts or model config?

No. The format holds identity, authority and accountability only. Prompts, models and infrastructure change weekly and are deliberately excluded, so a declaration stays stable enough to be worth checking.

The licence

Apache-2.0, read from the package’s own manifest. Embed it in anything, including closed software — that is what makes a spec adoptable and a verifier worth running. FlashyOS’s server side is AGPL-3.0-only instead, and a test in the monorepo asserts the direction between them: AGPL code may consume this, this may never consume AGPL code.

Keep reading

The AAO spec The JSON Schema

Also in the spec

@flashyos/conformance @flashyos/dialects @flashyos/llms-txt