Mark Burgess developed Promise Theory in the early two-thousands as a way to think about distributed system configuration. The central claim is that obligations cannot be imposed across autonomous agents. They can only be promised by the agent. A node in a distributed system cannot be ordered to do anything. It can only promise to do something, and the rest of the system has to plan for the case where the promise is not kept.
The framework was developed for sysadmins managing thousands of machines. It applies, almost without translation, to managing teams of humans.
Most organizational dysfunction comes from imposing what should be promised.
A manager assigns a task. The employee accepts the assignment. The manager treats the assignment as a guarantee. The employee treats the assignment as best-effort. When the task is not delivered, the manager is surprised, the employee is defensive, and the actual cause, that an obligation was imposed without a corresponding promise, goes unexamined.
The Promise-Theory-correct version. The manager makes an offer. The employee promises a specific deliverable, with a specific scope, by a specific date, with specific caveats about what will cause the promise to fail. The manager plans accordingly. If the promise fails, the manager has the caveats already on file and the failure is informative rather than surprising.
The framework looks like extra ceremony until you have run a team where it is missing. Then it looks like the only sane way to coordinate.
Three places I have applied this in my own work.
Client engagements. Every engagement now includes a written promise from me about what I will deliver, what I will not deliver, what the client must promise in return for me to deliver, and what triggers a renegotiation. The clients I have lost from this discipline were clients who would have lost me money. The clients I have kept are clients who value the precision.
Subcontractor coordination. I no longer assign tasks. I describe what I need and ask for a promise. The promise comes back with caveats. The caveats become the contract. When a caveat fires, neither party is surprised.
AI agent orchestration. Agents in a multi-step workflow are autonomous in the same sense distributed nodes are. You cannot impose obligations on an agent. You can prompt for a promise, parse the promise's caveats, and route around the caveats when they fire. Treating agents as Promise-Theory nodes makes the orchestration code legible. Treating them as deterministic functions produces the brittle agent stacks people complain about.
Burgess's writing is dense and the books are not light reading. The concepts repay the difficulty. I re-read sections of In Search of Certainty every six months and find something I missed.
If you are choosing one entry point, his paper Promise You A Rose Garden is a good short version. The full books are for when you are ready to commit.