Glossary
Holon — An entity that is, at the same time, a whole and a part: complete on its own and composable into something larger without losing what it is. The term is Arthur Koestler's.
Self-Assertion / Integration (S-A/INT) — The two tendencies every holon
carries at once. Self-Assertion preserves its own identity and lifecycle (it runs
its own .Execute()); Integration makes it function as part of a larger system
(governance oversight, IoC resolution, type accumulation, and Buildable
participation).
No-aggregation rule — Each entity's guardrails run independently. A child's guardrails don't apply to the parent that hosts it, and the parent's don't reach down into the child. Each entity is self-governing - which is what makes composition safe.
Holarchy — A bounded hierarchy of holons. Steward's holarchy has four tiers: Workbench → Workshop → Studio → Platform (YOU^AI → TEAM^AI → PRODUCT^AI → ENTERPRISE^AI).
Capability — A deterministic behavioral holon: typed input, typed output, an implementation, optional guardrails. An atomic tool with encapsulated context.
Agent — A behavioral holon that wraps an AI interaction behind a typed
input/output contract, returning a message-based handle (SendMessage, Close).
Operation — A strategy holon that composes Capabilities, Agents, and sub-Operations into a named, runnable action. Runs inside a Steward; never standalone.
Governance (GovernancePolicy) — A guardrail holon you attach to an entity.
Fixed I/O: input { Action, Initiator, Context }, output status where Code 0 =
accepted, non-zero = rejected, 202 = pending review.
Workflow — A long-running behavioral holon with durable, evolving state - branching, looping, approval gates, and persistence.
Steward — The root container and execution context. Hosts Operations, Capabilities, Agents, and Workflows, and shares governance across them. Complete at any scope; nests inside a larger Steward.
Builder — The fluent API for defining a holon - a portable, complete spec of what the entity IS, independent of where it runs.
Runner — Connects a builder to an execution environment: initializes IoC and
hands the builder to the Engine. (CapabilityRunner, StewardRunner, …)
Engine — Internal execution lifecycle. Builds the module lazily, validates input/output against the schemas, resolves services, runs guardrail checks, and executes. You never touch it directly.
Sub-capability — A Capability composed inside another Capability (or
Operation/Workflow) via .Capabilities({}), reached through ctx.Capabilities.
Guardrails — The everyday name for governance: a constraint you craft and attach to your own work, which travels with the entity wherever it goes.
Intent / IDD (Intent-Driven Development) — A declaration of what a holon intends to do, written as a runnable suite that travels with the holon. Version-controlled, machine-runnable, and readable by AI - an executable spec rather than a regression test.
See also the fai glossary for the workbench/vault vocabulary built on top of these.