Ubicity

Intent-based orchestration

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.

Intent engines and orchestrators

Imperative and declarative

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.

Structure and behavior

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.

What makes an intent engine

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.

The model continuum

A system can be described at several levels of abstraction, each suited to a different role:

  • Business view: the service as a product offered to its users, and the business goals it must meet.
  • System view: the system architecture of the service.
  • Administrator view: the technologies used for each component of that architecture.
  • Device view: the software modules and resource configurations of every component.
  • Instance view: the configuration of each running instance.

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.

Intent models

Models and policies together

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.

An intent model at every level

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.

Mapping intent recursively

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.

Recursive decomposition in TOSCA

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.

Where AI belongs

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.

See it on your own systems

Evaluation licenses for the Ubicity Orchestrator are available.

© 2026 Ubicity Corporation. All rights reserved.