SILT - Self-actualised Identity Layer Tool
Part of Law and Technology Architectures
Identity, lawful status, and agency – before platforms, before permissions.
SILT (Self-Actualised Identity Layer Tool) is a conceptual and technical framework for modelling authority, consent, delegation, and revocation in digital systems.
SILT is a long-term research and infrastructure project concerned with a deceptively simple question:
How is a person recognised as capable of acting, consenting, and binding themselves or others in law?
This question has become urgent in ways its framers did not anticipate. As AI agents begin to act on behalf of humans – transacting, delegating, consenting – the absence of this layer is no longer theoretical.
Modern identity systems rarely ask this directly. They begin further downstream – with accounts, credentials, permissions, dashboards. They assume legitimacy has already been settled somewhere else.
SILT moves upstream.
It treats identity not as a credential issued by an institution, but as lawful standing expressed through capacity, mandate, and recognised authority. Identity, in this sense, is not a profile or a document. It is the condition under which action becomes intelligible, enforceable, and contestable.
This work does not begin with an app, or wallet or chain – It begins where law and exchange have always begun – with the moment one party claims I can act, and another decides whether that claim can be relied upon.
The problem SILT insists we face
Most contemporary identity systems are adept at answering surface questions:
Who is this user?
What attributes can they prove?
What permissions have they been granted?
They struggle with the questions that actually govern legitimacy:
In what capacity is this entity acting?
By what authority may they bind themselves or others?
How is consent scoped, limited, withdrawn, or revoked?
What persists when platforms, providers, or jurisdictions change?
When these questions remain implicit, authority drifts upward by default. Consent hardens into compliance, and delegation becomes capture. Identity turns into something you are issued, rather than something you enact.
SILT treats this not as a technical oversight, but as a missing semantic layer in modern infrastructure – one with legal, cultural, and political consequences.
A necessary clarification
In modern systems, the word person carries more weight than it appears.
It names legal capacity, but often obscures where that capacity originates. The living individual and the administrative forms through which law and commerce operate are treated as one and the same.
SILT draws a careful distinction. Capacity originates in the living being. The person is an instrument – a legal and administrative form through which that capacity may be expressed, delegated, or constrained, but not created.
This distinction is not rhetorical. It is structural, ontological.
When systems fail to separate source from instrument, authority is silently reassigned. When they do, agency becomes legible again.
SILT Core
The first architectural step – https://siltcore.org/
SILT is the wider project.
SILT Core is where the work begins.
SILT Core is a spec-first identity infrastructure initiative that deliberately narrows the field. It focuses on a small set of foundational questions most systems quietly defer:
Who is acting?
In what capacity?
By what authority?
Under what constraints?
With what ability to revoke or withdraw?
Rather than delivering a platform or application, SILT Core defines the missing semantic layer that civic systems, governance tools, and high-trust digital environments already depend on, but rarely specify, and seldom interrogate.
It addresses identity at the level of status, authority, consent, and revocation – not attributes, profiles, or accounts.
What SILT Core actually does
SILT Core currently focuses on:
• Normative specifications for principals, roles, standing, authority, and mandate
• Clear treatment of consent as a constraint rather than a one-time gesture
• Threat models documenting common identity failure modes
• Minimal schemas that make authority and consent explicit, auditable, and revocable by default
Implementation is intentionally deferred.
SILT Core is designed to be adopted, critiqued, or extended by multiple downstream systems without locking identity into a particular platform, wallet, ledger, or custody model.
Design principles
A small number of principled guardrails do most of the work:
Status before attributes Identity begins with standing and authority, not claims or credentials. A system that knows everything about a person's attributes but nothing about their capacity to act has not established identity — it has assembled a profile. SILT begins where legitimacy actually originates.
Consent as constraint Consent must be scoped, enforceable, and revocable — not implied, not permanent, and not reducible to a single click at the point of onboarding. This means consent is treated as an ongoing structural condition of the relationship, not a one-time gesture that authorises everything downstream.
Delegation without capture Authority may be delegated without collapsing the principal into the system that receives it. This is the failure mode most identity architectures reproduce quietly: the moment you delegate, the delegatee accumulates authority that was never meant to be transferred. SILT encodes the limits of delegation as explicitly as the delegation itself.
Technology-agnostic by design No dependency on blockchains, wallets, or specific cryptographic primitives. This is not neutrality — it is a deliberate refusal to allow implementation choices to determine semantic commitments. The semantics must be legible and defensible independently of whatever infrastructure carries them.
Specification before implementation Clarity and legibility come before optimisation or deployment. Identity infrastructure that is built before its concepts are fully specified tends to reproduce the assumptions of its builders. SILT insists on making those assumptions explicit – and contestable – before any implementation locks them in.
How SILT relates to existing identity infrastructure
SILT is not a replacement for existing identity standards. It is a layer beneath them — one that existing systems depend on but have not fully specified.
W3C Decentralised Identifiers (DIDs) provide a method for creating and resolving globally unique, cryptographically verifiable identifiers without a central registry. This is necessary and valuable. What DIDs do not address is what the identifier means in terms of legal standing, capacity, and authority. A DID tells you that an entity controls a key. It does not tell you whether that entity has the capacity to bind themselves in law, or in what role they are acting. SILT operates at the layer below the identifier — where capacity and standing originate.
Verifiable Credentials (VCs) allow claims about a subject to be issued, held, and presented in a cryptographically verifiable form. SILT complements this: credentials are most meaningful when the subject's capacity to hold and act on them is itself legible. A credential that says "qualified lawyer" presupposes a framework for understanding what legal personhood, standing, and authority actually mean. SILT makes that presupposition explicit.
Self-Sovereign Identity (SSI) as a movement shares SILT's commitment to returning control of identity to individuals. The difference is one of depth. Most SSI implementations focus on the control and portability of attributes and credentials. SILT goes further, asking what it means to be a sovereign principal in the first place – what standing, what capacity, what limits on delegation, and what conditions of revocation actually constitute self-sovereignty in a legal sense.
eIDAS (EU) and equivalent national digital identity frameworks address identity assurance for legal and administrative purposes within defined jurisdictions. They are effective within their scope but structurally dependent on state recognition and administrative registration. SILT asks what happens to identity and capacity in contexts where state recognition is unavailable, contested, or structurally exclusionary – for stateless people, indigenous communities operating under distinct legal traditions, or agents acting across jurisdictions with incompatible identity regimes. These are not edge cases. They are the stress tests that reveal whether an identity architecture is genuinely foundational.
In short: SILT does not compete with DIDs, VCs, SSI, or eIDAS. It specifies the layer those systems quietly rely on. The question is not which standard to adopt — it is whether the semantics beneath any of them are explicit enough to hold under pressure.
What comes next?
SILT Core is not the end state. It is the foundation — and the work is sequenced deliberately.
Phase 1 — Specification (current) The core normative specifications for principals, standing, authority, consent, and revocation are in active development at siltcore.org. This phase prioritises legibility and rigour over completeness. The goal is a stable, contestable specification that downstream systems can adopt, critique, or extend — not a finished product.
Phase 2 — Critique and stress-testing The specification will be opened for structured review across legal, governance, and technical communities. This is not a consultation — it is adversarial testing. The aim is to find the cases where SILT's primitives fail, and to understand whether those failures are fixable within the current architecture or require deeper revision, in collaboration with legal scholars, DAO governance practitioners, and digital rights researchers.
Phase 3 — Reference implementations Once the semantics are stable enough to withstand pressure, reference implementations will follow. These will not be platforms or applications – they will be minimal, legible demonstrations that the specification can be instantiated in real systems without distortion. Initial implementations will focus on governance tooling and high-trust civic coordination contexts.
Phase 4 — Applications and instruments The broader SILT project will then explore how these primitives support lawful private exchange, new forms of governance, and civic and economic coordination at scale. Instruments and applications may follow – but only once the layer beneath them is explicit enough to hold.
This sequencing matters. Identity infrastructure built before its concepts are fully specified tends to reproduce the assumptions of its builders – quietly, structurally, and at scale. SILT does not seek to replace institutions overnight. It seeks to restore a layer they rely on but rarely acknowledge.
Identity, not as a product. Not as a permission. But as lawful capacity — originating in the living man or woman, expressed through instruments, and recognised in relation.
History as evidence, not nostalgia
For most of human history, identity and exchange operated without central registries or issuing authorities.
Merchants, artisans, indigenous communities, and kin-based societies coordinated trade, credit, and obligation through recognised standing, expressed intent, and explicit delegation. Authority was contextual, as consent was performative and relational. The right of revocation was understood.
These systems were plural by design. They crossed borders, languages, and cosmologies without collapsing difference into a single grammar. What they shared was a common logic: identity was a capacity to act, not a credential to be held. Dishonourable commerce carried ecosystem consequences: reputational harm, loss of standing, and diminished access to future exchange.
Modern administrative identity flattened these practices into registration, compliance, and account control. This enabled scale, but at a cost. The semantics that once made peer-to-peer exchange intelligible were pushed out of view.
SILT treats this history as proof that other arrangements are possible – and that contemporary failures are architectural, not inevitable.
Collaboration and conversation
SILT is a spec-first project, which means its development depends on rigorous challenge as much as on contribution. The work is stronger when it encounters people who have tried to solve adjacent problems and found the current tools inadequate.
If any of the following describes you, I would like to hear from you:
You are building governance systems – for DAOs, civic institutions, or distributed organisations – and have run into the limits of existing identity infrastructure when trying to encode authority, delegation, or accountability with legal rigour.
You work in digital rights, human rights law, or access to justice – and are concerned with what identity means for people whose standing is contested, unrecognised, or structurally excluded from conventional systems.
You are designing AI agent infrastructure – and are grappling with the question of how delegated authority should be represented, constrained, and audited as autonomous systems begin to act on behalf of human principals.
You are a legal scholar, philosopher, or theorist – working on questions of personhood, capacity, or the legal status of non-human actors, and want to engage with an infrastructure project that takes those questions seriously at the architectural level.
You are a funder or institutional partner – exploring how foundational identity infrastructure can be developed as a public good rather than a proprietary layer.
SILT Core is open. The specification is on GitHub. The conversation is at garethfakhry@gmail.com.
Github Link: https://github.com/Sugarlicks/silt-identity-core
Recent writing:
Who Authorised the Agent? AI Delegation and the Missing Legal Identity Layer
An essay examining why autonomous AI systems require a legal identity layer capable of encoding authority, mandate, and revocation.