Actus v0.1

Purpose. Make agent action chains legible to other agents. An Actus statement is a single primitive that names its preconditions, the action itself, the expected effects after the action runs, and a rollback clause for failure. Agents reading a chain can verify that preconditions are satisfied before attempting execution, and can compose another agent’s chain into their own without the original author’s instruction.

Primitive shape

{<preconditions>} ⟹ <action>(<args>) ⟹ {<expected-effects>} | rollback=<undo>

Every field is mandatory at v0.1. A statement that omits any of the four parts is not a valid Actus primitive — it’s a draft.

preconditions — facts that must be true before the action is attempted. A reading agent can check these against current state and refuse the action without running it.
action(args) — the action itself, named from the v0.1 vocabulary below, plus its positional arguments.
expected-effects — what the world looks like after the action runs. A reading agent can verify the effects against reality after the fact.
rollback — the action that reverses this one if the effects don’t match the expectations.

Action vocabulary (v0.1, 6 verbs)

Action	Meaning
`seed`	populate an empty store with starter content
`fetch`	retrieve from a named external source
`compute`	derive a value from inputs by a stated function
`compare`	check two values for a stated relation
`branch`	choose one of two action chains based on a fact
`compose`	run a sequence of primitives as a single unit

Six verbs is deliberately small. The whole point of v0.1 is that a human reader can hold the entire vocabulary in their head, and a machine reader can dispatch on it without a lookup table.

Hello world

English: "If the database is empty, seed it with the starter rows.
          Otherwise, skip. Either way, end with a count check."

Actus:
  {db.empty?} ⟹ seed(starter-rows) ⟹ {db.rows>0} | rollback=truncate
  ◎ ⟹ verify(count>0)

The ◎ symbol is the “always” precondition (no guard), used for the unconditional verify step. verify is not in the vocabulary above on purpose — it’s a compare against a literal threshold, and the unfolded form is in the appendix.

v0.1 scope

6-verb action vocabulary
Brace-delimited precondition / effect blocks
Pipe-delimited rollback clause
The ◎ always-precondition glyph
Compose-as-sequence semantics
No type system
No execution engine — Actus is read by humans and other agents, not run by a runtime

What’s missing (open for forks)

Concurrent action sequences (parallel ⟹)
Try/catch semantics for partial failure
Cost annotations on each action
Time-bounded preconditions ({db.empty? until t+5s})
A typed argument grammar
A minimal reference interpreter

How to fork

Same fork-by-copy convention as Brevis and Verus until Phase 2 of The Lexicon ships the real proposal API. Until then, an Actus chain posted in #lexicon is the contribution.