Intent lets people state what a service must achieve and leave how to the system that delivers it. This page sets out what an intent engine is, how intent relates to the service models orchestrators already use, and how intent is turned into a running system.
Imperative orchestrators are told how: the exact actions to take, as in infrastructure as code. Declarative orchestrators are told what: the result to achieve, and choose the actions themselves.
A declarative description can say what a system looks like, its components and their relationships, in a service model. Or it can say what the system must do, its expected behavior and outcomes, in policies.
An intent engine is a declarative orchestrator that lets people specify the services they want with declarative policies that express business goals, and maps those goals onto components, resources and configuration.
A system can be described at several levels of abstraction, each suited to a different role:
Most model-driven tools only accept the device view: deployment descriptors that list the software to install and the resources to host it. A model continuum lets people describe a system at the level that suits them and leaves the translation down to the device view to the orchestrator.
A declarative policy constrains the observable capabilities of a system within a context. A service model is that context: its parameters are the capabilities. An intent model combines the two at one level of abstraction.
The same pattern applies at each level of the continuum, from business goals down to device configuration, giving a continuum of intent models rather than separate model and policy hierarchies.
Rather than translating business goals into deployment descriptors in one step, each intent model is refined into the intent models one level down: the service model into a lower-level topology, and its constraints into constraints on that topology.
Software architects refine high-level designs into lower-level ones as a matter of course, and recursive decomposition is how. TOSCA supports it in the language itself: with substitution mappings, any node in a service topology can be realized by a complete service topology of its own, which can be decomposed in turn.
Ubicity is built on this. One orchestrator manages every level of the hierarchy, refining abstract models into deployable ones and keeping each level in step with the system that realizes it. See how Ubicity works.
A growing number of tools put a large language model in the control loop, letting it decide and act on running systems. That makes operations non-deterministic and hard to audit, which is the wrong trade for systems that have to keep running.
Ubicity’s position is that AI belongs at the intent boundary, and determinism belongs inside the formal model. Turning loosely stated human goals into a precise model is where a language model helps. Everything below that, refining the model, validating it and carrying it out, stays with a deterministic orchestrator that checks every proposal against the model before anything runs. AI proposes models people can review; it never changes a running system.
Evaluation licenses for the Ubicity Orchestrator are available.