← Catenator
The descriptors
Catenator defines multiple descriptors:
| Descriptor | Specifies |
|---|---|
domain |
the vocabulary and rules governing the system |
model |
the data structures the system operates on |
component |
the discrete, reusable pieces the system is made of |
service |
the capabilities the system exposes or consumes |
operation |
the individual operations the system performs |
actor |
who or what interacts with the system |
event |
what the system must respond to |
rule |
the constraints the system must enforce |
process |
the workflows the system executes |
integration |
the system's boundaries with external systems |
utility |
what the system does, for whom, and to what end |
risk |
what can go wrong, how likely, and who bears it |
What each descriptor covers
| Name | Description |
|---|---|
domain |
names the vocabulary the system operates in and the rules that govern it before any code is written. A pharmacy domain carries different constraints than a SaaS platform. The domain descriptor makes those constraints explicit and referenceable across the spec. |
model |
describes the data structures the system operates on — what objects exist, what attributes they carry, what states they can be in. A model is not a database schema. It is the conceptual shape of the system's objects before any implementation decision is made. |
component |
names the discrete, reusable pieces the system is made of. A component has a boundary, a contract, and a set of responsibilities. It does not describe implementation — it describes what the piece does and what it exposes. |
service |
describes capabilities the system exposes to the outside or consumes from outside. A service has a contract — what it receives, what it returns, what it guarantees. Internal logic is not part of the service descriptor. |
operation |
describes the individual operations the system performs — the atomic actions that change state, produce output, or trigger events. An operation is initiated by an actor, operates on a model, and produces a result. |
actor |
names who or what interacts with the system. Actors can be people, external systems, or automated processes. An actor has a role, a set of permitted operations, and a context in which it operates. |
event |
describes what the system must respond to — things that happen that require a reaction. Events can originate inside the system or outside it. An event triggers a process, an operation, or a state transition. |
rule |
names the constraints the system must enforce. Rules can be internal — business logic, validation, state machine constraints — or external — regulatory requirements, contractual obligations, platform policies. Rules are not embedded in operations. They are declared separately and referenced. |
process |
describes the workflows the system executes — the sequences through which objects move, actors interact, and events are handled. A process connects operations, actors, and events into a coherent flow. |
integration |
describes the system's boundaries with external systems — what it depends on, what depends on it, and the contracts at those boundaries. An integration names the external system, the protocol, the data exchanged, and the failure modes. |
utility |
describes what the system does, for whom, and to what end — its purpose from the outside. Utility is not a feature list. It is the statement of value the system produces for the actors who depend on it. |
risk |
names what can go wrong, how likely it is, and who bears the consequence. Risk is not an afterthought. It is a first-class descriptor that shapes decisions across every other part of the spec. |
Using descriptors
No descriptor is mandatory. A spec can use one descriptor or all of them — depending on what the system requires and what the agent needs to proceed.
A minimal spec might declare only utility and domain. A complete spec activates all thirteen. Most real specs live between these extremes — using the descriptors the system's complexity requires, leaving the rest implicit or deferred.
Some descriptors have subtypes that carry distinct requirements. Subtypes are defined in the descriptor reference.
The descriptors are not a checklist. They are a vocabulary. Use what the system requires.