Where the object-and-phase approach sits on the map of existing ways to build enterprise systems — and how far along that map it lets you move toward autonomy.
Most modern approaches to enterprise systems share one thing: behaviour is defined not by application code from scratch but by an executing core plus a description of behaviour — a process schema, a set of rules, a configuration or workflow code. They differ in what they place at the centre of the model: the main unit around which everything else is assembled.
Phase is assembled from ideas, each proven over decades, but their combination around a single carrier — an object with a phased lifecycle — does not repeat any of the existing classes of systems.
BPMN engines: Camunda, Flowable, Activiti, jBPM, Bizagi, ELMA, Comindware · CMMN · process mining: Celonis, UiPath
The centre is the process as a graph; a token moves through it. Participation of human and machine are different node types with different semantics, so handing a step from human to machine means changing the schema. Reaction to the unplanned is exception handling, not normal behaviour.
Temporal, Netflix Conductor, Cadence, Restate, AWS Step Functions, Azure Durable Functions
The centre is a long-running process function as code, surviving failures by replaying its history. Expressive and "dark" by nature, but lifecycle properties can be checked before launch only by tests; the human connects as an external signal, not a first-class participant.
Drools, IBM ODM, Red Hat Decision Manager, GoRules · DMN
The centre is "if — then" rules over a shared store of facts. They can join conditions across many objects, but as their number grows collective behaviour becomes hard to predict. They automate individual decisions, but not the lifecycle and not the participants.
Apache Kafka, Apache Pulsar, AWS Kinesis, Axon (event sourcing / CQRS)
The centre is the stream of events; state is secondary, computed as a projection. Full history and stream scalability. This is an infrastructure layer rather than a model of the enterprise — autonomy and agent-programmability are not posed here.
Erlang/OTP, Akka, Microsoft Orleans, Dapr Actors, Elixir
The centre is the actor: identity, state, a mailbox, spawning of children. Structurally the closest relative of Phase. But the actor's behaviour is code, its lifecycle is not structured as an explicit sequence of phases, and failure handling lives in infrastructure, not the business model.
Salesforce, Microsoft Dynamics, ServiceNow, SAP, 1C · Pega, Appian, OutSystems, Mendix
The centre is a record or case with a status and handlers. A ready ecosystem and interfaces. The closest in ideology — Pega — operates with a case lifecycle and stages, close to an object with phases. But these platforms were built around the human interface: automation and agents are added on top, and the vocabulary of constructs is vast.
LangGraph, AutoGen, CrewAI, OpenAI Agents SDK, LlamaIndex
The centre is an agent or a graph of agents; state is the conversation context. Flexible coordination of several agents. But business objects live for months while agent sessions last minutes: long-lived state, data ownership and audit are solved outside these frameworks. These are tools for executing agents, not a model of the enterprise.
VSM (Stafford Beer) · MAPE-K · digital twin (Azure Digital Twins, ISO 23247)
Not engines but conceptual models: a viable system with feedback loops, the autonomic-control loop, the digital twin of a physical object. These are not competitors of Phase but its intellectual ancestors.
Phase places at the centre of the model an object with a phased lifecycle — and it is the only unit. Not a process, not a rule, not an event, not an agent, not a status record. A contract, an order, an invoice, a goal, even a change to the system's own configuration are objects of one kind passing through phases.
| Approach | Centre of the model | Human | AI agent |
|---|---|---|---|
| Process-centric | process graph | special node type | special node type |
| Durable execution | process function (code) | external signal | call from code |
| Rule engines | rule over facts | — | — |
| Event-centric | stream of events | — | consumer |
| Actor model | actor (code) | — | code |
| Platforms / low-code | record/case with status | load-bearing construct | add-on |
| Agent orchestrators | agent / graph of agents | oversight | centre |
| Phase | object with phases | symmetric participant | addressable worker |
No approach builds the participation of human and agent on one and the same mechanism. In Phase it is writing to an object's field, identical for both — hence the symmetry the others lack.
The object view gives Phase a property the others lack: autonomy can be increased by configuration, not by rebuilding. Measure it on a scale analogous to the levels of driving autonomy (the SAE classification: L0 — manual control, L5 — full autonomy).
| Level | What the system does | How it is in Phase |
|---|---|---|
| L1 | records data, the human makes every decision | the default mode — manual control |
| L2 | proposes, the human confirms | the agent fills in a recommendation, the human confirms |
| L3 | decides itself, the human has a veto | the agent decides, the human can intervene |
| L4 | drives objects itself, human handles exceptions | the loop runs by itself, exception handling is configured |
| L5 | revises goals and rebuilds its rules | the second loop — adaptation — by the same means |
The value is not that Phase reaches a high level, but that moving along the scale does not require rebuilding the system. Moving from L1 to L4 is a sequence of configuration steps. In most other approaches raising autonomy means reworking the schema or the code.
The most unusual part is the top level. To manage an enterprise is not only to run affairs by the rules but to change the rules themselves. In conventional systems that loop lives outside the model. Phase describes it by the same means: a goal is an object, a configuration change is an object, passing through their own phases and audit just as an invoice does.
It might seem the limit of such autonomy is an enterprise without people. It is not, and the reason lies in the nature of the AI agent. An agent is the accumulated knowledge of people in executable form; it is strong in the known and acts from the past. The new — a new goal, a non-standard decision, a rethinking of how the business itself works — is not derivable from the past. The source of the new is the human.
The management loop is closed and runs on its own, deliberately reaching out to the human where it hits the edge of the known. The more knowledge is turned into patterns, the higher the human rises — from levers to goals, from goals to new ideas. Not a machine instead of people, but a machine that uses human wisdom precisely.
Every element of Phase has a long pedigree, and therein lies its strength: the approach does not ask you to believe in the untried but combines the proven.
The novelty of Phase is not in the elements — each is decades-proven. The novelty is in the combination: the symmetry of human and agent, autonomy as configuration, and training data as a by-product arise only when these ideas are assembled around a single carrier — an object with a phased lifecycle.
The same economy of means shows in scale: a subordinate enterprise is present in the upper one as a digital twin, managed through adapters — exactly as any twin is linked to its prototype. A hierarchy of enterprises of any depth is described by the same vocabulary as a single deal.