The previous posts - particularly Conceptual Spaces, What is a State Space?, and Graphs and Service Representations - have explored state spaces: what they are, how they are constructed, and how they can be represented as graphs where connectivity and relational structure matter as much as geometric position. But state spaces capture only one dimension of the picture. States describe how things are; they do not, by themselves, describe how things relate - how agents coordinate, how services get delivered, how cooperation emerges. This post introduces Promise Theory, developed by Mark Burgess (2015), as a formal framework for thinking about cooperation between autonomous agents, one that offers a radically different foundation for thinking about services by starting not from states and transitions but from voluntary commitments.
The Problem with Obligations
Most frameworks for thinking about coordination assume obligations. Contracts specify what parties must do; service level agreements define requirements; project plans assign tasks. The logic runs: if we specify obligations clearly enough and enforce them effectively, coordination will follow. Promise Theory inverts this. Burgess's key insight is that obligations are imposed from outside, but behaviour originates from inside; you can write a contract requiring someone to do something, but whether they actually do it depends on them. The contract does not cause the behaviour; at best, it creates incentives. The gap between obligation and behaviour is where most coordination failures live.
Promises, by contrast, are voluntary declarations made by the agent who will keep or break them. A promise says: "I intend to do X". It is not imposed; it is offered. The promiser retains agency; the observer assesses whether to trust the promise based on the promiser's track record and context. The distinction between obligation and promise may appear subtle, but its implications for how we think about service systems are substantial.
Agents, Promises, and Graphs
Promise Theory begins with the concept of autonomous agents. An agent, in Burgess's framework, is any entity that can make and keep promises - a person, an organisation, a software service, a device. Autonomy means the agent controls its own behaviour; no external force can make the agent do something; the agent decides. This is a deliberately strong assumption. Burgess (2015, 2017) argues that treating agents as autonomous is more realistic than treating them as controllable, because even in hierarchical organisations, even with contracts and enforcement mechanisms, agents ultimately choose their behaviour. Pretending otherwise leads to brittle systems that fail when the illusion of control breaks down. The starting point is therefore not "how do we control agents?" but "how do agents voluntarily coordinate?"
A promise has a specific structure: a promiser (the agent making the promise and the only one who can keep it), a promisee (the agent to whom the promise is made), and a body (the content of the commitment). The asymmetry between promiser and promisee is crucial: you cannot promise on behalf of someone else, and you cannot impose a promise from outside. A contract is a mutual exchange of obligations, often negotiated from a position of power; a promise is a unilateral declaration of intent. Contracts try to bind; promises try to coordinate.
When multiple agents make promises to each other, the result is a promise graph - a network of commitments. Consider a simple service such as a coffee shop: the barista promises to make coffee; the customer promises to pay; the supplier promises to deliver beans; the landlord promises to provide the premises. Each promise is a directed edge in a graph, from promiser to promisee. The promise graph makes visible the structure of cooperation - who depends on whom, what each agent has committed to, where the trust relationships are, and what happens if a promise is broken. This differs from an organisational chart (which shows hierarchy) or a process map (which shows sequence); the promise graph shows the commitment structure, the voluntary or contracted agreements that enable the service to function, assuming those promises are upheld.
Why This Matters for Services
Service design typically describes services in terms of touchpoints, journeys, and processes. These are valuable perspectives, but they share a common assumption: that the service can be designed from the outside and implemented as specified. Promise Theory suggests a different view. A service is not a designed artefact that gets implemented; it is an emergent pattern of kept promises among autonomous agents. The coffee shop exists because multiple agents voluntarily coordinate. The barista could quit; the supplier could fail to deliver; the customer could go elsewhere. The service persists not because of control but because the promises keep being made and kept.
This reframing has practical consequences. Resilience comes from redundancy of promises, not tightness of control; if the service depends on a single agent keeping a single promise, it is fragile, whereas if multiple agents can make equivalent promises, the service is robust. Trust is earned through promise-keeping, not guaranteed by contract; customers trust the coffee shop because past promises have been kept - not merely the mundane delivery of a cup of coffee, but perhaps the delivery of some social projection by being able to be seen at a certain coffee shop, or in fulfilling one's desire to be dairy-free by being able to receive the promise of an oat milk latte. New services must build trust through demonstrated reliability. And when coordination failures occur, Promise Theory directs attention to which promises were broken, by whom, and why - a more diagnostic framing than asking what went wrong with the process.
Promises and States
How does Promise Theory relate to the state space thinking developed in the preceding posts? The two perspectives are complementary. State spaces describe what is - configurations of variables at moments in time; a state tells you the current situation, and transitions tell you how situations change. Promises describe what will be - commitments about future behaviour; a promise tells you what an agent intends to do, and trust tells you how likely the promise is to be kept. In a service context, the state of a customer might be "has ordered, waiting for coffee", while the promise from the barista might be "I will prepare your order within five minutes". The state is descriptive; the promise is performative. The state captures the present; the promise shapes the future. Understanding how a service works requires both.
One way to connect the two: promises constrain state transitions. If the barista promises to prepare the order - perhaps on receipt of a promise from a global payments provider that they will deliver the money from the customer's bank account to that of the coffee chain - such a promise, and the trust that underpins it, constrains the space of likely future states, increasing the probability that the customer will receive their coffee. The promise does not guarantee the transition (the barista might fail, the machine might break down, thereby creating a demand for the coffee chain's maintenance contracts and their associated promises), but the promise makes certain future transitions and state spaces more probable than they would be without it.
The Service as Promise Network
Majid Iqbal (2018), whose work the next post explores in detail, builds on Promise Theory to develop a complete framework for service design. His core insight is that services are "arrangements and agreements - agreements between people and arrangements between things". The arrangements - how things are configured - correspond to state. The agreements - what people commit to - correspond to promises. A service exists at the intersection: a network of promises that enable certain arrangements to persist. Iqbal identifies four fundamental promises in any service: the provider promises outcomes to the customer; the customer promises inputs (payment, information, cooperation) to the provider; the provider promises experiences to the user; and the user promises engagement to the provider. These form a minimal structure that any service must have; more complex services layer additional promises on top of this foundation. This gives us a grammar - not in the linguistic sense of syntax rules, but in the generative sense of a system that produces valid forms, analogous to what Wilkinson's Grammar of Graphics specifies for statistical visualisation.
If services are promise networks, then service design is the work of identifying what promises are needed for the service to function, designing the arrangements that enable agents to keep their promises, building trust through demonstrated reliability, and handling what happens when promises are broken. This is different from designing processes or touchpoints; it is designing the commitment structure that makes the service possible.
At SCÖ, part of what was missing was precisely this commitment structure. The project had plans and milestones, but it was not clear what the Swedish organisations were promising to provide - data, infrastructure, capacity - or what the UK and Swedish academics were promising to deliver: a working system, knowledge transfer, research outputs, or all three. It was not clear what the funders expected in return for their investment, although the consortium had certainly made certain promises to the funders in order to secure funding. And it was not clear who would keep which promises, or how. The project was designed as a process to be executed, not as a promise network to be sustained. When the implicit promises could not be kept - because the data did not exist, the infrastructure was not there, the capacity had not been built - the process continued in form while failing in substance.
From Promises to Grammar
Promise Theory gives us a foundation: autonomous agents, voluntary commitments, trust built through keeping promises. It is a way of thinking about the deep structure of cooperation. But it remains abstract. To be useful for design, we need more concrete tools - ways to specify promises, compose them into services, and reason about whether a service design is complete and coherent. That is what Iqbal provides in Thinking in Services: he takes Promise Theory and builds a design grammar on top of it, a systematic way to encode and express services through their promise structures.
Next: "Thinking in Services: Iqbal's Programmatic Grammar" - how Majid Iqbal builds on Promise Theory to create a rigorous framework for service design.
References
Burgess, M. (2015). Thinking in Promises: Designing Systems for Cooperation. O'Reilly Media.
Burgess, M. (2017). A Treatise on Systems. ChiTek-i.
Burgess, M. (2020). A Treatise on Systems Volume 2. ChiTek-i.
Iqbal, M. (2018). Thinking in Services: Encoding and Expressing Strategy Through Design. BIS Publishers.