Introduction
The conversation around agentic AI has raced ahead of the foundations it claims to build on. Vendors speak endlessly about promises and accountability, yet they are missing the core framework that gives those concepts meaning Promise Theory, developed by Mark Burgess. As a result, many agentic systems borrow the language of Promise Theory while overlooking the principle Burgess placed at its core: integrity.
Integrity in Burgess’s sense isn’t what most marketing material implies. It isn’t whether an agent produced the right answer today, or whether its last decision passed an eval. It’s whether what an agent commits to and what an agent actually does stays aligned over time. Across cycles, across drift, across retraining. That’s a higher bar than most agentic AI systems clear, and it matters most for agentic AI specifically, since nothing else in IT updates and adapts on its own quite the way an AI agent does.
This blog is a return trip to the source: what Burgess meant by integrity, what an agentic system has to do to claim it, and why so few claim it honestly.
What is Meant by “Integrity”
Promise Theory describes a world made of autonomous agents that can only make commitments about themselves. Humans, machines, services, and AI models have the same rule. No agent can credibly promise on behalf of another. Cooperation, in Burgess’s account, is the slow work of building up declared promises that other agents voluntarily accept and then verify.
Integrity is what holds that work together. It’s the property an agent has when its actions stay aligned with what it said it would do, not just once but across many cycles and many shifts in conditions. Being right today doesn’t count for much. Being the same agent tomorrow, committed to the same things in roughly the same way, is what integrity means here.
Worth pausing on what that rules out. An agent that promises X and delivers X under perfect lab conditions is consistent. That isn’t integrous. An agent that promises X, runs into drift over six months, and quietly starts delivering Y while still labelling its outputs as X has lost integrity, even if no single output looks wrong from the outside. Burgess treats integrity as evidence accumulated over time, not something you can possess in a moment.
Why This Matters More for Agentic AI Than for Traditional Systems
Traditional software is mostly static. When its behaviour shifts, a human has changed something, and that change is auditable.
Agentic AI doesn’t work like that. The agents making promises today are not, in any operationally meaningful sense, the same agents that will be acting next quarter. Models get retrained. Prompts get tuned. Dependencies move. Even when nothing changes on purpose, behaviour drifts from new inputs and contexts. Burgess’s idea of integrity stops being an academic nicety in that environment. It becomes the single most important governance property an agentic system can have.
Here’s where it gets uncomfortable for the current state of agentic AI marketing. “The agent kept its promise this time” is not the same sentence as “the agent has integrity,” and a fair amount of what gets sold as the second is really the first wearing a costume.
Is Your AI Agent Keeping Its Promises?
Four Foundational Principles, Applied to Agentic Systems
Burgess put forward a small number of foundational principles. Applied honestly, they make integrity buildable. He wrote them well before agentic AI was a category, and they describe today’s situation almost uncannily.
Promises, not impositions
The central distinction is between a promise and an imposition. A promise is something an agent declares about its own behaviour. An imposition is what happens when one agent tries to dictate another’s behaviour from outside. Burgess argued at length that impositions don’t reliably work where the receiving agent is autonomous. They get ignored, misinterpreted, or quietly absorbed and forgotten.
This contradicts how most agentic AI is governed today. Vendors layer a controlling orchestrator over a set of agents and call the orchestrator’s directives “promises.” They aren’t. They’re impositions wearing the vocabulary of cooperation. A real promise comes from the agent that controls the behaviour, and integrity is whether that agent keeps the promises it made, not whether it obeys someone else’s.
Autonomy of the agent
Burgess’s corollary is that only the local agent can really know what it’s capable of delivering. An external system can guess, sometimes pretty well, but the agent itself is where the evidence lives. Systems that hardcode commitments into a governing layer instead of letting the agents declare what they can do are setting themselves up for the exact quiet-failure mode Promise Theory was designed to catch.
This has real teeth for AI agents. The agent knows its current confidence. It knows its current context. It knows its current model state. A central orchestrator above it knows none of those in real time. Letting the agent declare its own commitments and then verifying those declarations independently, rather than imposing alternatives, is the architectural baseline for any system that wants integrity.
Voluntary cooperation
Cooperation between autonomous agents, in this framework, emerges from voluntarily declared promises that other agents choose to depend on. Nobody’s compelled. What makes cooperation function is that commitments are visible and verifiable, so other agents structure their behaviour around the ones they trust.
Architectures that swap orchestration in for voluntary cooperation tend to crack under stress. One agent fails or drifts, and the whole plan needs a rewrite. With agents cooperating through declared promises, the failure of one is a local event. Other agents just stop relying on the promise that broke and carry on.
Trust as assessment, not assumption
The last principle is the one most often glossed over: trust is not given in Burgess’s framework. Trust is assessed. The longer an agent runs, the more evidence accumulates about which promises it actually keeps, and trust is whatever the evidence supports. It isn’t something baked in at design time and shipped with the product.
For agentic AI, this is exactly the basis of integrity. An agent has integrity because the running record of promise-keeping, over time, supports the claim. Without that record, kept independently and kept honestly, the word becomes another piece of marketing furniture.
What Integrity Requires in Practice
Translated into operating requirements, what Burgess described needs more than most agentic AI vendors are delivering. There has to be independent verification: the system judging whether a commitment was kept can’t be the agent that made it. Every autonomous decision needs lineage back to its commitment, its inputs, and the policy version in force at the time. The history of what was promised, and when, has to be kept separately from what was delivered, and immutable. Commitments themselves should evolve openly as agents learn, not get quietly redefined to match drifting behaviour.
None of these is a feature. They’re governance preconditions. A system missing any one of them cannot honestly claim integrity in the sense Burgess gave the word.
How Scout Honours These Foundational Principles
Inside Scout’s Agentic Workforce Framework, agent governance was designed around these principles, not retrofitted onto something already built. Every agent owns the commitments it makes. Orchestrators handle routing and escalation, but they don’t get to override the promises individual agents have already declared. What sits between an orchestrator and its sub-agents is voluntary cooperation, not top-down control.
Scout’s Promise Theory engine is the accountability layer. It checks agent behaviour against declared commitments through independent verification, meaning whichever agent made the promise isn’t the one allowed to judge whether the promise was kept. Every autonomous decision gets a structured lineage that points back at its commitment, the inputs it acted on, and the policy version in effect at the time. Boundaries of accountability between agents are explicit on purpose, and the record of promise-keeping accrues as actual evidence rather than as assertion.
Scout applies these principles. It doesn’t own them. Burgess’s framework is bigger than any product, and the work of building agentic systems with real integrity isn’t finished anywhere yet.
A Framework for Evaluating Agentic AI
As agentic AI becomes more autonomous, integrity should be measured through evidence rather than assumptions. Look for agents that make their own commitments, independent verification of those commitments, and a transparent record of promise-keeping over time. These principles provide a practical foundation for evaluating trustworthy AI governance.
Conclusion
Integrity is what transforms agentic AI from autonomous decision-making into trustworthy autonomous decision-making. By grounding governance in verifiable commitments, independent verification, and evidence accumulated over time, organizations can build AI systems that remain accountable as they evolve. To see these principles in practice, explore how Scout applies Promise Theory governance inside the Agentic Workforce Framework and discover how a governance-first approach helps build more reliable, transparent, and trustworthy AI agents.
Frequently Asked Questions
Mark Burgess is the person who originally formulated Promise Theory, the formal framework for understanding how autonomous agents cooperate through declared commitments instead of imposed commands. His foundational principles, written for distributed systems decades before agentic AI existed as a category, describe almost exactly the trust and governance problems agentic systems are running into today.
In the Promise Theory tradition, integrity is the property of an agent’s behaviour staying consistent with its declared commitments over time, across many cycles and conditions. It’s not the same as being right in the moment; integrity is a property accumulated through evidence.
A promise is a voluntary commitment an autonomous agent makes about its own behaviour. An imposition is a command issued by one agent trying to control another’s behaviour from outside. Burgess argued, persuasively, that impositions cannot be enforced reliably wherever the receiving agent is autonomous, which is exactly the case in agentic AI.
Because only the local agent has the information needed to declare what it can deliver. External governance layers can estimate, but the agent itself is where the current context, confidence, and model state actually live. Letting agents make their own commitments and verifying them independently is the architectural foundation Burgess set out.
As something assessed through observed promise-keeping over time, not assumed at design or at deployment. Trust is the accumulated record of which commitments an agent kept not a property baked in by whoever built the system.
Because agents update, retrain, and adapt in ways traditional software just doesn’t. Behaviour drifts under the influence of new inputs, retrained models, and changing contexts. Without explicit, verifiable commitments and an evidence trail over time, integrity becomes impossible to claim honestly.
Voluntary cooperation emerges from agents declaring promises other agents choose to depend on, with no central authority enforcing anything. Orchestrated cooperation depends on a controlling layer issuing directives. Burgess argued that the first scales and survives individual failure, while the second gets brittle as autonomy increases.
Independent verification of every commitment, structured lineage from each decision back to its commitment and inputs, an immutable record of what was promised and when, commitments that evolve openly rather than getting quietly redefined, and a running record of promise-keeping that someone can actually read and assess.
By treating each agent’s commitments as the agent’s own, validating behaviour through an independent Promise Theory engine, recording lineage from every autonomous decision back to its commitment and inputs, and keeping accountability boundaries between agents explicit. Scout applies these governance principles but doesn’t claim to own them.
His books Thinking in Promises (with Jan Bergstra) and In Search of Certainty are good starting points, along with the writing at markburgess.org. Those are the primary sources for engaging with Promise Theory directly, rather than through anyone’s interpretation of it.
Tony Davis
Director of Agentic Solutions & Compliance
