Most digital systems feel complete.
They can identify who is acting, verify what that actor holds, and determine what actions are permitted.
And yet something still breaks.
The failure is not obvious. It does not appear as an error or a rejected request. The system executes correctly. The logs are clean.
But the action itself is wrong.
An agent acts outside their mandate. A consent artefact is reused for a different purpose. An action is signed by the correct key, but in the wrong capacity. Nothing in the system flags it. Because the system was never designed to ask that question.
Modern digital infrastructure is good at authentication and permission. It does not model authority.
It can tell you who controls a key. It can tell you what credentials are valid. It can tell you whether a rule is satisfied.
But it cannot tell you:
In what capacity is this actor acting, under what authority, and is that authority valid right now?
Authority is implied through roles, interfaces, or institutional context. Consent is performed through clicks and signatures. Delegation is approximated through tokens and keys. Revocation is rarely checkable in real time.
That is a different kind of question.
Authorisation asks whether an action may proceed. Authority determines whether that action is legitimate in context. The first is a system check. The second is a condition of legitimacy.
The distinction matters because an action can satisfy every rule in a system and still fail outside it. Legal and institutional systems have always recognised this. A clerk acts under the authority of an office. An agent acts under the authority of a principal. A decision binds only when it is made within the scope of a mandate.
When authority becomes ambiguous, responsibility dissolves.
Digital systems, however, tend to collapse these distinctions. Identity, permission, and action are treated as if they are sufficient conditions for legitimacy. If a key is valid and a policy passes, the system assumes the action is acceptable.
But validity is not the same as authority.
As more systems begin to act autonomously – through APIs, smart contracts, and increasingly through AI agents – this gap becomes harder to ignore. An AI agent creates a dating profile because nothing told it that action was outside its mandate. A delegation is replayed for a different transaction because nothing encoded its original scope. Execution is no longer the constraint. Systems can already act at scale.
The question is whether they are acting under conditions that can be recognised, constrained, and relied upon.
At present, those conditions are rarely made explicit.
These are not failures of implementation. They reflect a deeper absence in the structure of digital systems.
Something is missing between identity and execution.
Not another application layer. Not new credential formats or more authorisation rules.
A way of expressing the conditions under which an actor is in a position to act at all.
Until that layer becomes explicit, systems will continue to operate on assumptions that cannot be verified, audited, or revoked in a meaningful way.
The systems we are building can execute actions at scale. They cannot yet justify them.
This is the problem SILT Core is designed to address: making the conditions of action explicit, before execution. Previous essay: Who Authorised the Agent?
This essay forms part of an ongoing research series exploring identity, authority, and governance in digital systems.
Explore the work:
SILT Core specification and documentation
Technology, governance, and identity projects
https://www.garethfarry.com/technology
View The Release:
https://github.com/Sugarlicks/silt-identity-core/releases
